arg? — optional arg; arg* — zero or more args; arg+ — one or more args; argenv — looked up in the environ; arg = val — arg with default; :: type — argument type; [*-arg arg] — default from environ values name-arg followed by arg

word to include a tag containing the word, -word to exclude. Prefix with m: for modules, kind:(note|control|pitch|val) for call kinds, or type:(val|generator|transformer) for call types.
You can also search by %control, arg default (name-arg), and call kind (note, control, ...).
Search for calls with the browser's text search, "call --" to search by binding, "-- call" to search by name.
Common tags are documented at Derive.Call.Tags.

x

note

Module: bali.gangsa (25 calls)

' -- ngoret
generator
'^ -- ngoret
'_ -- ngoret
Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
This requires the realize-ngoret postproc.
Tags: inst, ornament, requires-postproc
  • time :: ControlRef = %ngoret-time,.1s [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
  • damp :: ControlRef = %ngoret-damp,.15s [*-damp] — Time that the grace note overlaps with this one. So the total duration is time+damp, though it will be clipped to the end of the current note.
  • dyn :: ControlRef = %ngoret-dyn,.75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
  • damp-thresholdenv :: Num (RealTime) = .15s [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
'n -- ngoret
generator
Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
This requires the realize-ngoret postproc.
Tags: inst, ornament, requires-postproc
  • interval :: Num (Transposition, default diatonic) [*-interval] — The grace note is this interval from the destination pitch.
  • time :: ControlRef = %ngoret-time,.1s [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
  • damp :: ControlRef = %ngoret-damp,.15s [*-damp] — Time that the grace note overlaps with this one. So the total duration is time+damp, though it will be clipped to the end of the current note.
  • dyn :: ControlRef = %ngoret-dyn,.75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
  • damp-thresholdenv :: Num (RealTime) = .15s [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
cancel-pasang -- cancel-pasang
transformer
This is like the cancel call, except it also knows how to cancel out pasang instruments such that adjacent kotekan calls can have initial and final notes, but won't get doubled notes.
Tags: postproc
  • final-duration :: Num (RealTime) = 1s [final-duration] — If there is no following note, infer this duration.
f- -- f-
transformer
final = f. Kotekan calls won't emit a final note at the end time.
    gnorot -- gender-norot
    generator
    Gender-style norot.
    Tags: inst
    • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
    • kotekanenv :: ControlRef = .15 [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
    • inst-polosenv :: Str [inst-polos] — Polos instrument.
    • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
    • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
    • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
    i+ -- i+
    transformer
    initial = t. Kotekan calls will emit a note on the initial beat.
      i- -- i-
      transformer
      initial = f. Kotekan calls won't emit a note on the initial beat.
        k -- kotekan
        generator
        Render a kotekan pattern from a kernel representing the polos. The sangsih is inferred.
        Kotekan calls perform a pattern with inst-polos and inst-sangsih. They line up at the end of the event but may also emit a note at the start of the event, so use cancel-pasang to cancel the extra notes. Ngubeng kotekan is naturally suited to positive duration, while majalan is suited to negative duration.
        Tags: inst
        • kernel :: Str [kernel, *-kernel] — Polos part in transposition steps. This will be normalized to end on the destination pitch. It should consist of -, 1, and 2. You can start with k to avoid needing quotes. Starting with k will also require the length to be a multiple of 4.
        • style :: Str (telu pat) = telu [style, *-style] — Kotekan style.
        • sangsih :: Maybe Str (u d) = Nothing [sangsih, *-sangsih] — Whether sangsih is above or below polos. If not given, sangsih will be above if the polos ends on a low note or rest, below otherwise.
        • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
        • kotekanenv :: ControlRef = .15 [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
        • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
        k\\ -- kotekan
        generator
        k// -- kotekan
        Render a kotekan pattern where both polos and sangsih are explicitly specified. This is for irregular patterns.
        Kotekan calls perform a pattern with inst-polos and inst-sangsih. They line up at the end of the event but may also emit a note at the start of the event, so use cancel-pasang to cancel the extra notes. Ngubeng kotekan is naturally suited to positive duration, while majalan is suited to negative duration.
        Tags: inst
        • style :: Str (telu pat) = telu [style, *-style] — Kotekan style.
        • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
        • kotekanenv :: ControlRef = .15 [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
        • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
        k\\2 -- kotekan
        generator
        k\\- -- kotekan
        k//2 -- kotekan
        k//^ -- kotekan
        Render a kotekan pattern from a kernel representing the polos. The sangsih is inferred.
        Kotekan calls perform a pattern with inst-polos and inst-sangsih. They line up at the end of the event but may also emit a note at the start of the event, so use cancel-pasang to cancel the extra notes. Ngubeng kotekan is naturally suited to positive duration, while majalan is suited to negative duration.
        Tags: inst
        • style :: Str (telu pat) = telu [style, *-style] — Kotekan style.
        • sangsih :: Maybe Str (u d) = Nothing [sangsih, *-sangsih] — Whether sangsih is above or below polos. If not given, sangsih will be above if the polos ends on a low note or rest, below otherwise.
        • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
        • kotekanenv :: ControlRef = .15 [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
        • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
        k_\ -- kotekan
        generator
        k-\ -- kotekan
        k//\\ -- kotekan
        Render a kotekan pattern where both polos and sangsih are explicitly specified. This is for irregular patterns.
        Kotekan calls perform a pattern with inst-polos and inst-sangsih. They line up at the end of the event but may also emit a note at the start of the event, so use cancel-pasang to cancel the extra notes. Ngubeng kotekan is naturally suited to positive duration, while majalan is suited to negative duration.
        Tags: inst
        • style :: Str (telu pat) = pat [style, *-style] — Kotekan style.
        • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
        • kotekanenv :: ControlRef = .15 [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
        • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
        ke -- kotekan
        generator
        Render a kotekan pattern from explicit polos and sangsih parts.
        Tags: inst
        • polos :: Str [*-polos] — Polos part.
        • sangsih :: Str [*-sangsih] — Sangsih part.
        • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        kempyung -- kempyung
        generator
        k+ -- kempyung
        Split part into kempyung, with polos-inst below and sangsih-inst above. If the sangsih would go out of range, it's forced into unison.
        If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
        Tags: postproc, subs
        • inst-topenv :: Maybe NotePitch = Nothing [inst-top] — Top pitch this instrument can play. Normally the instrument sets it via the instrument environ.
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        kempyung -- kempyung
        transformer
        k+ -- kempyung
        Split part into kempyung, with polos-inst below and sangsih-inst above. If the sangsih would go out of range, it's forced into unison.
        Tags: postproc
        • inst-topenv :: Maybe NotePitch = Nothing [inst-top] — Top pitch this instrument can play. Normally the instrument sets it via the instrument environ.
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        kotekan -- kotekan
        generator
        Render a kotekan pattern from a kernel. The sangsih part is inferred.
        Kotekan calls perform a pattern with inst-polos and inst-sangsih. They line up at the end of the event but may also emit a note at the start of the event, so use cancel-pasang to cancel the extra notes. Ngubeng kotekan is naturally suited to positive duration, while majalan is suited to negative duration.
        Tags: inst
        • rotation :: Num (integral) = 0 [*-rotation] — Rotate kernel to make a different pattern.
        • style :: Str (telu pat) = telu [style, *-style] — Kotekan style.
        • sangsih :: Str (u d) = u [sangsih, *-sangsih] — Whether sangsih is above or below polos.
        • invertenv :: Str (f t) = f [*-invert] — Flip the pattern upside down.
        • kernelenv :: Str [kernel, *-kernel] — Polos part in transposition steps. This will be normalized to end on the destination pitch. It should consist of -, 1, and 2. You can start with k to avoid needing quotes. Starting with k will also require the length to be a multiple of 4.
        • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
        • kotekanenv :: ControlRef = .15 [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
        • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
        noltol -- noltol
        transformer
        Play the transformed notes in noltol style. If the space between notes of the same (instrument, hand) is above a threshold, end the note with a +muted copy of itself. This only happens if the duration of the note is at or below the kotekan-dur.
        Tags: delayed
        • time :: ControlRef = %noltol,.1 [*-time] — Play noltol if the time available exceeds this threshold.
        • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
        norot -- norot
        generator
        nt -- norot
        nt- -- norot
        nt< -- norot
        nt<- -- norot
        Emit the basic norot pattern. Normally it will prepare for the next pitch if it touches the next note, the nt- variant will suppress that. The nt< variant will also emit a preparation at the note's start.
        Tags: inst
        • style :: Str (default diamond) = default [*-style] — Norot style.
        • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
        • kotekanenv :: ControlRef = .15 [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
        • inst-topenv :: Maybe NotePitch = Nothing [inst-top] — Top pitch this instrument can play. Normally the instrument sets it via the instrument environ.
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
        • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
        nyog -- nyog
        generator
        Nyog cag style. Split a single part into polos and sangsih parts by assigning polos and sangsih to alternating notes.
        If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
        Tags: postproc, subs
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        nyog -- nyog
        transformer
        Nyog cag style. Split a single part into polos and sangsih parts by assigning polos and sangsih to alternating notes.
        Tags: postproc
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        p+ -- p+
        generator
        s+ -- s+
        ps+ -- ps+
        Derive the note with polos, sangsih, or both.
        If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
        Tags: inst, subs
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        p+ -- p+
        transformer
        s+ -- s+
        ps+ -- ps+
        Derive the note with polos, sangsih, or both.
        Tags: inst
        • inst-polosenv :: Str [inst-polos] — Polos instrument.
        • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
        realize-gangsa -- realize-gangsa
        transformer
        Combine the gangsa realize calls in the right order.
        A static macro for: realize-noltol | cancel-pasang $ | realize-ngoret.
        Each $ is lifted to be an argument of this macro.
        This directly calls the underlying sub-calls, so it's not dependent on the names they are bound to, which also means the macro text may not be a valid expression.
        Tags: postproc
        • final-duration :: Num (RealTime) = 1s [final-duration] — If there is no following note, infer this duration.
        realize-ngoret -- realize-ngoret
        transformer
        Realize pitches and positions emited by the ngoret call. This is necessary because it needs to know the positions and pitches of the previous and next notes, and those aren't necessarily available when evaluating the track. This call needs a hand envron to figure out which which note follows which.
        Tags: inst, postproc
          realize-noltol -- realize-noltol
          transformer
          Perform the annotations added by noltol.
          Tags: realize-delayed
            unison -- unison
            transformer
            Split part into unison polos and sangsih. Emit only polos if only=polos and only sangsih if only=sangsih.
            Tags: postproc
            • inst-polosenv :: Str [inst-polos] — Polos instrument.
            • inst-sangsihenv :: Str [inst-sangsih] — Sangsih instrument.
            Module: bali.gender (4 calls)

            ' -- ngoret
            generator
            '^ -- ngoret
            '_ -- ngoret
            Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
            This requires the realize-ngoret postproc.
            Tags: inst, ornament, requires-postproc
            • time :: ControlRef = %ngoret-time,.1s [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
            • damp :: ControlRef = %ngoret-damp,.5s [*-damp] — Time that the grace note overlaps with this one. So the total duration is time+damp, though it will be clipped to the end of the current note.
            • dyn :: ControlRef = %ngoret-dyn,.75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
            • damp-thresholdenv :: Num (RealTime) = .15s [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
            'n -- ngoret
            generator
            Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
            This requires the realize-ngoret postproc.
            Tags: inst, ornament, requires-postproc
            • interval :: Num (Transposition, default diatonic) [*-interval] — The grace note is this interval from the destination pitch.
            • time :: ControlRef = %ngoret-time,.1s [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
            • damp :: ControlRef = %ngoret-damp,.5s [*-damp] — Time that the grace note overlaps with this one. So the total duration is time+damp, though it will be clipped to the end of the current note.
            • dyn :: ControlRef = %ngoret-dyn,.75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
            • damp-thresholdenv :: Num (RealTime) = .15s [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
            realize-ngoret -- realize-ngoret
            transformer
            Realize pitches and positions emited by the ngoret call. This is necessary because it needs to know the positions and pitches of the previous and next notes, and those aren't necessarily available when evaluating the track. This call needs a hand envron to figure out which which note follows which.
            Tags: inst, postproc
              weak -- weak
              generator
              Weak notes are filler notes.
              Tags: inst
              • strength :: ControlRef = %strength,.5 [*-strength] — From low strength to high, omit the note, then play it muted, and then play it open but softly.
              Module: bali.gong (4 calls)

              C -- calung
              transformer
              Add a calung note with Derive.Flags.infer_duration and the same pitch, transposed into the calung range.
              Tags: inst, under-invert
              • octave :: Str (u d) = d [*-octave] — If the pitch exists in multiple octaves, choose this one.
              • instsenv :: list of Str = (list calung-p calung-s) [*-insts] — Instruments.
              J -- jegog
              transformer
              Add a jegog note with Derive.Flags.infer_duration and the same pitch, transposed into the jegog range.
              Tags: inst, under-invert
              • octave :: Str (u d) = d [*-octave] — If the pitch exists in multiple octaves, choose this one.
              • instsenv :: list of Str = (list jegog-p jegog-s) [*-insts] — Instruments.
              nruk -- nruk
              transformer
              Nruktuk, for kajar or gangsa.
              Tags: inst
              • start :: Num (Time) = 4s [*-start] — Start speed.
              • end :: Num (Time) = 19s [*-end] — End speed.
              • end-dyn :: Num = .15 [*-end-dyn] — Dyn multiplier when the stroke duration reaches 0.
              • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
              pokok -- pokok
              transformer
              Add a pokok note with Derive.Flags.infer_duration and the same pitch, transposed into the appropriate range.
              Tags: inst, under-invert
              • octave :: Str (u d) = d [*-octave] — Which to choose if the pitch exists in multiple octaves.
              • instsenv :: list of Str [*-insts] — Instruments.
              • bottomenv :: NotePitch [*-bottom] — Bottom of the range.
              • topenv :: NotePitch [*-top] — Top of the range.
              Module: bali.reyong (22 calls)

              ' -- ngoret
              generator
              '^ -- ngoret
              '_ -- ngoret
              Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
              This requires the realize-ngoret postproc.
              Tags: inst, ornament, requires-postproc
              • time :: ControlRef = %ngoret-time,.1s [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
              • dyn :: ControlRef = %ngoret-dyn,.75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
              • damp-thresholdenv :: Num (RealTime) = .15s [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
              'n -- ngoret
              generator
              Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
              This requires the realize-ngoret postproc.
              Tags: inst, ornament, requires-postproc
              • interval :: Num (Transposition, default diatonic) [*-interval] — The grace note is this interval from the destination pitch.
              • time :: ControlRef = %ngoret-time,.1s [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
              • dyn :: ControlRef = %ngoret-dyn,.75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
              • damp-thresholdenv :: Num (RealTime) = .15s [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
              / -- cek-loose
              generator
              // -- cek-loose
              X -- cek
              XX -- cek
              O -- byong
              - -- byut-loose
              + -- byut
              Reyong articulation. The doubled variants emit two notes, and rely on start time randomization so they're not exactly simultaneous.
              Tags: inst
              • voicesenv :: list of Num (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
              : -- pitches
              generator
              Play notes for each pitch: (list (pitch 4 2) (pitch 5 0)). Really only for 4e and 5i for the penyorog.
              Tags: inst
                a -- tumpuk-auto
                generator
                A variant of tumpuk that randomly picks a pattern.
                Tags: inst
                • placeenv :: ControlRef = %place,1 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
                cancel-kotekan -- cancel-kotekan
                transformer
                This is like the cancel call, except it understands flags set by kotekan, and cancels based on reyong voice.
                Tags: postproc
                • final-duration :: Num (RealTime) = 1s [final-duration] — If there is no following note, infer this duration.
                infer-damp -- infer-damp
                transformer
                Add damping for reyong parts based on a simulation of the hand technique. The +damped attribute will force a damp, while +undamped will prevent damping. The latter can cause a previously undamped note to become damped because the hand is now freed up.
                Tags: postproc
                • inst :: Str [*-inst] — Apply damping to this instrument.
                • dur :: ControlRef = %damp-dur,.15 [*-dur] — This is how fast the player is able to damp. A note is only damped if there is a hand available which has this much time to move into position for the damp stroke, and then move into position for its next note afterwards.
                k -- kotekan
                generator
                Render a kotekan pattern from a kernel representing the polos. The sangsih is inferred. This can emit notes at both the beginning and end of the event, so use cancel-kotekan to cancel the extras.
                Tags: inst
                • kernel :: Str [*-kernel] — Transposition steps for the part that ends on the destination pitch. It should consist of -, 1, and 2. You can start with k to avoid needing quotes. Starting with k will also require the length to be a multiple of 4.
                • dir :: Str (u d) = u [*-dir] — Inferred part is above or below the explicit one.
                • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
                • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
                • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
                • voicesenv :: list of Num (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
                k// -- kotekan
                generator
                k\\ -- kotekan
                Render a kotekan pattern from a kernel representing the polos. The sangsih is inferred. This can emit notes at both the beginning and end of the event, so use cancel-kotekan to cancel the extras.
                Tags: inst
                • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
                • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
                • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
                • voicesenv :: list of Num (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
                kilit -- reyong
                generator
                >kilit -- reyong
                k_\ -- reyong
                k//\\ -- reyong
                Emit reyong pattern.
                Tags: inst
                • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
                • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
                • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
                • voicesenv :: list of Num (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
                lv -- note with +undamped
                generator
                Add attributes to the notes.
                If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
                Tags: attr, subs
                  lv -- note with +undamped
                  transformer
                  Add attributes to the notes.
                  Tags: attr
                    norot -- norot
                    generator
                    nt -- norot
                    Reyong norot.
                    Tags: inst
                    • prepare :: Maybe Str (f t) = Nothing [*-prepare] — Whether or not to prepare for the next pitch. If Nothing, infer based on the next note.
                    • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
                    • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
                    • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
                    • voicesenv :: list of Num (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
                    nt- -- norot
                    generator
                    Reyong norot.
                    Tags: inst
                    • prepare :: Maybe Str (f t) = f [*-prepare] — Whether or not to prepare for the next pitch. If Nothing, infer based on the next note.
                    • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
                    • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
                    • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
                    • voicesenv :: list of Num (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
                    nt> -- norot
                    generator
                    Reyong norot.
                    Tags: inst
                    • prepare :: Maybe Str (f t) = t [*-prepare] — Whether or not to prepare for the next pitch. If Nothing, infer based on the next note.
                    • kotekan-durenv :: Num (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
                    • initialenv :: Maybe Str (f t) = Nothing [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
                    • finalenv :: Str (f t) = t [final] — If true, include the final note, at the event end.
                    • voicesenv :: list of Num (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
                    o -- byong
                    generator
                    Play the byong notes, but only for the current voice, and following normal damping rules.
                    Tags: inst
                      realize-ngoret -- realize-ngoret
                      transformer
                      Realize pitches and positions emited by the ngoret call. This is necessary because it needs to know the positions and pitches of the previous and next notes, and those aren't necessarily available when evaluating the track. This call needs a hand envron to figure out which which note follows which.
                      Tags: inst, postproc
                        realize-reyong -- realize-reyong
                        transformer
                        Combine the reyong realize calls in the right order.
                        A static macro for: infer-damp $ $ | cancel-kotekan $ | realize-ngoret.
                        Each $ is lifted to be an argument of this macro.
                        This directly calls the underlying sub-calls, so it's not dependent on the names they are bound to, which also means the macro text may not be a valid expression.
                        Tags: postproc
                        • inst :: Str [*-inst] — Apply damping to this instrument.
                        • dur :: ControlRef = %damp-dur,.15 [*-dur] — This is how fast the player is able to damp. A note is only damped if there is a hand available which has this much time to move into position for the damp stroke, and then move into position for its next note afterwards.
                        • final-duration :: Num (RealTime) = 1s [final-duration] — If there is no following note, infer this duration.
                        t -- tumpuk
                        generator
                        Pile up notes together.
                        Tags: inst
                        • notes :: Str [*-notes] — Articulations, from -.mnox, pitches from edcba0123456789, or a space for a rest.
                        • dur :: Num (RealTime) = .1s [*-dur] — Duration of each note.
                        • placeenv :: ControlRef = %place,1 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
                        upper -- upper
                        generator
                        Double a part with %t-oct=+1 and v=2. If reyong subtracks have v=+1 and v=+2 respectively, they'll wind up with the right voices.
                        If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
                        Tags: inst, subs
                          upper -- upper
                          transformer
                          Double a part with %t-oct=+1 and v=2. If reyong subtracks have v=+1 and v=+2 respectively, they'll wind up with the right voices.
                          Tags: inst
                            vv -- lower-octave-note
                            transformer
                            Double a note with a single note one octave down, and add Derive.Flags.infer_duration.
                            Tags: postproc, under-invert
                              Module: bali.reyong.solkattu (1 calls)

                              n1 -- solkattu-note
                              generator
                              n2 -- solkattu-note
                              n3 -- solkattu-note
                              n4 -- solkattu-note
                              n14 -- solkattu-note
                              A pitched note, as generated by reyong solkattu.
                              Tags: inst
                                Module: bali.sekar (2 calls)

                                sekar -- sekar
                                generator
                                Arrange sub-notes according to a pattern.
                                In the direct substitution style, each note retains its relative duration as it is rearranged by the pattern. A rest is considered a note, but just one note, so you can't have two rests in a row.
                                Tags: inst, subs
                                • pattern :: list of Str [*-pattern] — If there is a list of patterns, they are for different numbers of notes, starting with 1. A single pattern is applied to all numbers though. The pattern is letters from a-z, where a is the first note and z is the 26th. Capital letters replace that note with a rest. Gaps in the input notes count as rest notes.
                                • arriveenv :: Str (f t) = t [*-arrive] — If true, the last note of the pattern is aligned to the end of the event, and given {infer-duration}.
                                sekar-e -- sekar
                                generator
                                Arrange sub-notes according to a pattern.
                                In the even subdivision style, the range is divided evenly based on the highest index of the pattern (so abcac would divide into 3 parts). The melody is sampled at those points for note attacks, sustains, and rests, which are then rearranged by the pattern. Thus, the output is always notes in a regular tempo determined by the length of the pattern.
                                Tags: inst, subs
                                • pattern :: Str [*-pattern] — The pattern is letters from a-z, where a is the first note and z is the 26th. Capital letters replace that note with a rest. Gaps in the input notes count as rest notes.
                                • arriveenv :: Str (f t) = t [*-arrive] — If true, the last note of the pattern is aligned to the end of the event, and given {infer-duration}.
                                Module: china.zheng (4 calls)

                                bent-string -- bent-string
                                transformer
                                Post-process events to play in a monophonic string-like idiom, where strings must be bent or stopped to reach non-open pitches. Originally it was meant to play in the style of a 古箏 or other zither, but may also be appropriate for stopped strings like the violin family. This only makes sense for instruments with some decay, since otherwise you can't hear the transitions. Further documentation is in Derive.Call.Idiom.String.
                                Tags: inst, postproc
                                • attack :: ControlRef = %string-attack,.15 [*-attack] — Time for a string to bend to its desired pitch. A fast attack sounds like a stopped string.
                                • release :: ControlRef = %string-release,.1 [*-release] — Time for a string to return to its original pitch.
                                • delay :: ControlRef = %string-delay,0 [*-delay] — If the string won't be used for the following note, it will be released after this delay.
                                • open-stringsenv :: list of Pitch = (list) [open-strings] — Pitches of the open strings.
                                gliss -- gliss
                                generator
                                Glissando along the open strings. The standard version divides the time among the number of notes, while the -a (absolute) version gives time to each note.
                                • start :: Num (integral) [*-start] — Start this many strings above or below the destination pitch.
                                • time :: Num (Time, default real) = .075s [*-time] — Time between each note.
                                • dyn :: Maybe Num = Nothing [*-dyn] — Start at this dyn, and interpolate to the destination dyn. If not given, the dyn is constant.
                                • open-stringsenv :: list of Pitch = (list) [open-strings] — Pitches of the open strings.
                                gliss-a -- gliss-a
                                generator
                                Glissando along the open strings. The standard version divides the time among the number of notes, while the -a (absolute) version gives time to each note.
                                • start :: Num (integral) [*-start] — Start this many strings above or below the destination pitch.
                                • time :: Num (Time, default real) = .25s [*-time] — Time in which to play the glissando.
                                • dyn :: Maybe Num = Nothing [*-dyn] — Start at this dyn, and interpolate to the destination dyn. If not given, the dyn is constant.
                                • open-stringsenv :: list of Pitch = (list) [open-strings] — Pitches of the open strings.
                                tr -- tr
                                generator
                                tr^ -- tr
                                tr_ -- tr
                                A trill with smooth transitions.
                                Tags: ly
                                • neighbor :: ControlRef = %tr-neighbor,1nn [*-neighbor] — Alternate with a pitch at this interval.
                                • speed :: ControlRef = %tr-speed,20s [*-speed] — Alternate pitches at this speed.
                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                Module: europe (5 calls)

                                `mordent` -- mordent
                                generator
                                Like g, but hardcoded to play pitch, neighbor, pitch.
                                Tags: ornament
                                • neighbor :: Num (Transposition, default diatonic) = 1d [*-neighbor] — Neighbor pitch.
                                • durenv :: Num (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
                                • grace-dynenv :: Num (>=0) = .5 [grace-dyn] — Scale the dyn of the grace notes.
                                • placeenv :: ControlRef = %place,0 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
                                `rmordent` -- mordent
                                generator
                                Like g, but hardcoded to play pitch, neighbor, pitch.
                                Tags: ornament
                                • neighbor :: Num (Transposition, default diatonic) = -1d [*-neighbor] — Neighbor pitch.
                                • durenv :: Num (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
                                • grace-dynenv :: Num (>=0) = .5 [grace-dyn] — Scale the dyn of the grace notes.
                                • placeenv :: ControlRef = %place,0 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
                                chord -- chord
                                generator
                                chord^ -- chord
                                chord_ -- chord
                                Make a chord based on a specialized chord notation. It's different from the usual kind of chord notation because the base pitch is given separately, and it has to be non-ambiguous, but the idea is the same.
                                • name :: Str = '' [*-name] — Chord name.
                                • timeenv :: Num (Time, default real) = .08s [*-time] — Time between notes, if they aren't unison.
                                roll -- roll
                                generator
                                These are like grace notes, but they all have the same pitch. The extra notes always fall before the main one, because trem covers the afterwards case.
                                Tags: ornament
                                • times :: Num (integral) = 1 [*-times] — Number of grace notes.
                                • time :: Num (Time, default real) = .083s [*-time] — Time between the strokes.
                                • dyn :: Num = .5 [*-dyn] — Dyn scale for the grace notes.
                                stack -- stack
                                generator
                                stack^ -- stack
                                stack_ -- stack
                                Make a chord by stacking intervals on a base pitch. There are variants that arpeggiate upwards or downwards, in addition to playing in unison.
                                • interval* :: Pitch or Num (integral) or Str [] — Relative intervals, starting from the base pitch. Can be absolute pitch, diatonic intervals, or a chromatic interval. Chromatic intervals are notated m3, M3, p4 for minor third, major third, and perfect fourth respectively.
                                • timeenv :: Num (Time, default real) = .08s [*-time] — Time between notes, if they aren't unison.
                                Module: idiom.string (2 calls)

                                bent-string -- bent-string
                                transformer
                                Post-process events to play in a monophonic string-like idiom, where strings must be bent or stopped to reach non-open pitches. Originally it was meant to play in the style of a 古箏 or other zither, but may also be appropriate for stopped strings like the violin family. This only makes sense for instruments with some decay, since otherwise you can't hear the transitions. Further documentation is in Derive.Call.Idiom.String.
                                Tags: inst, postproc
                                • attack :: ControlRef = %string-attack,.15 [*-attack] — Time for a string to bend to its desired pitch. A fast attack sounds like a stopped string.
                                • release :: ControlRef = %string-release,.1 [*-release] — Time for a string to return to its original pitch.
                                • delay :: ControlRef = %string-delay,0 [*-delay] — If the string won't be used for the following note, it will be released after this delay.
                                • open-stringsenv :: list of Pitch = (list) [open-strings] — Pitches of the open strings.
                                stopped-string -- stopped-string
                                transformer
                                A specialization of bent-string but for stopped strings, like the violin family, where strings instantly jump to their pitches.
                                Tags: inst, postproc
                                • delay :: ControlRef = %string-delay,0 [*-delay] — String release delay time.
                                • open-stringsenv :: list of Pitch = (list) [open-strings] — Pitches of the open strings.
                                Module: idiom.wind (1 calls)

                                wind-idiom -- wind-idiom
                                transformer
                                Post-process events to play in a monophonic wind-like idiom.
                                This tweaks the ends of the pitch signals of notes depending on the following note. When a note is played, a (fundamental, harmonic) pair is chosen that best fits it. When a subsequent note is played, a new pair is chosen for it.
                                The decay of the note will be shifted to the corresponding harmonic of the the fundamental of the subsequent note. If the fundamentals are the same then the pitch will remain constant, of course.
                                Tags: inst, postproc
                                • fundamentalsenv :: list of Num (NN) or Pitch = (list) [fundamentals] — Fundamentals for this instrument.
                                Module: india.gamakam2 (3 calls)

                                @ -- sequence
                                generator
                                Sequence several pitch calls. Calls are divided into begin ; middle1 ; middle2; ... ; end phases. Calls are pitch generators, and are sequenced such that the middle calls stretch based on the duration of the note. The india.gamakam2.begin, india.gamakam2.middle, and india.gamakam2.end modules are in scope during the begin, middle, and end phases. All calls below the india.gamakam2 module are designed for sequencing. This just means they emit samples at the beginning and end of their range, so the sequence call knows their extent. Normal pitch calls may not do that.
                                There's a special hack for the -< and -> calls: they have 0 duration, but are overlaid with their neighbors. This is so you can fade in or out without having to flatten the pitch.
                                • arg* :: Val [] — Expressions separated by ;.
                                @ -- sequence
                                transformer
                                Sequence several pitch calls. Calls are divided into begin ; middle1 ; middle2; ... ; end phases. Calls are pitch generators, and are sequenced such that the middle calls stretch based on the duration of the note. The india.gamakam2.begin, india.gamakam2.middle, and india.gamakam2.end modules are in scope during the begin, middle, and end phases. All calls below the india.gamakam2 module are designed for sequencing. This just means they emit samples at the beginning and end of their range, so the sequence call knows their extent. Normal pitch calls may not do that.
                                There's a special hack for the -< and -> calls: they have 0 duration, but are overlaid with their neighbors. This is so you can fade in or out without having to flatten the pitch.
                                • arg* :: Val [] — Expressions separated by ;.
                                sahitya -- sahitya
                                transformer
                                Ignore the transformed deriver. Put this on a track to ignore its contents, and put in sahitya.
                                  Module: india.gamakam5 (1 calls)

                                  sahitya -- sahitya
                                  transformer
                                  Ignore the transformed deriver. Put this on a track to ignore its contents, and put in sahitya.
                                    Module: india.mridangam (4 calls)

                                    p -- pattern
                                    generator
                                    Like seq, but pick a standard pattern.
                                    Tags: inst
                                    • n :: Maybe Num (integral, >0) [*-n] — Number of strokes. If not given, and dur > 0, then infer the number of strokes as the event_duration / dur.
                                    • var :: Str = d [var, *-var] — Variation name. Possibilities are: d, f567-0, f567-1, f567-2, f567-3, f567-4, f567-5, f567-6, f567-7, f567-8, kt_kn_o
                                    • dur :: Num (ScoreTime, >=0) = 0t [dur, *-dur] — Duration for each letter in the sequence. If 0, the sequence will stretch to the event's duration.
                                    seq -- sequence
                                    generator
                                    Play a sequence of mridangam strokes. Each one takes the given dur, and if the event is longer than the sequence, it is repeated to fill up available space. If a whole cycle doesn't fit, clip from the end for a positive event, or from the beginning for a negative one. If dur is 0, then stretch to the sequence to fit the event.
                                    Tags: inst
                                    • sequence :: Str [sequence] — Single letter stroke names. _ or space is a rest.
                                    • dur :: Num (ScoreTime, >=0) = 0t [dur, *-dur] — Duration for each letter in the sequence. If 0, the sequence will stretch to the event's duration.
                                    tari -- sequence
                                    generator
                                    na -- sequence
                                    tk -- sequence
                                    tknk -- sequence
                                    Play a sequence of mridangam strokes. Each one takes the given dur, and if the event is longer than the sequence, it is repeated to fill up available space. If a whole cycle doesn't fit, clip from the end for a positive event, or from the beginning for a negative one. If dur is 0, then stretch to the sequence to fit the event.
                                    Tags: inst
                                    • dur :: Num (ScoreTime, >=0) = 0t [dur, *-dur] — Duration for each letter in the sequence. If 0, the sequence will stretch to the event's duration.
                                    tir -- tir
                                    generator
                                    Repeat a sequence three times. If the duration is negative, put the first stroke of the karvai at the end time with {strong}.
                                    Tags: inst
                                    • sequence :: Str [sequence] — Single letter stroke names. _ or space is a rest.
                                    • karvai :: Str = '' [*-karvai] — Separates each sequence. If it's empty or a single non-rest, then the gap can stretch to an integral number of matras.
                                    • dur :: Num (ScoreTime, >=0) = 0t [dur, *-dur] — Duration for each letter in the sequence. If 0, the sequence will stretch to the event's duration.
                                    Module: india.pakhawaj (1 calls)

                                    bols -- bols
                                    generator
                                    Interpret pakhawaj bols in sub events. Bols: tet / te / ne / re / na / ta / di / din / ka / kat / ki / ge / gen / ga / dha / dhin / dhet / kre / gre / te re ki ta / tr kt / te re ki ta ta ka / tr kt tk / ki ta ta ka / kt tk / ta ki / te ran / dhu ma / tetekata
                                    Tags: inst, subs
                                    • flam :: Num (ScoreTime) = .15t [*-flam] — Time between flam type bols like kre.
                                    Module: internal (1 calls)

                                    capture-null-control -- capture-null-control
                                    generator
                                    This is an internal call used to capture the control signal at the bottom of a control block.
                                      Module: ly (50 calls)

                                      8va -- ottava
                                      generator
                                      Emit lilypond ottava mark. If it has duration, end with 8va 0.
                                      This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                      • octave :: Num (integral) = 0 [*-octave] — Transpose this many octaves up or down.
                                      8va -- ottava
                                      transformer
                                      Emit lilypond ottava mark. If it has duration, end with 8va 0.
                                      This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                      • octave :: Num (integral) = 0 [*-octave] — Transpose this many octaves up or down.
                                      clef -- clef
                                      generator
                                      Emit lilypond clef change.
                                      This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                      • clef :: Str [*-clef] — Should be bass, treble, etc.
                                      clef -- clef
                                      transformer
                                      Emit lilypond clef change.
                                      This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                      • clef :: Str [*-clef] — Should be bass, treble, etc.
                                      dyn -- dyn
                                      generator
                                      Emit a lilypond dynamic. If there are notes below, they are derived unchanged.
                                      This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                      • dynamic :: Str [*-dynamic] — Should be p, ff, etc.
                                      dyn -- dyn
                                      transformer
                                      Emit a lilypond dynamic. If there are notes below, they are derived unchanged.
                                      This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                      • dynamic :: Str [*-dynamic] — Should be p, ff, etc.
                                      if-ly -- if-ly
                                      generator
                                      Conditional for lilypond.
                                      • is-ly :: Val [*-is-ly] — Evaluated in lilypond mode.
                                      • not-ly :: Val [*-not-ly] — Evaluated when not in lilypond mode.
                                      ly-! -- ly-reminder-accidental
                                      generator
                                      Force this note to display an accidental.
                                      If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
                                      Tags: subs
                                        ly-! -- ly-reminder-accidental
                                        transformer
                                        Force this note to display an accidental.
                                          ly-( -- ly-begin-slur
                                          generator
                                          Begin a slur. The normal slur transformer doesn't work in some cases, for instance inside tuplets.
                                            ly-( -- ly-begin-slur
                                            transformer
                                            Begin a slur. The normal slur transformer doesn't work in some cases, for instance inside tuplets.
                                              ly-) -- ly-end-slur
                                              generator
                                              End a slur. The normal slur transformer doesn't work in some cases, for instance inside tuplets.
                                                ly-) -- ly-end-slur
                                                transformer
                                                End a slur. The normal slur transformer doesn't work in some cases, for instance inside tuplets.
                                                  ly-< -- ly-crescendo
                                                  generator
                                                  Start a crescendo hairpin. If it has non-zero duration, stop the crescendo at the event's end, otherwise the crescendo will stop at the next hairpin or dynamic marking.
                                                    ly-< -- ly-crescendo
                                                    transformer
                                                    Start a crescendo hairpin. If it has non-zero duration, stop the crescendo at the event's end, otherwise the crescendo will stop at the next hairpin or dynamic marking.
                                                      ly-<> -- ly-crescendo-diminuendo
                                                      generator
                                                      Crescendo followed by diminuendo, on one note.
                                                        ly-<> -- ly-crescendo-diminuendo
                                                        transformer
                                                        Crescendo followed by diminuendo, on one note.
                                                          ly-> -- ly-diminuendo
                                                          generator
                                                          Start a diminuendo hairpin. If it has non-zero duration, stop the diminuendo at the event's end, otherwise the diminuendo will stop at the next hairpin or dynamic marking.
                                                            ly-> -- ly-diminuendo
                                                            transformer
                                                            Start a diminuendo hairpin. If it has non-zero duration, stop the diminuendo at the event's end, otherwise the diminuendo will stop at the next hairpin or dynamic marking.
                                                              ly-? -- ly-cautionary-accidental
                                                              generator
                                                              Force this note to display a cautionary accidental.
                                                              If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
                                                              Tags: subs
                                                                ly-? -- ly-cautionary-accidental
                                                                transformer
                                                                Force this note to display a cautionary accidental.
                                                                  ly-^~ -- ly-tie-direction
                                                                  generator
                                                                  ly-_~ -- ly-tie-direction
                                                                  Force the note's tie to go either up or down.
                                                                  If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
                                                                  Tags: subs
                                                                    ly-^~ -- ly-tie-direction
                                                                    transformer
                                                                    ly-_~ -- ly-tie-direction
                                                                    Force the note's tie to go either up or down.
                                                                      ly-global -- ly-global
                                                                      transformer
                                                                      Evaluate the deriver only when in lilypond mode, like when-ly, but also set the ly-global instrument.
                                                                        ly-key -- ly-key
                                                                        generator
                                                                        Emit a key change. This only emits a lilypond key change, it doesn't actually set the key. This means diatonic operations won't work as expected. Also, you have to add it to every staff manually. On the up side, it doesn't force a structural change like = does.
                                                                        This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                                                        • key :: Str [*-key] — You can use any of the keys from the Twelve scale.
                                                                        ly-key -- ly-key
                                                                        transformer
                                                                        Emit a key change. This only emits a lilypond key change, it doesn't actually set the key. This means diatonic operations won't work as expected. Also, you have to add it to every staff manually. On the up side, it doesn't force a structural change like = does.
                                                                        This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                                                        • key :: Str [*-key] — You can use any of the keys from the Twelve scale.
                                                                        ly-post -- ly-post
                                                                        generator
                                                                        Emit arbitrary lilypond code that will go after concurrent notes.
                                                                        This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                                                        • code :: Str [*-code] — A leading \ will be prepended.
                                                                        ly-post -- ly-post
                                                                        transformer
                                                                        Emit arbitrary lilypond code that will go after concurrent notes.
                                                                        This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                                                        • code :: Str [*-code] — A leading \ will be prepended.
                                                                        ly-pre -- ly-pre
                                                                        generator
                                                                        Emit arbitrary lilypond code that will go before concurrent notes.
                                                                        This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                                                        • code :: Str [*-code] — A leading \ will be prepended.
                                                                        ly-pre -- ly-pre
                                                                        transformer
                                                                        Emit arbitrary lilypond code that will go before concurrent notes.
                                                                        This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                                                        • code :: Str [*-code] — A leading \ will be prepended.
                                                                        ly-span -- ly-span
                                                                        generator
                                                                        Emit a bit of text followed by a dashed line until the end of the event. This is useful for things like accel. or cresc.
                                                                        • text :: Str [*-text] — Text.
                                                                        ly-span -- ly-span
                                                                        transformer
                                                                        Emit a bit of text followed by a dashed line until the end of the event. This is useful for things like accel. or cresc.
                                                                        • text :: Str [*-text] — Text.
                                                                        ly-sus -- ly-sus
                                                                        generator
                                                                        Emit \sustainOn and \sustainOff markup.
                                                                        This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                                                        • state :: Str (f t ft) [*-state] — t for \sustainOn, f for \sustainOff, ft for \sustainOff\sustainOn.
                                                                        ly-sus -- ly-sus
                                                                        transformer
                                                                        Emit \sustainOn and \sustainOff markup.
                                                                        This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                                                        • state :: Str (f t ft) [*-state] — t for \sustainOn, f for \sustainOff, ft for \sustainOff\sustainOn.
                                                                        ly-track -- ly-track
                                                                        transformer
                                                                        Evaluate the deriver only when in lilypond mode, otherwise ignore this track but evaluate its subtracks. Apply this to a track to omit lilypond-only articulations, or to apply different articulations to lilypond and non-lilypond output. Only use it in the track title!
                                                                          ly^ -- ly-text-above
                                                                          generator
                                                                          Attach text above the note.
                                                                          • text :: Str [*-text] — Text to attach. Double quotes can be omitted.
                                                                          ly^ -- ly-text-above
                                                                          transformer
                                                                          Attach text above the note.
                                                                          • text :: Str [*-text] — Text to attach. Double quotes can be omitted.
                                                                          ly_ -- ly-text-below
                                                                          generator
                                                                          Attach text below the note.
                                                                          • text :: Str [*-text] — Text to attach. Double quotes can be omitted.
                                                                          ly_ -- ly-text-below
                                                                          transformer
                                                                          Attach text below the note.
                                                                          • text :: Str [*-text] — Text to attach. Double quotes can be omitted.
                                                                          meter -- meter
                                                                          generator
                                                                          Emit lilypond meter change. It will be interpreted as global no matter where it is. Simultaneous different meters aren't supported yet.
                                                                          • meter :: Str [*-meter] — Should be 4/4, 3+3/8, etc.
                                                                          meter -- meter
                                                                          transformer
                                                                          Emit lilypond meter change. It will be interpreted as global no matter where it is. Simultaneous different meters aren't supported yet.
                                                                          • meter :: Str [*-meter] — Should be 4/4, 3+3/8, etc.
                                                                          movement -- movement
                                                                          generator
                                                                          Start a new movement with the given title.
                                                                          • title :: Str [*-title] — Title of this movement.
                                                                          movement -- movement
                                                                          transformer
                                                                          Start a new movement with the given title.
                                                                          • title :: Str [*-title] — Title of this movement.
                                                                          not-ly-track -- not-ly-track
                                                                          transformer
                                                                          The inverse of ly-track, evaluate the track only when not in lilypond mode. Only use it in the track title!
                                                                            unless-ly -- unless-ly
                                                                            transformer
                                                                            The inverse of when-ly, evaluate the deriver or apply the args only when not in lilypond mode.
                                                                            • arg* :: Val [] — Call expression.
                                                                            when-ly -- when-ly
                                                                            transformer
                                                                            With no arguments, evaluate the deriver only when in lilypond mode. Unlike ly-track, this doesn't evaluate subtracks, so you can use it to emit an entirely different set of tracks.
                                                                            With arguments, evaluate them as a transformer and apply it only when in lilypond mode. Otherwise, the deriver is unchanged.
                                                                            • arg* :: Val [] — Call expression.
                                                                            xstaff -- xstaff
                                                                            generator
                                                                            Emit lilypond to put the notes on a different staff.
                                                                            This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                                                            • staff :: Str (up down) [*-staff] — Switch to this staff.
                                                                            xstaff -- xstaff
                                                                            transformer
                                                                            Emit lilypond to put the notes on a different staff.
                                                                            This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
                                                                            • staff :: Str (up down) [*-staff] — Switch to this staff.
                                                                            xstaff-a -- xstaff-around
                                                                            generator
                                                                            Emit lilypond to put the notes on a different staff.
                                                                            This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer. The transformer will wrap each event in (start, end) pairs. This way you can wrap all notes on a certain track with complementary bits of lilypond code.
                                                                            • staff :: Str (up down) [*-staff] — Switch to this staff.
                                                                            xstaff-a -- xstaff-around
                                                                            transformer
                                                                            Emit lilypond to put the notes on a different staff.
                                                                            This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer. The transformer will wrap each event in (start, end) pairs. This way you can wrap all notes on a certain track with complementary bits of lilypond code.
                                                                            • staff :: Str (up down) [*-staff] — Switch to this staff.
                                                                            Module: prelude (88 calls)

                                                                            "" -- note
                                                                            generator
                                                                            n -- note
                                                                            The note call is the main note generator, and will emit a single score event. It interprets >inst and +attr args by setting those fields of the event. This is bound to the null call, "", but any potential arguments would wind up looking like a different call, so it's bound to n as well.
                                                                            • attribute* :: Str or Attributes [] — Add attributes.
                                                                            ( -- legato
                                                                            generator
                                                                            ^( -- legato
                                                                            _( -- legato
                                                                            Play the transformed notes legato. This just makes all but the last overlap slightly.
                                                                            You can combine this with other controls to get fancier phrasing. For example, you can be detached by default but have legato connect notes, by setting %legato-overlap = .05 | %sus-abs = -.05.
                                                                            Otherwise, you can use the detach and dyn args.
                                                                            Tags: attr, ly, subs
                                                                            • overlap :: ControlRef = %legato-overlap,.1s [*-overlap] — All notes but the last have their durations extended by this amount.
                                                                            • detach :: Maybe Num (RealTime) = Nothing [*-detach] — Shorten the final note by this amount, by setting %sus-abs. The distinction between not given and 0 is important, because 0 will still override %sus-abs, which you may not want.
                                                                            • dyn :: Num = 1 [*-dyn] — Scale dyn for notes after the first one by this amount.
                                                                            - -- shorten
                                                                            generator
                                                                            + -- lengthen
                                                                            Lengthen or Shorten a note duration, by adding to or subtracting from %sus-abs.
                                                                            If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
                                                                            Tags: subs
                                                                            • time :: Num = .15 [*-time] — Subtract this duration.
                                                                            - -- shorten
                                                                            transformer
                                                                            + -- lengthen
                                                                            Lengthen or Shorten a note duration, by adding to or subtracting from %sus-abs.
                                                                            • time :: Num = .15 [*-time] — Subtract this duration.
                                                                            < -- track-integrate
                                                                            transformer
                                                                            Integrate the output into new tracks. Events will be split into tracks based on source track, instrument, and scale, as documented in Cmd.Integrate.Convert.
                                                                            Unlike block integrate, this doesn't return the events. While an integrated block's output is likely to be playable, and you can chose whether or not to play it, an integrated track is part of a block, so it plays whether you want it or not.
                                                                              << -- block-integrate
                                                                              transformer
                                                                              Integrate the output into a new block. The events are returned as-is so the block can still be played normally.
                                                                                = -- equal
                                                                                generator
                                                                                Similar to the transformer, this will evaluate the notes below in a transformed environ.
                                                                                Tags: subs
                                                                                • lhs :: Str [*-lhs] — Assign to this. This looks like a Str, but can actualy contain any characters except =, due to the special infix parsing for =. Symbolic prefixes determine what is assigned, and the valid types for the rhs.
                                                                                • rhs :: Val [*-rhs] — Source of the assignment.
                                                                                • merge :: Str = set [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from Derive.Deriver.Monad.mergers: add, interleave, max, min, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
                                                                                = -- equal
                                                                                transformer
                                                                                Evaluate the deriver with a value set. Special parser support means this can be called infix. The arguments can take many forms to set different kinds of values.
                                                                                Set an environ value by setting a plain symbol or unset it by assigning to _: x = 42 or x = _.
                                                                                Alias instrument names like: >alias = >inst.
                                                                                If the lhs is prefixed with >>, ^, *, ., or -, it will add a new name for a ^note, *pitch, .control, or -val call, respectively. It sets the generator by default, but will set the transformer if you prefix another -. >> is special cased to only create a note transformer, whose name will be prefixed with >. This is used to set an instrument transformer, which can apply a transformer when an instrument is set by the title of a note track, as implemented by by note-track.
                                                                                E.g.: set note generator: ^phrase = some-block, note transformer: ^-mute = +mute+loose, control transfomrer: .-i = t, val call: -4c = (5c).
                                                                                You can bypass all this cryptic prefix garbage by using a ky file. It has more space available so it can use a more readable syntax.
                                                                                If you bind a call to a quoted expression, this creates a new call: ^abc = "(a b c) will create a abc call, which is a macro for a b c. The created call does not take arguments.
                                                                                Set constant signals by assigning to a signal literal: %c = .5 or pitch: #p = (4c). # = (4c) sets the default pitch signal. You can rename a signal via %a = %b or #x = #y. Control signal assignment also supports the same merge functions as the control track: %a = .5 add or %a = %b add. However, the second example throws an error if %b is a ControlFunction. %a = .5 default will combine with a's default merge function. Assigning to _ unsets the control, and any ControlFunction.
                                                                                The = operator can be suffixed with symbol, which will become the last argument, so %x=+1 becomes %x = 1 '+'. Note that the order is backwards from the usual +=, which is ultimately because the first word can have almost any character except space and =. Also, x=-1 is ambiguous, and parsed as x =- 1.
                                                                                Tags: subs
                                                                                • lhs :: Str [*-lhs] — Assign to this. This looks like a Str, but can actualy contain any characters except =, due to the special infix parsing for =. Symbolic prefixes determine what is assigned, and the valid types for the rhs.
                                                                                • rhs :: Val [*-rhs] — Source of the assignment.
                                                                                • merge :: Str = set [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from Derive.Deriver.Monad.mergers: add, interleave, max, min, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
                                                                                ^ -- weaken
                                                                                generator
                                                                                Weaken the note by multiplying its dynamic.
                                                                                If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
                                                                                Tags: subs
                                                                                • dyn :: Num = .35 [*-dyn] — Multiply dynamic.
                                                                                ^ -- weaken
                                                                                transformer
                                                                                Weaken the note by multiplying its dynamic.
                                                                                • dyn :: Num = .35 [*-dyn] — Multiply dynamic.
                                                                                `arp-up` -- arp
                                                                                generator
                                                                                `arp-down` -- arp
                                                                                `arp-rnd` -- arp
                                                                                Arpeggiate the transformed notes. This shifts each note's start time by a different amount, increasing to the right for arp-up, to the left for arp-down, and randomly for arp-rnd. Since it transforms score and not events, it doesn't know the pitches of the sub notes (they may not have a single pitch) so it's not actually "up" or "down".
                                                                                Tags: subs
                                                                                • time :: Num = .1 [*-time] — This much RealTime between each note.
                                                                                • random :: Num = .5 [*-random] — Each note can vary randomly by +- time/2 * random.
                                                                                add-flag -- add-flag
                                                                                transformer
                                                                                Add the given flags to transformed events. Mostly for debugging and testing.
                                                                                Tags: postproc
                                                                                • flag+ :: Str [] — Add these flags.
                                                                                alt -- alternate
                                                                                generator
                                                                                Pick one of several expressions and evaluate it.
                                                                                Tags: random
                                                                                • expr+ :: Quoted [] — Expression to evaluate.
                                                                                alt-t -- alternate-tracks
                                                                                generator
                                                                                Evaluate notes from one of the sub-tracks.
                                                                                Tags: random, subs
                                                                                • weight* :: Num [] — Likelihood to choose each child track. Each number is a relative weight, and tracks without a number default to 1. It's an error to have more numbers than tracks.
                                                                                alt-w -- alternate-weighted
                                                                                generator
                                                                                Pick one of several expressions and evaluate it.
                                                                                Tags: random
                                                                                • expr+ :: (Num, Quoted) [] — (weight, expr) pairs.
                                                                                ap -- ap
                                                                                generator
                                                                                Derive sub events with no changes. This is used to apply a transformer to sub events.
                                                                                Tags: subs
                                                                                  apply-attributes -- apply-attributes
                                                                                  transformer
                                                                                  Apply attributes by control signal. This looks for controls with a attr- prefix. A control named attr-a-b will, when non-zero, add the +a+b attributes to its events.
                                                                                  Tags: postproc
                                                                                    apply-start-offset -- apply-start-offset
                                                                                    transformer
                                                                                    Apply the start-offset-val env var. This is set by note deriver from the %start-s and %start-t controls, so if you want those controls to have an effect, you have to use this postproc.
                                                                                    Tags: postproc
                                                                                    • min-duration :: Maybe Num (RealTime) = Nothing [*-min-duration] — If given, notes on the same hand won't be moved closer than this time. Otherwise, hand and instrument is ignored.
                                                                                    avoid-overlap -- avoid-overlap
                                                                                    transformer
                                                                                    Notes with the same instrument and starting pitch are shortened so they don't overlap with each other. This simulates keyboard instruments, where you have to release a key before striking the same key again. This also happens to be what MIDI expects, since it's based on keyboards.
                                                                                    Tags: inst, postproc
                                                                                    • time :: Num (RealTime) = .1s [*-time] — Ensure at least this much time between two notes of the same pitch.
                                                                                    cancel -- cancel
                                                                                    transformer
                                                                                    Process the Derive.Flags.strong and Derive.Flags.weak flags. This will cause notes to be dropped.
                                                                                    Tags: postproc
                                                                                    • final-duration :: Num (RealTime) = 1s [final-duration] — If there is no following note, infer this duration.
                                                                                    cf-sample -- cf-sample
                                                                                    transformer
                                                                                    Sample the given control functions and insert them as constants in the control map. The default note call expects continuous signals, so it takes slices out of the control map. This transfers control functions to the control map, so you can e.g. use randomized controls.
                                                                                    Tags: control-function
                                                                                    • control+ :: Control ([a-z][a-z0-9.-]*) [] — Sample these control functions.
                                                                                    Clip -- Clip
                                                                                    transformer
                                                                                    Like clip, but align the named block to the end of the event instead of the beginning. Events that then lie before the start are clipped.
                                                                                      clip -- clip
                                                                                      transformer
                                                                                      Unstretch the deriver to its natural duration, and clip events that lie beyond the end of the event. Notes that overlap the end of the event will be cut short.
                                                                                      This is only useful with calls that have a natural duration apart from whatever their calling event's duration, e.g. block calls.
                                                                                        cycle -- cycle
                                                                                        generator
                                                                                        Apply transformers in a cycle to the sub events.
                                                                                        Tags: subs
                                                                                        • transformer+ :: Quoted [] — Transformers to apply.
                                                                                        cycle-t -- cycle-t
                                                                                        generator
                                                                                        Apply transformers in a cycle to the sub events. This is like 'cycle', except that it also gets a duration for each transformer, and cycles in the given rhythm, rather than for each event.
                                                                                        Tags: subs
                                                                                        • transformer+ :: (Quoted, Num) [] — Transformers to apply, and the ScoreTime duration for each transformer.
                                                                                        d -- delay
                                                                                        transformer
                                                                                        Simple abstract delay. As with echo, abstract means it happens in the score, so events may not be delayed evenly if the tempo is changing.
                                                                                        Tags: ly
                                                                                        • time :: ControlRef = %delay-time,.1s [*-time] — Delay time.
                                                                                        debug -- debug
                                                                                        transformer
                                                                                        Save the events at this point in a special log msg. This is useful to inspect events at a certain point in a pipeline. You can extract them later by looking at the Log.msg_data of a log msg with the given tag.
                                                                                        • tag :: Str [*-tag] — Log msg has this text.
                                                                                        default-merge -- default-merge
                                                                                        transformer
                                                                                        Set the default merge operators for controls. These apply when the control track doesn't have an explicit operator.
                                                                                        • merge :: Str [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from Derive.Deriver.Monad.mergers: add, interleave, max, min, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
                                                                                        • control+ :: Control ([a-z][a-z0-9.-]*) [] — Control names.
                                                                                        drop -- drop
                                                                                        transformer
                                                                                        Drop pitch and dyn at the end of the note.
                                                                                        Tags: under-invert
                                                                                        • interval :: Num (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
                                                                                        • time :: Num (Time, default real) = .25s [*-time] — Time to the destination pitch.
                                                                                        • fade :: Maybe Num (Time, default real) = Nothing [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
                                                                                        • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                        Drop -- Drop
                                                                                        transformer
                                                                                        Like Lift, but attack the note from a higher neighbor.
                                                                                        Tags: under-invert
                                                                                        • interval :: Num (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
                                                                                        • time :: Num (Time, default real) = .25s [*-time] — Time to the destination pitch.
                                                                                        • fade :: Maybe Num (Time, default real) = Nothing [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
                                                                                        • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                        e-echo -- event echo
                                                                                        transformer
                                                                                        Concrete echo. All events are delayed by the same amount. Also, the parameter signals are sampled at every event, so they can vary over the course of the echo.
                                                                                        Tags: postproc
                                                                                        • delay :: ControlRef = %echo-delay,1 [*-delay] — Delay time.
                                                                                        • feedback :: ControlRef = %echo-feedback,.4 [*-feedback] — The %dyn of each echo is multiplied by this amount.
                                                                                        • times :: ControlRef = %echo-times,1 [*-times] — Number of echoes, not counting the original.
                                                                                        echo -- echo
                                                                                        transformer
                                                                                        Abstract echo. This means the echoes happen in score time, so they will change tempo with the rest of the score, and their derivation may change due to different dynamics.
                                                                                        The controls are only sampled at the beginning of the echo, so you can't vary them over the scope of the echo like you can with e-echo.
                                                                                        • delay :: ControlRef = %echo-delay,1 [*-delay] — Delay time.
                                                                                        • feedback :: ControlRef = %echo-feedback,.4 [*-feedback] — The %dyn of each echo is multiplied by this amount.
                                                                                        • times :: ControlRef = %echo-times,1 [*-times] — Number of echoes, not counting the original.
                                                                                        extend-duration -- extend-duration
                                                                                        transformer
                                                                                        Extend the duration of notes with certain attributes. This is appropriate for attributes like +stac, which might already have their own built-in duration, and sound better when given as much time to ring as possible.
                                                                                        Tags: postproc
                                                                                        • attrs :: list of Attributes [*-attrs] — Extend durations of notes with these attrs.
                                                                                        • dur :: Num (RealTime) = 2s [*-dur] — Extend to a minimum of this duration.
                                                                                        g -- grace
                                                                                        generator
                                                                                        Emit grace notes. The grace notes go through the ( call, so they will overlap or apply a keyswitch, or do whatever ( does.
                                                                                        Tags: ly, ornament
                                                                                        • pitch* :: Pitch or Num [] — Grace note pitches. If they are numbers, they are taken as transpositions and must all be the same type, defaulting to diatonic.
                                                                                        • durenv :: Num (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
                                                                                        • grace-dynenv :: Num (>=0) = .5 [grace-dyn] — Scale the dyn of the grace notes.
                                                                                        • placeenv :: ControlRef = %place,0 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
                                                                                        g- -- grace
                                                                                        generator
                                                                                        Like g, but doesn't use (, and all notes are held to the duration of the event.
                                                                                        Tags: ly, ornament
                                                                                        • pitch* :: Pitch or Num [] — Grace note pitches. If they are numbers, they are taken as transpositions and must all be the same type, defaulting to diatonic.
                                                                                        • durenv :: Num (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
                                                                                        • grace-dynenv :: Num (>=0) = .5 [grace-dyn] — Scale the dyn of the grace notes.
                                                                                        • placeenv :: ControlRef = %place,0 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
                                                                                        grace -- basic-grace
                                                                                        generator
                                                                                        This a grace call where all arguments are required. The idea is that this will be used as the implementation of more specific ornaments, perhaps defined in a definitions file.
                                                                                        Tags: ly, ornament
                                                                                        • pitches :: list of Pitch or Num [] — Grace note pitches. If they are numbers, they are taken as transpositions and must all be the same type, defaulting to diatonic.
                                                                                        • dur :: Num (Time) [] — Duration of grace notes.
                                                                                        • place :: ControlRef [] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
                                                                                        • transformer :: Maybe Quoted = Nothing [] — Apply a transformer to grace notes.
                                                                                        h -- hold
                                                                                        transformer
                                                                                        Set the Derive.EnvKey.hold environ variable.
                                                                                        • time :: Num (Time, default real) = .25s [*-time] — Hold this long.
                                                                                        highlight -- highlight
                                                                                        transformer
                                                                                        Add a highlight color.
                                                                                        • highlight :: Str (nohighlight notice warning error) [*-highlight] — Highlight code.
                                                                                        highlight-out-of-range -- highlight-out-of-range
                                                                                        transformer
                                                                                        Error on notes whose initial pitch is below inst-bottom or above inst-top. The range must be in NNs.
                                                                                          highlight-strings -- highlight-strings
                                                                                          transformer
                                                                                          Highlight any notes whose initial pitch either is or isn't in open-strings.
                                                                                          • openenv :: Str (f t) = f [*-open] — If true, put Info on open strings, else put Warning on non-open ones.
                                                                                          if-c< -- if-c<
                                                                                          generator
                                                                                          if-c> -- if-c<
                                                                                          Derive based on the value of a control.
                                                                                          • control :: Control ([a-z][a-z0-9.-]*) [*-control] — Test this control.
                                                                                          • tests+ :: Val [] — (value, expr) pairs.
                                                                                          if-e -- if-e
                                                                                          generator
                                                                                          Derive based on the value of an environment variable.
                                                                                          • name :: Str [*-name] — Environ key.
                                                                                          • value :: Maybe Val = Nothing [*-value] — Environ value. If not given, require only that the environ key is set.
                                                                                          • true :: Quoted [*-true] — Eval if true.
                                                                                          • false :: Quoted [*-false] — Eval if false.
                                                                                          import -- import
                                                                                          transformer
                                                                                          Import the given modules into scope. Calls of all types (note, control, pitch, val) are imported. If names clash, the ones from later modules win.
                                                                                          • module+ :: Str [] — Import these modules.
                                                                                          imports -- import-symbol
                                                                                          transformer
                                                                                          Import a single symbol, or list of symbols.
                                                                                          • module :: Str [*-module] — Import this module.
                                                                                          • symbol+ :: Str [] — Import these symbols.
                                                                                          infer-dur -- infer-dur
                                                                                          transformer
                                                                                          Add Derive.Flags.infer_duration to the events.
                                                                                          Tags: postproc
                                                                                            infer-hands -- infer-hands
                                                                                            transformer
                                                                                            Infer hand=l and hand=r for the two tracks explicitly named with the same instrument. >2 tracks is an error. This only sets hand if it isn't already set.
                                                                                              interpolate -- interpolate
                                                                                              generator
                                                                                              Interpolate between multiple sub-tracks, each of which must have the same number of events. This interpolates rhythm only. To interpolate pitch and controls, it would need to work at the score event level, rather than ui events.
                                                                                              Tags: subs
                                                                                              • at :: ControlRef = %at,0 [*-at] — interpolate position
                                                                                              Lift -- Lift
                                                                                              transformer
                                                                                              Attack the note from a lower neighbor. This is like the n pitch call, but it's a note call, and it fades in dyn at the same time.
                                                                                              Tags: under-invert
                                                                                              • interval :: Num (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
                                                                                              • time :: Num (Time, default real) = .25s [*-time] — Time to the destination pitch.
                                                                                              • fade :: Maybe Num (Time, default real) = Nothing [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
                                                                                              • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                              lift -- lift
                                                                                              transformer
                                                                                              Raise pitch and drop dyn at the end of the note. Same as the drop note call, except it defaults to going up instead of down.
                                                                                              Tags: under-invert
                                                                                              • interval :: Num (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
                                                                                              • time :: Num (Time, default real) = .25s [*-time] — Time to the destination pitch.
                                                                                              • fade :: Maybe Num (Time, default real) = Nothing [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
                                                                                              • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                              lookup: attribute starting with `+` or `=` -- note with +example-attr
                                                                                              transformer
                                                                                              Add attributes to the notes.
                                                                                              If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
                                                                                              Tags: attr, subs
                                                                                                lookup: block name -- block (bid "example/block")
                                                                                                generator
                                                                                                Substitute the named block into the score. If the symbol doesn't contain a /, the default namespace is applied. If it starts with a -, this is a relative call and the calling block's namespace and name are prepended.
                                                                                                Tags: prio-block
                                                                                                  loop -- loop
                                                                                                  transformer
                                                                                                  This is similar to clip, but when the called note runs out, it is repeated.
                                                                                                    mapc -- mapc
                                                                                                    transformer
                                                                                                    Apply a signal transformer to the pitch or control signals of each event.
                                                                                                    Tags: postproc
                                                                                                    • control :: Control ([a-z][a-z0-9.-]*) or PControl (#[a-z][a-z0-9.-]*) [*-control] — Apply to this control. Pitch signals start with #.
                                                                                                    • transformer :: Quoted [*-transformer] — Transformer to apply.
                                                                                                    multiple -- multiple
                                                                                                    transformer
                                                                                                    Derive the transformed score under different transformers.
                                                                                                    • transformer+ :: Quoted [] — Derive under each transformer.
                                                                                                    n -- note-attributes
                                                                                                    transformer
                                                                                                    This is similar to to =, but it takes any number of >inst and +attr args and sets the inst or attr environ.
                                                                                                    • attribute* :: Str or Attributes [] — Set instrument or attributes.
                                                                                                    note-track -- note-track
                                                                                                    transformer
                                                                                                    This is the implicit call at the top of every note track. The first argument is the instrument named after the note track's >. If there is a note transformer of the same name as the instrument, starting with >, it will be called after setting the instrument. This way, you can set instrument-specific variables or transformations.
                                                                                                    • inst :: Maybe Str = Nothing [] — Set this instrument and run the transformer, if it exists.
                                                                                                    o -- note with +harm
                                                                                                    generator
                                                                                                    m -- note with +mute
                                                                                                    . -- note with +stac
                                                                                                    { -- note with +porta
                                                                                                    lookup: attribute starting with `+` or `=` -- note with +example-attr
                                                                                                    Add attributes to the notes.
                                                                                                    If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
                                                                                                    Tags: attr, subs
                                                                                                      o -- note with +harm
                                                                                                      transformer
                                                                                                      m -- note with +mute
                                                                                                      . -- note with +stac
                                                                                                      { -- note with +porta
                                                                                                      Add attributes to the notes.
                                                                                                      Tags: attr
                                                                                                        omit -- omit
                                                                                                        transformer
                                                                                                        Omit the derived call a certain percentage of the time.
                                                                                                        Tags: random
                                                                                                        • chance :: ControlRef = %omit,.5 [*-chance] — Chance, from 0 to 1, that the transformed note will be omitted.
                                                                                                        parallel -- parallel
                                                                                                        generator
                                                                                                        Run the given calls in parallel.
                                                                                                        • call+ :: Quoted [] — Generator calls.
                                                                                                        pizz-arp -- pizz-arp
                                                                                                        transformer
                                                                                                        Arpeggiate simultaneous notes with +pizz. The order is arbitrary but probably in track order. TODO sort by pitch?
                                                                                                        Tags: inst, postproc
                                                                                                        • time :: ControlRef = %pizz-arp-time,.02 [*-time] — Insert this much time between each note.
                                                                                                        randomize-start -- randomize-start
                                                                                                        transformer
                                                                                                        A static macro for: apply-start-offset | equal '%start-s' (cf-rnd-a $).
                                                                                                        Each $ is lifted to be an argument of this macro.
                                                                                                        This directly calls the underlying sub-calls, so it's not dependent on the names they are bound to, which also means the macro text may not be a valid expression.
                                                                                                        Tags: postproc
                                                                                                        • range :: Num [*-range] — Range this far from the center.
                                                                                                        repeat -- repeat
                                                                                                        transformer
                                                                                                        Repeat the score multiple times, fitted within the note duration.
                                                                                                        • times :: Num (integral, >0) [*-times] — Repeat this many times.
                                                                                                        reverse -- reverse
                                                                                                        transformer
                                                                                                        Reverse the events.
                                                                                                        Tags: postproc
                                                                                                          sequence -- sequence
                                                                                                          generator
                                                                                                          Run the given calls in sequence. If they each have have an intrinsic CallDuration (usually this means block calls), they will get that amount of time, at least proportial to the duration of the event. Otherwise, if none of them do, they are given equal duration. If some do and some don't, you probably get confusing results.
                                                                                                          • call+ :: Quoted [] — Generator calls.
                                                                                                          sequence-rt -- sequence-rt
                                                                                                          generator
                                                                                                          Run the given block calls in sequence. Each call gets its natural real time duration. Unlike sequence, each block gets its natural RealTime duration, rather than being normalized to 1 and then expanded to its ScoreTime duration. TODO I can't get the RealTime duration without deriving, at which point it's too late to stretch, so the event duration has no effect.
                                                                                                          • call+ :: Quoted [] — Generator calls.
                                                                                                          slur-dur -- slur-dur
                                                                                                          transformer
                                                                                                          Merge groups of notes into one note, where the pitch is taken from each merged note. The groups are by duration.
                                                                                                          Tags: postproc
                                                                                                          • dur :: Num (Time, default score) [*-dur] — How long each group is.
                                                                                                          • offset :: Num (Time, default score) = 0t [*-offset] — Groups start at this time.
                                                                                                          • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                          • curve-timeenv :: Num (RealTime) = 0s [curve-time, *-curve-time] — Curve transition time.
                                                                                                          slur-n -- slur-n
                                                                                                          transformer
                                                                                                          Merge groups of notes into one note, where the pitch is taken from each merged note. The groups are of a fixed size.
                                                                                                          Tags: postproc
                                                                                                          • group :: Num (integral) [*-group] — How many notes in a group.
                                                                                                          • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                          • curve-timeenv :: Num (RealTime) = 0s [curve-time, *-curve-time] — Curve transition time.
                                                                                                          solo -- solo
                                                                                                          transformer
                                                                                                          Only derive if inst is set to the given value. This is a specialized version of when-e.
                                                                                                          • inst :: Str [*-inst] — Instrument.
                                                                                                          strong -- strong
                                                                                                          transformer
                                                                                                          Add the Derive.Flags.strong flag, which will cancel coincident non-strong notes.
                                                                                                          Tags: postproc
                                                                                                            sus -- sus
                                                                                                            transformer
                                                                                                            Simple legato, extend the duration of the transformed notes by the given amount. This works by setting %sus.
                                                                                                            • amount :: Num = 1.5 [*-amount] — Multiply the note's duration by this.
                                                                                                            sus-a -- sus-a
                                                                                                            transformer
                                                                                                            Simple legato, extend the duration of the transformed notes by the given amount. This works by setting %sus-abs.
                                                                                                            • time :: Num (Time, default real) = .25s [*-time] — Add this duration to the note.
                                                                                                            t -- tuplet
                                                                                                            generator
                                                                                                            tup -- tuplet
                                                                                                            A generalized tuplet. The notes within its scope are stretched so that their collective duration is the same as the tuplet's duration.
                                                                                                            This doesn't work so well for zero duration notes. The last note winds up at the end of the tuplet, which is not very useful. But zero duration is common for percussion, so there's a hack to cover this case: if there are >1 equidistant zero duration sub events, the distance between them is considered their implicit duration.
                                                                                                            If there are multiple note tracks, they get the stretch of the longest one. This is so the timing will come out right if some of the notes are chords.
                                                                                                            Tags: subs
                                                                                                              t-alt -- tempo-alternate
                                                                                                              generator
                                                                                                              Derive alternate calls depending on the tempo, for Javanese-style wirama transitions. For instance, a 1/8 b 1/4 c will play a when an 8th note is between 0 and 1/8s, b when it's between 1/8s and 1/4s, and c when it's above 1/4s.
                                                                                                              • bottom :: Quoted [] — Default alternate.
                                                                                                              • threshold,expr* :: (Num (RealTime), Quoted) [] — Evaluate the expr if the tempo is above the threshold. The thresholds should be in ascending order, so the fastest alternate is at the left.
                                                                                                              • timestepenv :: Str (section w h q e s t32 t64 t128 t256) = e [*-timestep] — Use the duration of this timestep, in seconds.
                                                                                                              t-alt-c -- tempo-alternate-continuous
                                                                                                              generator
                                                                                                              Derive alternate calls depending on the tempo, for Javanese-style wirama transitions. For instance, a 1/8 b 1/4 c will play a when an 8th note is between 0 and 1/8s, b when it's between 1/8s and 1/4s, and c when it's above 1/4s.
                                                                                                              This variant will switch between the alternates even in the middle of the call. Long notes will be shortened clipped at the transition point.
                                                                                                              • bottom :: Quoted [] — Default alternate.
                                                                                                              • threshold,expr* :: (Num (RealTime), Quoted) [] — Evaluate the expr if the tempo is above the threshold. The thresholds should be in ascending order, so the fastest alternate is at the left.
                                                                                                              • timestepenv :: Str (section w h q e s t32 t64 t128 t256) = e [*-timestep] — Use the duration of this timestep, in seconds.
                                                                                                              • intervalenv :: Str (section w h q e s t32 t64 t128 t256) = q [*-interval] — Switch between alternates at this time interval.
                                                                                                              tile -- tile
                                                                                                              transformer
                                                                                                              This is like loop, but it can start the looped call in its middle instead of starting from 0. The effect is as if the loop is tiled from the beginning of the called block, and is only "let through" during the tile call. This is useful for patterns that are tied to the meter, but may be interrupted at arbitrary times, e.g. sarvalaghu patterns.
                                                                                                                tr -- tr
                                                                                                                generator
                                                                                                                Generate a note with a trill.
                                                                                                                Unlike a trill on a pitch track, this generates events for each note of the trill. This is more appropriate for fingered trills, or monophonic instruments that use legato to play slurred notes.
                                                                                                                Tags: ly
                                                                                                                • neighbor :: ControlRef = %tr-neighbor,1d [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                • tr-startenv :: Maybe Str (high low) = Nothing [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
                                                                                                                • tr-endenv :: Maybe Str (high low) = Nothing [tr-end] — Which note the trill ends with. If not given, it can end with either.
                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                tr-^ -- tr
                                                                                                                generator
                                                                                                                tr-_ -- tr
                                                                                                                Generate a note with a trill.
                                                                                                                Unlike a trill on a pitch track, this generates events for each note of the trill. This is more appropriate for fingered trills, or monophonic instruments that use legato to play slurred notes.
                                                                                                                A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
                                                                                                                Tags: ly
                                                                                                                • neighbor :: ControlRef = %tr-neighbor,1d [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                • tr-startenv :: Maybe Str (high low) = Nothing [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                tr^ -- tr
                                                                                                                generator
                                                                                                                tr_ -- tr
                                                                                                                Generate a note with a trill.
                                                                                                                Unlike a trill on a pitch track, this generates events for each note of the trill. This is more appropriate for fingered trills, or monophonic instruments that use legato to play slurred notes.
                                                                                                                A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
                                                                                                                Tags: ly
                                                                                                                • neighbor :: ControlRef = %tr-neighbor,1d [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                • tr-endenv :: Maybe Str (high low) = Nothing [tr-end] — Which note the trill ends with. If not given, it can end with either.
                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                tr^^ -- tr
                                                                                                                generator
                                                                                                                tr^_ -- tr
                                                                                                                tr_^ -- tr
                                                                                                                tr__ -- tr
                                                                                                                Generate a note with a trill.
                                                                                                                Unlike a trill on a pitch track, this generates events for each note of the trill. This is more appropriate for fingered trills, or monophonic instruments that use legato to play slurred notes.
                                                                                                                A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
                                                                                                                Tags: ly
                                                                                                                • neighbor :: ControlRef = %tr-neighbor,1d [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                trem -- trem
                                                                                                                generator
                                                                                                                Repeat a single note. Or, if there are sub-notes, alternate with each of the sub-notes in turn.
                                                                                                                Tags: ly
                                                                                                                • speed :: ControlRef = %speed,10s [*-speed] — Repeat at this speed. If it's a RealTime, the value is the number of repeats per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of repeats per ScoreTime unit, and will stretch along with tempo changes.
                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                trem -- trem
                                                                                                                transformer
                                                                                                                Repeat the transformed note. The generator is creating the notes so it can set them to the appropriate duration, but this one has to stretch them to fit.
                                                                                                                Tags: subs
                                                                                                                • speed :: ControlRef = %speed,10s [*-speed] — Repeat at this speed. If it's a RealTime, the value is the number of repeats per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of repeats per ScoreTime unit, and will stretch along with tempo changes.
                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                v -- accent
                                                                                                                generator
                                                                                                                Accent the note by multiplying its dynamic.
                                                                                                                If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
                                                                                                                Tags: ly, subs
                                                                                                                • dyn :: Num = 1.5 [*-dyn] — Multiply dynamic.
                                                                                                                v -- accent
                                                                                                                transformer
                                                                                                                Accent the note by multiplying its dynamic.
                                                                                                                Tags: ly
                                                                                                                • dyn :: Num = 1.5 [*-dyn] — Multiply dynamic.
                                                                                                                weak -- weak
                                                                                                                transformer
                                                                                                                Add the Derive.Flags.weak flag, which will cause this to be cancelled by coincident non-weak notes.
                                                                                                                Tags: postproc
                                                                                                                  when-c -- when-c
                                                                                                                  transformer
                                                                                                                  unless-c -- when-c
                                                                                                                  Only derive if the control has the given value. E.g., you can use a %var control to select among different variations.
                                                                                                                  • val :: Num (integral) [*-val] — Value.
                                                                                                                  • control :: ControlRef = %var,0 [*-control] — Control.
                                                                                                                  when-e -- when-e
                                                                                                                  transformer
                                                                                                                  unless-e -- when-e
                                                                                                                  Only derive if environ value is set to the given value. In a block derived multiple times by different instruments, this can be used to solo a bit of score to one particular instrument.
                                                                                                                  • name :: Str [*-name] — Environ key.
                                                                                                                  • value :: Maybe Val = Nothing [*-value] — Environ value. If not given, require only that the environ key is set.
                                                                                                                  zero-duration-mute -- zero-duration-mute
                                                                                                                  transformer
                                                                                                                  Add attributes to zero duration events.
                                                                                                                  Tags: inst, postproc
                                                                                                                  • attr :: Attributes = +mute [*-attr] — Add this attribute.
                                                                                                                  • dyn :: Num = .75 [*-dyn] — Scale dynamic by this amount.
                                                                                                                  Module: retune (2 calls)

                                                                                                                  realize-retune -- retune-realize
                                                                                                                  transformer
                                                                                                                  Perform annotations added by retune.
                                                                                                                  Tags: realize-delayed
                                                                                                                    retune -- retune
                                                                                                                    transformer
                                                                                                                    Notes start with some detuning, and adjust to the desired pitch. This effect is scaled by the time and pitch distance from the previous note, as documeneted in Derive.Call.Post.Retune.pitch_scale.
                                                                                                                    Tags: delayed
                                                                                                                    • time :: ControlRef = %retune-time,.15 [*-time] — RealTime to get to the intended pitch.
                                                                                                                    • dist :: ControlRef = %retune-dist,.15 [*-dist] — Out of tune distance, in NNs. Presumably this should be set to a control function with a bimodal distribution.

                                                                                                                    control

                                                                                                                    Module: india.gamakam (6 calls)

                                                                                                                    dip -- dip
                                                                                                                    generator
                                                                                                                    Alternate two intervals, dropping dyn on the second. This is useful when avoiding a swaram, since it doesn't necessarily emit the base pitch.
                                                                                                                    • high :: Num = 1 [*-high] — High interval.
                                                                                                                    • low :: Num = -1 [*-low] — Low interval.
                                                                                                                    • speed :: ControlRef = %tr-speed,6s [*-speed] — Alternate pitches at this speed.
                                                                                                                    • dyn :: Num = .5 [*-dyn] — Multiply dyn by this amount.
                                                                                                                    • transitionenv :: Num (RealTime) = .08s [transition, *-transition] — Time for each slide.
                                                                                                                    j) -- j)
                                                                                                                    generator
                                                                                                                    This is a series of grace notes with relative pitches.
                                                                                                                    • interval+ :: Num [] — Intervals from base pitch.
                                                                                                                    • timeenv :: Num (RealTime) = .15s [time, *-time] — Time for each note.
                                                                                                                    • transitionenv :: Maybe Num (RealTime) = Nothing [transition, *-transition] — Time for each slide, defaults to time.
                                                                                                                    j] -- j]
                                                                                                                    generator
                                                                                                                    This is a series of grace notes with relative pitches.
                                                                                                                    • interval+ :: Num [] — Intervals from base pitch.
                                                                                                                    • timeenv :: Num (RealTime) = .15s [time, *-time] — Time for each note.
                                                                                                                    • transitionenv :: Maybe Num (RealTime) = .075s [transition, *-transition] — Time for each slide.
                                                                                                                    kam -- kam
                                                                                                                    generator
                                                                                                                    kam_ -- kam
                                                                                                                    kam^ -- kam
                                                                                                                    _kam -- kam
                                                                                                                    _kam_ -- kam
                                                                                                                    _kam^ -- kam
                                                                                                                    ^kam -- kam
                                                                                                                    ^kam_ -- kam
                                                                                                                    ^kam^ -- kam
                                                                                                                    This is a trill with smooth transitions between the notes. It's intended for the microtonal vocal trills common in Carnatic music. ^ is high and _ is low, so ^kam_ starts on the upper note, and ends on the lower one. Otherwise, it starts on the unison note and ends on either.
                                                                                                                    • neighbor :: ControlRef = %tr-neighbor,1 [*-neighbor] — Alternate between 0 and this value.
                                                                                                                    • speed :: ControlRef = %tr-speed,6s [*-speed] — Alternate pitches at this speed.
                                                                                                                    • transition :: Num (RealTime) = .08s [transition, *-transition] — Time for each slide.
                                                                                                                    • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                    • liltenv :: Num = 0 [lilt, *-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                    • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                    nkam -- nkam
                                                                                                                    generator
                                                                                                                    nkam_ -- nkam
                                                                                                                    nkam^ -- nkam
                                                                                                                    _nkam -- nkam
                                                                                                                    _nkam_ -- nkam
                                                                                                                    _nkam^ -- nkam
                                                                                                                    ^nkam -- nkam
                                                                                                                    ^nkam_ -- nkam
                                                                                                                    ^nkam^ -- nkam
                                                                                                                    kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
                                                                                                                    • neighbor :: ControlRef = %tr-neighbor,1 [*-neighbor] — Alternate between 0 and this value.
                                                                                                                    • cycles :: Num (>0) = 1 [*-cycles] — Number of cycles.
                                                                                                                    • liltenv :: Num = 0 [lilt, *-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                    • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                    • transitionenv :: Num (RealTime) = .08s [transition, *-transition] — Time for each slide.
                                                                                                                    sgr -- jaru
                                                                                                                    generator
                                                                                                                    This is jaru hardcoded to [-1, 1].
                                                                                                                    • time :: Num (RealTime) = .15s [*-time] — Time for each note.
                                                                                                                    • transition :: Maybe Num (RealTime) = Nothing [*-transition] — Time for each slide, defaults to time.
                                                                                                                    Module: india.gamakam5 (2 calls)

                                                                                                                    dyn -- dyn
                                                                                                                    transformer
                                                                                                                    Import calls for a dyn track.
                                                                                                                      gamak -- gamak
                                                                                                                      transformer
                                                                                                                      Import calls for a gamakam track.
                                                                                                                        Module: india.gamakam5.dyn (1 calls)

                                                                                                                        ! -- dyn-sequence
                                                                                                                        generator
                                                                                                                        This is a mini-language, where each one or two characters is a call. Each character can take an argument, which can only be a single digit. Typically this represents a dyn level / 9, so 0 is 0 and 9 is 1. Calls:
                                                                                                                        . - Move to dyn.
                                                                                                                        < - Attack from 0.
                                                                                                                        = - No movement.
                                                                                                                        > - Decay to 0, with curve weights: (.8, 0)
                                                                                                                        T - Set from dyn.
                                                                                                                        a - Attack from previous value.
                                                                                                                        d - Decay to 0, with curve weights: (0, .8)
                                                                                                                        • sequence :: Str [*-sequence] — Dyn calls.
                                                                                                                        Module: india.gamakam5.pitch (1 calls)

                                                                                                                        ! -- sequence
                                                                                                                        generator
                                                                                                                        This is a mini-language, where each one or two characters is a call. An upper-case call will take a single character argument. A special parsing rule means that - and its following character is considered a single character, so -1 is a valid call or argument. Most of these calls represent a pitch movement:
                                                                                                                        - - Negative relative motion.
                                                                                                                        . - Postfix call that modifies the duration of the previous call. _ adds 1 to it, . divides by 2. (dur 0)
                                                                                                                        0 - Relative motion.
                                                                                                                        1 - Relative motion.
                                                                                                                        2 - Relative motion.
                                                                                                                        3 - Relative motion.
                                                                                                                        4 - Relative motion.
                                                                                                                        5 - Relative motion.
                                                                                                                        6 - Relative motion.
                                                                                                                        7 - Relative motion.
                                                                                                                        8 - Relative motion.
                                                                                                                        9 - Relative motion.
                                                                                                                        < - Set from pitch to previous. (dur 0)
                                                                                                                        = - Hold flat pitch.
                                                                                                                        F - Fast transition time. (dur 0)
                                                                                                                        M - Medium transition time. (dur 0)
                                                                                                                        S - Slow transition time. (dur 0)
                                                                                                                        T - Set from pitch relative to swaram. (dur 0)
                                                                                                                        ^ - Set from pitch to current. (dur 0)
                                                                                                                        _ - Postfix call that modifies the duration of the previous call. _ adds 1 to it, . divides by 2. (dur 0)
                                                                                                                        a - Negative relative motion.
                                                                                                                        b - Negative relative motion.
                                                                                                                        c - Negative relative motion.
                                                                                                                        e - Pitch up by 1nn.
                                                                                                                        f - Pitch down by 1nn.
                                                                                                                        g - Pitch up by .5nn.
                                                                                                                        h - Pitch down by .5nn.
                                                                                                                        n - Pitch up by 1nn. (dur .5); Pitch down by 1nn. (dur .5)
                                                                                                                        u - Pitch down by 1nn. (dur .5); Pitch up by 1nn. (dur .5)
                                                                                                                        v - Absolute motion to next pitch.

                                                                                                                        Currently the transition curve is hardcoded to a sigmoid curve, but I could add a curve env var if necessary.
                                                                                                                        • sequence :: Str [*-sequence] — Pitch calls.
                                                                                                                        • transitionenv :: Num (0 <= x <= 1) = .5 [transition, *-transition] — Time for each pitch movement, in proportion of the total time available.
                                                                                                                        Module: prelude (56 calls)

                                                                                                                        ' -- set-prev
                                                                                                                        generator
                                                                                                                        Re-set the previous value. This can be used to extend a breakpoint.
                                                                                                                        Tags: prev
                                                                                                                          -> -- redirect
                                                                                                                          transformer
                                                                                                                          Redirect a signal to another control, using the control modifier hack. The control is combined with the default merger for the control.
                                                                                                                          Tags: cmod
                                                                                                                          • control :: Control ([a-z][a-z0-9.-]*) [*-control] — Redirect to this control.
                                                                                                                          ->+ -- redirect
                                                                                                                          transformer
                                                                                                                          Redirect a signal to another control, using the control modifier hack. The control is combined with add.
                                                                                                                          Tags: cmod
                                                                                                                          • control :: Control ([a-z][a-z0-9.-]*) [*-control] — Redirect to this control.
                                                                                                                          = -- equal
                                                                                                                          transformer
                                                                                                                          Evaluate the deriver with a value set. Special parser support means this can be called infix. The arguments can take many forms to set different kinds of values.
                                                                                                                          Set an environ value by setting a plain symbol or unset it by assigning to _: x = 42 or x = _.
                                                                                                                          Alias instrument names like: >alias = >inst.
                                                                                                                          If the lhs is prefixed with >>, ^, *, ., or -, it will add a new name for a ^note, *pitch, .control, or -val call, respectively. It sets the generator by default, but will set the transformer if you prefix another -. >> is special cased to only create a note transformer, whose name will be prefixed with >. This is used to set an instrument transformer, which can apply a transformer when an instrument is set by the title of a note track, as implemented by by note-track.
                                                                                                                          E.g.: set note generator: ^phrase = some-block, note transformer: ^-mute = +mute+loose, control transfomrer: .-i = t, val call: -4c = (5c).
                                                                                                                          You can bypass all this cryptic prefix garbage by using a ky file. It has more space available so it can use a more readable syntax.
                                                                                                                          If you bind a call to a quoted expression, this creates a new call: ^abc = "(a b c) will create a abc call, which is a macro for a b c. The created call does not take arguments.
                                                                                                                          Set constant signals by assigning to a signal literal: %c = .5 or pitch: #p = (4c). # = (4c) sets the default pitch signal. You can rename a signal via %a = %b or #x = #y. Control signal assignment also supports the same merge functions as the control track: %a = .5 add or %a = %b add. However, the second example throws an error if %b is a ControlFunction. %a = .5 default will combine with a's default merge function. Assigning to _ unsets the control, and any ControlFunction.
                                                                                                                          The = operator can be suffixed with symbol, which will become the last argument, so %x=+1 becomes %x = 1 '+'. Note that the order is backwards from the usual +=, which is ultimately because the first word can have almost any character except space and =. Also, x=-1 is ambiguous, and parsed as x =- 1.
                                                                                                                          Tags: subs
                                                                                                                          • lhs :: Str [*-lhs] — Assign to this. This looks like a Str, but can actualy contain any characters except =, due to the special infix parsing for =. Symbolic prefixes determine what is assigned, and the valid types for the rhs.
                                                                                                                          • rhs :: Val [*-rhs] — Source of the assignment.
                                                                                                                          • merge :: Str = set [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from Derive.Deriver.Monad.mergers: add, interleave, max, min, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
                                                                                                                          `ped` -- pedal
                                                                                                                          generator
                                                                                                                          ped -- pedal
                                                                                                                          Unlike most control events, this uses a duration. Set the control to the given value for the event's duration, and reset to the old value afterwards.
                                                                                                                          • val :: Num = 1 [*-val] — Set to this value.
                                                                                                                          • durenv :: Num (RealTime) = .05s [*-dur] — Use this duration if the event duration is 0.
                                                                                                                          abs -- abs
                                                                                                                          generator
                                                                                                                          Set the control to an absolute value, provided this control is combined via multiplication.
                                                                                                                          • val :: Num [*-val] — Set to this value.
                                                                                                                          alt -- alternate
                                                                                                                          generator
                                                                                                                          Pick one of several expressions and evaluate it.
                                                                                                                          Tags: random
                                                                                                                          • expr+ :: Quoted [] — Expression to evaluate.
                                                                                                                          alt-w -- alternate-weighted
                                                                                                                          generator
                                                                                                                          Pick one of several expressions and evaluate it.
                                                                                                                          Tags: random
                                                                                                                          • expr+ :: (Num, Quoted) [] — (weight, expr) pairs.
                                                                                                                          bp> -- breakpoint
                                                                                                                          generator
                                                                                                                          Interpolate between the given values. Breakpoints start at this event and end at the next one.
                                                                                                                          • val+ :: Num [] — Breakpoints are distributed evenly between this event and the next event.
                                                                                                                          d -- d
                                                                                                                          generator
                                                                                                                          Descend at the given speed until the value reaches 0 or the next event.
                                                                                                                          Tags: prev
                                                                                                                          • speed :: Num = 1 [*-speed] — Descend this amount per second.
                                                                                                                          • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                          default-merge -- default-merge
                                                                                                                          transformer
                                                                                                                          Set the default merge operators for controls. These apply when the control track doesn't have an explicit operator.
                                                                                                                          • merge :: Str [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from Derive.Deriver.Monad.mergers: add, interleave, max, min, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
                                                                                                                          • control+ :: Control ([a-z][a-z0-9.-]*) [] — Control names.
                                                                                                                          df -- df
                                                                                                                          generator
                                                                                                                          Drop from a certain value. This is like d with from, but more convenient to write.
                                                                                                                          • from :: Num = 1 [*-from] — Start at this value.
                                                                                                                          • speed :: Num = 1 [*-speed] — Descend this amount per second.
                                                                                                                          dyn-f -- f
                                                                                                                          generator
                                                                                                                          Set the control to an absolute value. This is useful for the dyn control, so a part can override the dynamic in scope.
                                                                                                                          • val :: Num = .75 [*-val] — Set to this value.
                                                                                                                          dyn-ff -- ff
                                                                                                                          generator
                                                                                                                          Set the control to an absolute value. This is useful for the dyn control, so a part can override the dynamic in scope.
                                                                                                                          • val :: Num = .95 [*-val] — Set to this value.
                                                                                                                          dyn-mf -- mf
                                                                                                                          generator
                                                                                                                          Set the control to an absolute value. This is useful for the dyn control, so a part can override the dynamic in scope.
                                                                                                                          • val :: Num = .5 [*-val] — Set to this value.
                                                                                                                          dyn-p -- p
                                                                                                                          generator
                                                                                                                          Set the control to an absolute value. This is useful for the dyn control, so a part can override the dynamic in scope.
                                                                                                                          • val :: Num = .25 [*-val] — Set to this value.
                                                                                                                          dyn-pp -- pp
                                                                                                                          generator
                                                                                                                          Set the control to an absolute value. This is useful for the dyn control, so a part can override the dynamic in scope.
                                                                                                                          • val :: Num = .05 [*-val] — Set to this value.
                                                                                                                          e -- exp
                                                                                                                          generator
                                                                                                                          Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
                                                                                                                          Tags: prev
                                                                                                                          • to :: Num [*-to] — Destination value.
                                                                                                                          • exp :: Num = 2 [*-exp] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
                                                                                                                          • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                          e<< -- exp-prev-const
                                                                                                                          generator
                                                                                                                          Interpolate from the previous value to the given one.
                                                                                                                          Tags: prev
                                                                                                                          • to :: Num [*-to] — Destination value.
                                                                                                                          • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
                                                                                                                          • exp :: Num = 2 [*-exp] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
                                                                                                                          • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                          e> -- exp-next
                                                                                                                          generator
                                                                                                                          Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
                                                                                                                          Tags: prev
                                                                                                                          • to :: Num [*-to] — Destination value.
                                                                                                                          • exp :: Num = 2 [*-exp] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
                                                                                                                          • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                          e>> -- exp-next-const
                                                                                                                          generator
                                                                                                                          Interpolate from the previous value to the given one.
                                                                                                                          Tags: prev
                                                                                                                          • to :: Num [*-to] — Destination value.
                                                                                                                          • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination.
                                                                                                                          • exp :: Num = 2 [*-exp] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
                                                                                                                          • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                          h -- hold
                                                                                                                          transformer
                                                                                                                          Set the Derive.EnvKey.hold environ variable.
                                                                                                                          • time :: Num (Time, default real) = .25s [*-time] — Hold this long.
                                                                                                                          i -- linear
                                                                                                                          generator
                                                                                                                          Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
                                                                                                                          Tags: prev
                                                                                                                          • to :: Num [*-to] — Destination value.
                                                                                                                          • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                          i<< -- linear-prev-const
                                                                                                                          generator
                                                                                                                          Interpolate from the previous value to the given one.
                                                                                                                          Tags: prev
                                                                                                                          • to :: Num [*-to] — Destination value.
                                                                                                                          • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
                                                                                                                          • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                          i> -- linear-next
                                                                                                                          generator
                                                                                                                          Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
                                                                                                                          Tags: prev
                                                                                                                          • to :: Num [*-to] — Destination value.
                                                                                                                          • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                          i>> -- linear-next-const
                                                                                                                          generator
                                                                                                                          Interpolate from the previous value to the given one.
                                                                                                                          Tags: prev
                                                                                                                          • to :: Num [*-to] — Destination value.
                                                                                                                          • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination.
                                                                                                                          • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                          if-c< -- if-c<
                                                                                                                          generator
                                                                                                                          if-c> -- if-c<
                                                                                                                          Derive based on the value of a control.
                                                                                                                          • control :: Control ([a-z][a-z0-9.-]*) [*-control] — Test this control.
                                                                                                                          • tests+ :: Val [] — (value, expr) pairs.
                                                                                                                          if-e -- if-e
                                                                                                                          generator
                                                                                                                          Derive based on the value of an environment variable.
                                                                                                                          • name :: Str [*-name] — Environ key.
                                                                                                                          • value :: Maybe Val = Nothing [*-value] — Environ value. If not given, require only that the environ key is set.
                                                                                                                          • true :: Quoted [*-true] — Eval if true.
                                                                                                                          • false :: Quoted [*-false] — Eval if false.
                                                                                                                          import -- import
                                                                                                                          transformer
                                                                                                                          Import the given modules into scope. Calls of all types (note, control, pitch, val) are imported. If names clash, the ones from later modules win.
                                                                                                                          • module+ :: Str [] — Import these modules.
                                                                                                                          imports -- import-symbol
                                                                                                                          transformer
                                                                                                                          Import a single symbol, or list of symbols.
                                                                                                                          • module :: Str [*-module] — Import this module.
                                                                                                                          • symbol+ :: Str [] — Import these symbols.
                                                                                                                          lookup: block id -- control-block
                                                                                                                          generator
                                                                                                                          Substitute the control signal from the named control block. A control block should consist of a single branch ending in a track named %. The signal from that track will be substituted.
                                                                                                                            lookup: numbers and hex -- set
                                                                                                                            generator
                                                                                                                            Emit a sample with no interpolation. This accepts either decimal numbers or hex numbers that look like `0x`xx. The hex is divided by 255, so they represent a number between 0 and 1.
                                                                                                                            Setting a control called <controlname>-rnd will cause the set value to be randomized by the given number.
                                                                                                                              lookup: numbers and hex -- set
                                                                                                                              transformer
                                                                                                                              Prepend a sample to a signal. This is useful to create a discontinuity, e.g. interpolate to a value and then jump to another one.
                                                                                                                                n -- neighbor
                                                                                                                                generator
                                                                                                                                Emit a slide from a value to 0 in absolute time. This is the control equivalent of the neighbor pitch call.
                                                                                                                                • neighbor :: Num = 1 [*-neighbor] — Start at this value.
                                                                                                                                • time :: Num (Time, default real) = .1s [*-time] — Time taken to get to 0.
                                                                                                                                • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                omit -- omit
                                                                                                                                transformer
                                                                                                                                Omit the derived call a certain percentage of the time.
                                                                                                                                Tags: random
                                                                                                                                • chance :: ControlRef = %omit,.5 [*-chance] — Chance, from 0 to 1, that the transformed note will be omitted.
                                                                                                                                p -- porta
                                                                                                                                generator
                                                                                                                                Interpolate between two values. This is similar to i>>, but intended to be higher level, in that instruments or scores can override it to represent an idiomatic portamento.
                                                                                                                                • to :: Num [*-to] — Destination value.
                                                                                                                                • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination.
                                                                                                                                • place :: Num (0 <= x <= 1) = .5 [place, *-place] — Placement, from before to after the call.
                                                                                                                                • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                                • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                quantize -- quantize
                                                                                                                                transformer
                                                                                                                                Quantize a control signal.
                                                                                                                                • val :: Num [*-val] — Quantize to multiples of this value.
                                                                                                                                s -- sigmoid
                                                                                                                                generator
                                                                                                                                Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
                                                                                                                                Tags: prev
                                                                                                                                • to :: Num [*-to] — Destination value.
                                                                                                                                • w1 :: Num = .5 [*-w1] — Start weight.
                                                                                                                                • w2 :: Num = .5 [*-w2] — End weight.
                                                                                                                                • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                                s<< -- sigmoid-prev-const
                                                                                                                                generator
                                                                                                                                Interpolate from the previous value to the given one.
                                                                                                                                Tags: prev
                                                                                                                                • to :: Num [*-to] — Destination value.
                                                                                                                                • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
                                                                                                                                • w1 :: Num = .5 [*-w1] — Start weight.
                                                                                                                                • w2 :: Num = .5 [*-w2] — End weight.
                                                                                                                                • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                                s> -- sigmoid-next
                                                                                                                                generator
                                                                                                                                Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
                                                                                                                                Tags: prev
                                                                                                                                • to :: Num [*-to] — Destination value.
                                                                                                                                • w1 :: Num = .5 [*-w1] — Start weight.
                                                                                                                                • w2 :: Num = .5 [*-w2] — End weight.
                                                                                                                                • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                                s>> -- sigmoid-next-const
                                                                                                                                generator
                                                                                                                                Interpolate from the previous value to the given one.
                                                                                                                                Tags: prev
                                                                                                                                • to :: Num [*-to] — Destination value.
                                                                                                                                • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination.
                                                                                                                                • w1 :: Num = .5 [*-w1] — Start weight.
                                                                                                                                • w2 :: Num = .5 [*-w2] — End weight.
                                                                                                                                • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                                saw -- saw
                                                                                                                                generator
                                                                                                                                Emit a sawtooth. By default it has a downward slope, but you can make an upward slope by setting from and to.
                                                                                                                                • speed :: ControlRef = %speed,10s [*-speed] — Repeat at this speed. If it's a RealTime, the value is the number of repeats per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of repeats per ScoreTime unit, and will stretch along with tempo changes.
                                                                                                                                • from :: Num = 1 [*-from] — Start from this value.
                                                                                                                                • to :: Num = 0 [*-to] — End at this value.
                                                                                                                                set -- set
                                                                                                                                generator
                                                                                                                                Emit a sample with no interpolation.
                                                                                                                                • to :: Num [*-to] — Destination value.
                                                                                                                                sh -- sh
                                                                                                                                transformer
                                                                                                                                Sample & hold. Hold values at the given speed.
                                                                                                                                • speed :: ControlRef = %speed,10s [*-speed] — Repeat at this speed. If it's a RealTime, the value is the number of repeats per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of repeats per ScoreTime unit, and will stretch along with tempo changes.
                                                                                                                                sine -- sine
                                                                                                                                generator
                                                                                                                                sine+ -- sine
                                                                                                                                sine- -- sine
                                                                                                                                Emit a sine wave. The default version is centered on the offset, and the + and - variants are above and below it, respectively.
                                                                                                                                • speed :: ControlRef = %sine-speed,1s [*-speed] — Frequency.
                                                                                                                                • amp :: Num = 1 [*-amp] — Amplitude, measured center to peak.
                                                                                                                                • offset :: Num = 0 [*-offset] — Center point.
                                                                                                                                slew -- slew
                                                                                                                                transformer
                                                                                                                                Smooth a signal by interpolating such that it doesn't exceed the given slope.
                                                                                                                                • slope :: Num [*-slope] — Maximum allowed slope, per second.
                                                                                                                                smooth -- smooth
                                                                                                                                transformer
                                                                                                                                Smooth a signal by interpolating between each sample.
                                                                                                                                • time :: Num (Time, default real) [*-time] — Amount of time to reach to the next sample. If negative, it will end on the destination sample rather than start on it. The time will be compressed if the samples are too close, so unlike slew, this will always reach the samples in the source.
                                                                                                                                • curve :: Str = i [*-curve] — Curve.
                                                                                                                                swell -- swell
                                                                                                                                generator
                                                                                                                                Start at the given value, interpolate to a peak, then back to the original value. Uses duration.
                                                                                                                                • val :: Num [*-val] — Start value.
                                                                                                                                • peak :: Num = 1 [*-peak] — Interpolate to this value.
                                                                                                                                • bias :: Num = .5 [*-bias] — 0 puts the peak at the start, 1 at the end.
                                                                                                                                tr -- tr
                                                                                                                                generator
                                                                                                                                The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
                                                                                                                                • neighbor :: ControlRef = %tr-neighbor,1 [*-neighbor] — Alternate with this value.
                                                                                                                                • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                                • tr-transitionenv :: ControlRef = %tr-transition,0 [tr-transition] — Alternate with a pitch at this interval.
                                                                                                                                • tr-startenv :: Maybe Str (high low) = Nothing [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
                                                                                                                                • tr-endenv :: Maybe Str (high low) = Nothing [tr-end] — Which note the trill ends with. If not given, it can end with either.
                                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                tr-^ -- tr
                                                                                                                                generator
                                                                                                                                tr-_ -- tr
                                                                                                                                The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
                                                                                                                                A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
                                                                                                                                • neighbor :: ControlRef = %tr-neighbor,1 [*-neighbor] — Alternate with this value.
                                                                                                                                • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                                • tr-transitionenv :: ControlRef = %tr-transition,0 [tr-transition] — Alternate with a pitch at this interval.
                                                                                                                                • tr-startenv :: Maybe Str (high low) = Nothing [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
                                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                tr^ -- tr
                                                                                                                                generator
                                                                                                                                tr_ -- tr
                                                                                                                                The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
                                                                                                                                A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
                                                                                                                                • neighbor :: ControlRef = %tr-neighbor,1 [*-neighbor] — Alternate with this value.
                                                                                                                                • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                                • tr-transitionenv :: ControlRef = %tr-transition,0 [tr-transition] — Alternate with a pitch at this interval.
                                                                                                                                • tr-endenv :: Maybe Str (high low) = Nothing [tr-end] — Which note the trill ends with. If not given, it can end with either.
                                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                tr^^ -- tr
                                                                                                                                generator
                                                                                                                                tr^_ -- tr
                                                                                                                                tr_^ -- tr
                                                                                                                                tr__ -- tr
                                                                                                                                The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
                                                                                                                                A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
                                                                                                                                • neighbor :: ControlRef = %tr-neighbor,1 [*-neighbor] — Alternate with this value.
                                                                                                                                • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                                • tr-transitionenv :: ControlRef = %tr-transition,0 [tr-transition] — Alternate with a pitch at this interval.
                                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                u -- u
                                                                                                                                generator
                                                                                                                                Ascend at the given speed until the value reaches 1 or the next event.
                                                                                                                                Tags: prev
                                                                                                                                • speed :: Num = 1 [*-speed] — Ascend this amount per second.
                                                                                                                                • fromenv :: Maybe Num = Nothing [from, *-from] — Start from this value. If unset, use the previous value.
                                                                                                                                when-c -- when-c
                                                                                                                                transformer
                                                                                                                                unless-c -- when-c
                                                                                                                                Only derive if the control has the given value. E.g., you can use a %var control to select among different variations.
                                                                                                                                • val :: Num (integral) [*-val] — Value.
                                                                                                                                • control :: ControlRef = %var,0 [*-control] — Control.
                                                                                                                                when-e -- when-e
                                                                                                                                transformer
                                                                                                                                unless-e -- when-e
                                                                                                                                Only derive if environ value is set to the given value. In a block derived multiple times by different instruments, this can be used to solo a bit of score to one particular instrument.
                                                                                                                                • name :: Str [*-name] — Environ key.
                                                                                                                                • value :: Maybe Val = Nothing [*-value] — Environ value. If not given, require only that the environ key is set.
                                                                                                                                xcut -- xcut
                                                                                                                                generator
                                                                                                                                xcut-h -- xcut
                                                                                                                                Cross-cut between two signals. The -h variant holds the value at the beginning of each transition.
                                                                                                                                • val1 :: ControlRef = %xcut1,1 [*-val1] — First value.
                                                                                                                                • val2 :: ControlRef = %xcut2,0 [*-val2] — Second value.
                                                                                                                                • speed :: ControlRef = %xcut-speed,14s [*-speed] — Speed.

                                                                                                                                pitch

                                                                                                                                Module: china.zheng (1 calls)

                                                                                                                                tr -- tr
                                                                                                                                generator
                                                                                                                                tr^ -- tr
                                                                                                                                tr_ -- tr
                                                                                                                                A trill with smooth transitions.
                                                                                                                                • pitch :: Pitch [*-pitch] — Base pitch.
                                                                                                                                • neighbor :: ControlRef = %tr-neighbor,1nn [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                                • speed :: ControlRef = %tr-speed,20s [*-speed] — Alternate pitches at this speed.
                                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                Module: europe (3 calls)

                                                                                                                                `mordent` -- mordent
                                                                                                                                generator
                                                                                                                                Like g, but hardcoded to play pitch, neighbor, pitch.
                                                                                                                                Tags: ornament
                                                                                                                                • pitch :: Pitch [*-pitch] — Base pitch.
                                                                                                                                • neighbor :: Num (Transposition, default diatonic) = 1d [*-neighbor] — Neighbor pitch.
                                                                                                                                • durenv :: Num (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
                                                                                                                                `rmordent` -- mordent
                                                                                                                                generator
                                                                                                                                Like g, but hardcoded to play pitch, neighbor, pitch.
                                                                                                                                Tags: ornament
                                                                                                                                • pitch :: Pitch [*-pitch] — Base pitch.
                                                                                                                                • neighbor :: Num (Transposition, default diatonic) = -1d [*-neighbor] — Neighbor pitch.
                                                                                                                                • durenv :: Num (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
                                                                                                                                g -- grace
                                                                                                                                generator
                                                                                                                                Generate grace note pitches. They start on the event and have the given duration, but are shortened if the available duration is too short. The destination pitch is first, even though it plays last, so g (c) (a) (b) produces a b c.
                                                                                                                                Tags: ornament
                                                                                                                                • pitch :: Pitch [*-pitch] — Base pitch.
                                                                                                                                • pitch* :: Pitch or Num [] — Grace note pitches. If they are numbers, they are taken as transpositions and must all be the same type, defaulting to diatonic.
                                                                                                                                • durenv :: Num (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
                                                                                                                                Module: india.gamakam (4 calls)

                                                                                                                                dip -- dip
                                                                                                                                generator
                                                                                                                                Alternate two intervals, dropping dyn on the second. This is useful when avoiding a swaram, since it doesn't necessarily emit the base pitch.
                                                                                                                                • pitch :: Pitch [*-pitch] — Base pitch.
                                                                                                                                • high :: Num (Transposition, default diatonic) = 1d [*-high] — High interval.
                                                                                                                                • low :: Num = -1 [*-low] — Low interval.
                                                                                                                                • speed :: ControlRef = %tr-speed,6s [*-speed] — Alternate pitches at this speed.
                                                                                                                                • dyn :: Num = .5 [*-dyn] — Multiply dyn by this amount.
                                                                                                                                • transitionenv :: Num (RealTime) = .08s [transition, *-transition] — Time for each slide.
                                                                                                                                jaru -- jaru
                                                                                                                                generator
                                                                                                                                This is a series of grace notes whose pitches are relative to the given base pitch.
                                                                                                                                • pitch :: Pitch [*-pitch] — Base pitch.
                                                                                                                                • interval+ :: Num (Transposition, default diatonic) [] — Intervals from base pitch.
                                                                                                                                • timeenv :: Num (RealTime) = .15s [time, *-time] — Time for each note.
                                                                                                                                • transitionenv :: Maybe Num (RealTime) = Nothing [transition, *-transition] — Time for each slide, defaults to time.
                                                                                                                                kam -- kam
                                                                                                                                generator
                                                                                                                                kam_ -- kam
                                                                                                                                kam^ -- kam
                                                                                                                                _kam -- kam
                                                                                                                                _kam_ -- kam
                                                                                                                                _kam^ -- kam
                                                                                                                                ^kam -- kam
                                                                                                                                ^kam_ -- kam
                                                                                                                                ^kam^ -- kam
                                                                                                                                This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
                                                                                                                                • pitch :: Pitch [*-pitch] — Base pitch.
                                                                                                                                • neighbor :: ControlRef = %tr-neighbor,1nn [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                                • speed :: ControlRef = %tr-speed,6s [*-speed] — Alternate pitches at this speed.
                                                                                                                                • transition :: Num (RealTime) = .08s [transition, *-transition] — Time for each slide.
                                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                • liltenv :: Num = 0 [lilt, *-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                sgr -- jaru
                                                                                                                                generator
                                                                                                                                This is jaru hardcoded to [-1, 1].
                                                                                                                                • pitch :: Pitch [*-pitch] — Base pitch.
                                                                                                                                • time :: Num (RealTime) = .15s [*-time] — Time for each note.
                                                                                                                                • transition :: Maybe Num (RealTime) = Nothing [*-transition] — Time for each slide, defaults to time.
                                                                                                                                Module: india.gamakam2 (13 calls)

                                                                                                                                cur -- from
                                                                                                                                generator
                                                                                                                                cur< -- from
                                                                                                                                Come from a pitch, and possibly fade in.
                                                                                                                                • from :: Maybe Pitch or Num (Transposition) = Nothing [*-from] — Come from this pitch, or the previous one.
                                                                                                                                • transition :: Num (Time, default real) = .12s [*-transition] — Time to destination.
                                                                                                                                • to :: Maybe Pitch or Num (Transposition) = Nothing [*-to] — Go to this pitch, or the current one.
                                                                                                                                • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                fade-in -- fade
                                                                                                                                generator
                                                                                                                                Fade in. This will overlap with the pitch part of the next call.
                                                                                                                                • time :: Num (Time, default real) = .15s [*-time] — Time to fade.
                                                                                                                                fade-out -- fade
                                                                                                                                generator
                                                                                                                                Fade out. This will overlap with the pitch part of the previous call.
                                                                                                                                • time :: Num (Time, default real) = .15s [*-time] — Time to fade.
                                                                                                                                flat -- flat
                                                                                                                                generator
                                                                                                                                Emit a flat pitch.
                                                                                                                                • pitch :: Maybe Pitch or Num (Transposition) = Nothing [*-pitch] — Emit this pitch, or continue the previous pitch if not given.
                                                                                                                                flat-start -- flat-start
                                                                                                                                generator
                                                                                                                                flat-end -- flat-end
                                                                                                                                Emit a flat pitch for the given duration.
                                                                                                                                • pitch :: Maybe Pitch or Num (Transposition) = Nothing [*-pitch] — Emit this pitch, or continue the previous pitch if not given.
                                                                                                                                • time :: Num (Time, default real) = .15s [*-time] — Pitch lasts for this duration.
                                                                                                                                jaru -- jaru
                                                                                                                                generator
                                                                                                                                jaru0 -- jaru
                                                                                                                                This is a series of grace notes whose pitches are relative to the base pitch. The 0 variant appends a 0 on the end.
                                                                                                                                • interval+ :: Num (Transposition, default diatonic) [] — Intervals from base pitch.
                                                                                                                                • timeenv :: Num (Time, default real) = .12s [time, *-time] — Time for each note.
                                                                                                                                • transitionenv :: Maybe Num (RealTime) = Nothing [transition, *-transition] — Time for each slide, defaults to time.
                                                                                                                                • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                kam -- kam
                                                                                                                                generator
                                                                                                                                kam_ -- kam
                                                                                                                                kam^ -- kam
                                                                                                                                This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
                                                                                                                                • neighbor :: ControlRef = %kam-neighbor,1nn [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                                • speed :: ControlRef = %kam-speed,6s [*-speed] — Alternate pitches at this speed.
                                                                                                                                • transition :: Num (RealTime) = .12s [transition, *-transition] — Time for each slide.
                                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                • liltenv :: Num = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                kam2 -- kam
                                                                                                                                generator
                                                                                                                                kam2_ -- kam
                                                                                                                                kam2^ -- kam
                                                                                                                                This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
                                                                                                                                • pitch1 :: ControlRef = %kam-pitch1,0nn [*-pitch1] — First interval.
                                                                                                                                • pitch2 :: ControlRef = %kam-pitch2,1nn [*-pitch2] — Second interval.
                                                                                                                                • speed :: ControlRef = %kam-speed,6s [*-speed] — Alternate pitches at this speed.
                                                                                                                                • transition :: Num (RealTime) = .12s [transition, *-transition] — Time for each slide.
                                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                • liltenv :: Num = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                nkam -- nkam
                                                                                                                                generator
                                                                                                                                nkam_ -- nkam
                                                                                                                                nkam^ -- nkam
                                                                                                                                kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
                                                                                                                                • cycles :: Num (>0) = 1 [*-cycles] — Number of cycles.
                                                                                                                                • neighbor :: ControlRef = %kam-neighbor,1nn [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                                • transition :: Num (RealTime) = .12s [transition, *-transition] — Time for each slide.
                                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                • liltenv :: Num = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                nkam2 -- nkam
                                                                                                                                generator
                                                                                                                                nkam2_ -- nkam
                                                                                                                                nkam2^ -- nkam
                                                                                                                                kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
                                                                                                                                • cycles :: Num (>0) = 1 [*-cycles] — Number of cycles.
                                                                                                                                • pitch1 :: ControlRef = %kam-pitch1,0nn [*-pitch1] — First interval.
                                                                                                                                • pitch2 :: ControlRef = %kam-pitch2,1nn [*-pitch2] — Second interval.
                                                                                                                                • transition :: Num (RealTime) = .12s [transition, *-transition] — Time for each slide.
                                                                                                                                • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                • liltenv :: Num = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                                • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                prev -- from
                                                                                                                                generator
                                                                                                                                prev< -- from
                                                                                                                                Come for the previous pitch, and possibly fade in.
                                                                                                                                • transition :: Num (Time, default real) = .12s [*-transition] — Time to destination.
                                                                                                                                • to :: Maybe Pitch or Num (Transposition) = Nothing [*-to] — Go to this pitch, or the current one.
                                                                                                                                • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                set-pitch -- set-pitch
                                                                                                                                generator
                                                                                                                                Emit the current pitch. Sequence pitch calls normally use the previous pitch, and this is an implicit begin call so a sequence missing a begin doesn't inherit the previous pitch.
                                                                                                                                  to -- to
                                                                                                                                  generator
                                                                                                                                  to> -- to
                                                                                                                                  Go to a pitch, and possibly fade out.
                                                                                                                                  • pitch :: Pitch or Num (Transposition) [*-pitch] — Go to this pitch or interval.
                                                                                                                                  • transition :: Num (Time, default real) = .12s [*-transition] — Time to destination pitch.
                                                                                                                                  Module: india.gamakam2.begin (5 calls)

                                                                                                                                  - -- flat-start
                                                                                                                                  generator
                                                                                                                                  Emit a flat pitch for the given duration.
                                                                                                                                  • pitch :: Maybe Pitch or Num (Transposition) = Nothing [*-pitch] — Emit this pitch, or continue the previous pitch if not given.
                                                                                                                                  • time :: Num (Time, default real) = .15s [*-time] — Pitch lasts for this duration.
                                                                                                                                  -< -- fade
                                                                                                                                  generator
                                                                                                                                  Fade in. This will overlap with the pitch part of the next call.
                                                                                                                                  • time :: Num (Time, default real) = .15s [*-time] — Time to fade.
                                                                                                                                  c -- from
                                                                                                                                  generator
                                                                                                                                  c< -- from
                                                                                                                                  Come from a pitch, and possibly fade in.
                                                                                                                                  • from :: Maybe Pitch or Num (Transposition) = Nothing [*-from] — Come from this pitch, or the previous one.
                                                                                                                                  • transition :: Num (Time, default real) = .12s [*-transition] — Time to destination.
                                                                                                                                  • to :: Maybe Pitch or Num (Transposition) = Nothing [*-to] — Go to this pitch, or the current one.
                                                                                                                                  • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                  J -- jaru
                                                                                                                                  generator
                                                                                                                                  j -- jaru
                                                                                                                                  This is a series of grace notes whose pitches are relative to the base pitch. The 0 variant appends a 0 on the end.
                                                                                                                                  • interval+ :: Num (Transposition, default diatonic) [] — Intervals from base pitch.
                                                                                                                                  • timeenv :: Num (Time, default real) = .12s [time, *-time] — Time for each note.
                                                                                                                                  • transitionenv :: Maybe Num (RealTime) = Nothing [transition, *-transition] — Time for each slide, defaults to time.
                                                                                                                                  • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                  p -- from
                                                                                                                                  generator
                                                                                                                                  p< -- from
                                                                                                                                  Come for the previous pitch, and possibly fade in.
                                                                                                                                  • transition :: Num (Time, default real) = .12s [*-transition] — Time to destination.
                                                                                                                                  • to :: Maybe Pitch or Num (Transposition) = Nothing [*-to] — Go to this pitch, or the current one.
                                                                                                                                  • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                  Module: india.gamakam2.end (3 calls)

                                                                                                                                  - -- flat-end
                                                                                                                                  generator
                                                                                                                                  Emit a flat pitch for the given duration.
                                                                                                                                  • pitch :: Maybe Pitch or Num (Transposition) = Nothing [*-pitch] — Emit this pitch, or continue the previous pitch if not given.
                                                                                                                                  • time :: Num (Time, default real) = .15s [*-time] — Pitch lasts for this duration.
                                                                                                                                  -> -- fade
                                                                                                                                  generator
                                                                                                                                  Fade out. This will overlap with the pitch part of the previous call.
                                                                                                                                  • time :: Num (Time, default real) = .15s [*-time] — Time to fade.
                                                                                                                                  t -- to
                                                                                                                                  generator
                                                                                                                                  t> -- to
                                                                                                                                  Go to a pitch, and possibly fade out.
                                                                                                                                  • pitch :: Pitch or Num (Transposition) [*-pitch] — Go to this pitch or interval.
                                                                                                                                  • transition :: Num (Time, default real) = .12s [*-transition] — Time to destination pitch.
                                                                                                                                  Module: india.gamakam2.middle (7 calls)

                                                                                                                                  - -- flat
                                                                                                                                  generator
                                                                                                                                  Emit a flat pitch.
                                                                                                                                  • pitch :: Maybe Pitch or Num (Transposition) = Nothing [*-pitch] — Emit this pitch, or continue the previous pitch if not given.
                                                                                                                                  k -- kam
                                                                                                                                  generator
                                                                                                                                  k_ -- kam
                                                                                                                                  k^ -- kam
                                                                                                                                  This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
                                                                                                                                  • neighbor :: ControlRef = %kam-neighbor,1nn [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                                  • speed :: ControlRef = %kam-speed,6s [*-speed] — Alternate pitches at this speed.
                                                                                                                                  • transition :: Num (RealTime) = .12s [transition, *-transition] — Time for each slide.
                                                                                                                                  • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                  • liltenv :: Num = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                                  • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                  • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                  k2 -- kam
                                                                                                                                  generator
                                                                                                                                  k2_ -- kam
                                                                                                                                  k2^ -- kam
                                                                                                                                  This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
                                                                                                                                  • pitch1 :: ControlRef = %kam-pitch1,0nn [*-pitch1] — First interval.
                                                                                                                                  • pitch2 :: ControlRef = %kam-pitch2,1nn [*-pitch2] — Second interval.
                                                                                                                                  • speed :: ControlRef = %kam-speed,6s [*-speed] — Alternate pitches at this speed.
                                                                                                                                  • transition :: Num (RealTime) = .12s [transition, *-transition] — Time for each slide.
                                                                                                                                  • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                  • liltenv :: Num = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                                  • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                  • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                  nk -- nkam
                                                                                                                                  generator
                                                                                                                                  nk_ -- nkam
                                                                                                                                  nk^ -- nkam
                                                                                                                                  kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
                                                                                                                                  • cycles :: Num (>0) = 1 [*-cycles] — Number of cycles.
                                                                                                                                  • neighbor :: ControlRef = %kam-neighbor,1nn [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                                  • transition :: Num (RealTime) = .12s [transition, *-transition] — Time for each slide.
                                                                                                                                  • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                  • liltenv :: Num = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                                  • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                  • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                  nk2 -- nkam
                                                                                                                                  generator
                                                                                                                                  nk2_ -- nkam
                                                                                                                                  nk2^ -- nkam
                                                                                                                                  kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
                                                                                                                                  • cycles :: Num (>0) = 1 [*-cycles] — Number of cycles.
                                                                                                                                  • pitch1 :: ControlRef = %kam-pitch1,0nn [*-pitch1] — First interval.
                                                                                                                                  • pitch2 :: ControlRef = %kam-pitch2,1nn [*-pitch2] — Second interval.
                                                                                                                                  • transition :: Num (RealTime) = .12s [transition, *-transition] — Time for each slide.
                                                                                                                                  • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                  • liltenv :: Num = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                                  • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                  • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                  no^ -- nkam
                                                                                                                                  generator
                                                                                                                                  no_ -- nkam
                                                                                                                                  no* -- nkam
                                                                                                                                  kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
                                                                                                                                  These are hardcoded k variants:
                                                                                                                                  o^ touches the swaram from above, like k2^ 1 0.
                                                                                                                                  o_ touches the swaram from below, like k2_ -1 0.
                                                                                                                                  o* avoids the swaram, like k2_ -1 1.
                                                                                                                                  • cycles :: Num (>0) = 1 [*-cycles] — Number of cycles.
                                                                                                                                  • transition :: Num (RealTime) = .12s [transition, *-transition] — Time for each slide.
                                                                                                                                  • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                  • liltenv :: Num = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                                  • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                  • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                  o^ -- kam
                                                                                                                                  generator
                                                                                                                                  o_ -- kam
                                                                                                                                  o* -- kam
                                                                                                                                  This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
                                                                                                                                  These are hardcoded k variants:
                                                                                                                                  o^ touches the swaram from above, like k2^ 1 0.
                                                                                                                                  o_ touches the swaram from below, like k2_ -1 0.
                                                                                                                                  o* avoids the swaram, like k2_ -1 1.
                                                                                                                                  • speed :: ControlRef = %kam-speed,6s [*-speed] — Alternate pitches at this speed.
                                                                                                                                  • transition :: Num (RealTime) = .12s [transition, *-transition] — Time for each slide.
                                                                                                                                  • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                  • liltenv :: Num = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
                                                                                                                                  • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                  • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                  Module: prelude (42 calls)

                                                                                                                                  ' -- set-prev
                                                                                                                                  generator
                                                                                                                                  Re-set the previous pitch. This can be used to extend a breakpoint.
                                                                                                                                  Tags: prev
                                                                                                                                    * -- multiply
                                                                                                                                    generator
                                                                                                                                    Emit the given pitch multiplied by a factor.
                                                                                                                                    • pitch :: Pitch [*-pitch] — Source pitch.
                                                                                                                                    • interval :: Num or Str = 0 [*-interval] — Multiply this interval with the note's frequency. Negative numbers divide, so while 3/2 goes up a fifth, -3/2 goes down a fifth. Can be either a ratio or a symbol drawn from: M2, M2-, M3, M6, M7, P4, P5, m2, m2-, m3, m6, m7, tt, tt11, tt7+, tt7-, wolf
                                                                                                                                    = -- equal
                                                                                                                                    transformer
                                                                                                                                    Evaluate the deriver with a value set. Special parser support means this can be called infix. The arguments can take many forms to set different kinds of values.
                                                                                                                                    Set an environ value by setting a plain symbol or unset it by assigning to _: x = 42 or x = _.
                                                                                                                                    Alias instrument names like: >alias = >inst.
                                                                                                                                    If the lhs is prefixed with >>, ^, *, ., or -, it will add a new name for a ^note, *pitch, .control, or -val call, respectively. It sets the generator by default, but will set the transformer if you prefix another -. >> is special cased to only create a note transformer, whose name will be prefixed with >. This is used to set an instrument transformer, which can apply a transformer when an instrument is set by the title of a note track, as implemented by by note-track.
                                                                                                                                    E.g.: set note generator: ^phrase = some-block, note transformer: ^-mute = +mute+loose, control transfomrer: .-i = t, val call: -4c = (5c).
                                                                                                                                    You can bypass all this cryptic prefix garbage by using a ky file. It has more space available so it can use a more readable syntax.
                                                                                                                                    If you bind a call to a quoted expression, this creates a new call: ^abc = "(a b c) will create a abc call, which is a macro for a b c. The created call does not take arguments.
                                                                                                                                    Set constant signals by assigning to a signal literal: %c = .5 or pitch: #p = (4c). # = (4c) sets the default pitch signal. You can rename a signal via %a = %b or #x = #y. Control signal assignment also supports the same merge functions as the control track: %a = .5 add or %a = %b add. However, the second example throws an error if %b is a ControlFunction. %a = .5 default will combine with a's default merge function. Assigning to _ unsets the control, and any ControlFunction.
                                                                                                                                    The = operator can be suffixed with symbol, which will become the last argument, so %x=+1 becomes %x = 1 '+'. Note that the order is backwards from the usual +=, which is ultimately because the first word can have almost any character except space and =. Also, x=-1 is ambiguous, and parsed as x =- 1.
                                                                                                                                    Tags: subs
                                                                                                                                    • lhs :: Str [*-lhs] — Assign to this. This looks like a Str, but can actualy contain any characters except =, due to the special infix parsing for =. Symbolic prefixes determine what is assigned, and the valid types for the rhs.
                                                                                                                                    • rhs :: Val [*-rhs] — Source of the assignment.
                                                                                                                                    • merge :: Str = set [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from Derive.Deriver.Monad.mergers: add, interleave, max, min, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
                                                                                                                                    a -- approach
                                                                                                                                    generator
                                                                                                                                    Slide to the next pitch.
                                                                                                                                    Tags: next
                                                                                                                                    • time :: Num (Time, default real) = .2s [*-time] — Time to get to destination.
                                                                                                                                    • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                    ad -- approach-dyn
                                                                                                                                    generator
                                                                                                                                    Like approach, slide to the next pitch, but also drop the dyn.
                                                                                                                                    Tags: cmod, next
                                                                                                                                    • time :: Num (Time, default real) = .2s [*-time] — Time to get to destination pitch and dyn.
                                                                                                                                    • dyn :: Num = .25 [*-dyn] — Drop dyn by this factor.
                                                                                                                                    • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                    alt -- alternate
                                                                                                                                    generator
                                                                                                                                    Pick one of several expressions and evaluate it.
                                                                                                                                    Tags: random
                                                                                                                                    • expr+ :: Quoted [] — Expression to evaluate.
                                                                                                                                    alt-w -- alternate-weighted
                                                                                                                                    generator
                                                                                                                                    Pick one of several expressions and evaluate it.
                                                                                                                                    Tags: random
                                                                                                                                    • expr+ :: (Num, Quoted) [] — (weight, expr) pairs.
                                                                                                                                    d -- down
                                                                                                                                    generator
                                                                                                                                    Descend at the given speed until the next event.
                                                                                                                                    Tags: prev
                                                                                                                                    • slope :: Num (Transposition) = 1c [*-slope] — Descend this many steps per second.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                    default-merge -- default-merge
                                                                                                                                    transformer
                                                                                                                                    Set the default merge operators for controls. These apply when the control track doesn't have an explicit operator.
                                                                                                                                    • merge :: Str [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from Derive.Deriver.Monad.mergers: add, interleave, max, min, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
                                                                                                                                    • control+ :: Control ([a-z][a-z0-9.-]*) [] — Control names.
                                                                                                                                    drop -- drop
                                                                                                                                    generator
                                                                                                                                    Drop pitch and dyn.
                                                                                                                                    Tags: cmod
                                                                                                                                    • interval :: Num (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
                                                                                                                                    • time :: Num (Time, default real) = .25s [*-time] — Time to the destination pitch.
                                                                                                                                    • fade :: Maybe Num (Time, default real) = Nothing [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
                                                                                                                                    • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                    e -- exp
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • exp :: Num = 2 [*-exp] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    e<< -- exp-prev-const
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
                                                                                                                                    • exp :: Num = 2 [*-exp] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    e> -- exp-next
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • exp :: Num = 2 [*-exp] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    e>> -- exp-next-const
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination.
                                                                                                                                    • exp :: Num = 2 [*-exp] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    h -- hold
                                                                                                                                    transformer
                                                                                                                                    Set the Derive.EnvKey.hold environ variable.
                                                                                                                                    • time :: Num (Time, default real) = .25s [*-time] — Hold this long.
                                                                                                                                    i -- linear
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    i<< -- linear-prev-const
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    i> -- linear-next
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    i>> -- linear-next-const
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    if-c< -- if-c<
                                                                                                                                    generator
                                                                                                                                    if-c> -- if-c<
                                                                                                                                    Derive based on the value of a control.
                                                                                                                                    • control :: Control ([a-z][a-z0-9.-]*) [*-control] — Test this control.
                                                                                                                                    • tests+ :: Val [] — (value, expr) pairs.
                                                                                                                                    if-e -- if-e
                                                                                                                                    generator
                                                                                                                                    Derive based on the value of an environment variable.
                                                                                                                                    • name :: Str [*-name] — Environ key.
                                                                                                                                    • value :: Maybe Val = Nothing [*-value] — Environ value. If not given, require only that the environ key is set.
                                                                                                                                    • true :: Quoted [*-true] — Eval if true.
                                                                                                                                    • false :: Quoted [*-false] — Eval if false.
                                                                                                                                    import -- import
                                                                                                                                    transformer
                                                                                                                                    Import the given modules into scope. Calls of all types (note, control, pitch, val) are imported. If names clash, the ones from later modules win.
                                                                                                                                    • module+ :: Str [] — Import these modules.
                                                                                                                                    imports -- import-symbol
                                                                                                                                    transformer
                                                                                                                                    Import a single symbol, or list of symbols.
                                                                                                                                    • module :: Str [*-module] — Import this module.
                                                                                                                                    • symbol+ :: Str [] — Import these symbols.
                                                                                                                                    lift -- lift
                                                                                                                                    generator
                                                                                                                                    Lift pitch and drop dyn. This is the same as drop, except that it defaults to going up instead of down.
                                                                                                                                    Tags: cmod
                                                                                                                                    • interval :: Num (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
                                                                                                                                    • time :: Num (Time, default real) = .25s [*-time] — Time to the destination pitch.
                                                                                                                                    • fade :: Maybe Num (Time, default real) = Nothing [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
                                                                                                                                    • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                    n -- neighbor
                                                                                                                                    generator
                                                                                                                                    Emit a slide from a neighboring pitch to the given one.
                                                                                                                                    • pitch :: Pitch [*-pitch] — Destination pitch.
                                                                                                                                    • neighbor :: Num (Transposition) = 1c [*-neighbor] — Neighobr interval.
                                                                                                                                    • time :: Num (Time, default real) = .1s [*-time] — Time to get to destination.
                                                                                                                                    • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                    omit -- omit
                                                                                                                                    transformer
                                                                                                                                    Omit the derived call a certain percentage of the time.
                                                                                                                                    Tags: random
                                                                                                                                    • chance :: ControlRef = %omit,.5 [*-chance] — Chance, from 0 to 1, that the transformed note will be omitted.
                                                                                                                                    p -- porta
                                                                                                                                    generator
                                                                                                                                    Interpolate between two pitches. This is similar to i>>, but intended to be higher level, in that instruments or scores can override it to represent an idiomatic portamento.
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination.
                                                                                                                                    • place :: Num (0 <= x <= 1) = .5 [place, *-place] — Placement, from before to after the call.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                    s -- sigmoid
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • w1 :: Num = .5 [*-w1] — Start weight.
                                                                                                                                    • w2 :: Num = .5 [*-w2] — End weight.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    s<< -- sigmoid-prev-const
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
                                                                                                                                    • w1 :: Num = .5 [*-w1] — Start weight.
                                                                                                                                    • w2 :: Num = .5 [*-w2] — End weight.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    s> -- sigmoid-next
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • w1 :: Num = .5 [*-w1] — Start weight.
                                                                                                                                    • w2 :: Num = .5 [*-w2] — End weight.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    s>> -- sigmoid-next-const
                                                                                                                                    generator
                                                                                                                                    Interpolate from the previous value to the given one.
                                                                                                                                    Tags: prev
                                                                                                                                    • pitch :: Pitch or Num (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
                                                                                                                                    • time :: Num (Time, default real) = .1s [*-time] — Time to reach destination.
                                                                                                                                    • w1 :: Num = .5 [*-w1] — Start weight.
                                                                                                                                    • w2 :: Num = .5 [*-w2] — End weight.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    set -- set
                                                                                                                                    generator
                                                                                                                                    Emit a pitch with no interpolation.
                                                                                                                                    • pitch :: Num (NN) or Pitch [*-pitch] — Set this pitch.
                                                                                                                                    set -- set
                                                                                                                                    transformer
                                                                                                                                    Prepend a pitch to a signal. This is useful to create a discontinuity, e.g. interpolate to a pitch and then jump to another one.
                                                                                                                                    • pitch :: Num (NN) or Pitch [*-pitch] — Set this pitch.
                                                                                                                                    sh -- sh
                                                                                                                                    transformer
                                                                                                                                    Sample & hold. Hold values at the given speed.
                                                                                                                                    • speed :: ControlRef = %speed,10s [*-speed] — Repeat at this speed. If it's a RealTime, the value is the number of repeats per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of repeats per ScoreTime unit, and will stretch along with tempo changes.
                                                                                                                                    tr -- tr
                                                                                                                                    generator
                                                                                                                                    Generate a pitch signal of alternating pitches.
                                                                                                                                    • note :: Pitch [*-note] — Base pitch.
                                                                                                                                    • neighbor :: ControlRef = %tr-neighbor,1d [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                                    • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                                    • tr-transitionenv :: ControlRef = %tr-transition,0 [tr-transition] — Alternate with a pitch at this interval.
                                                                                                                                    • tr-startenv :: Maybe Str (high low) = Nothing [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
                                                                                                                                    • tr-endenv :: Maybe Str (high low) = Nothing [tr-end] — Which note the trill ends with. If not given, it can end with either.
                                                                                                                                    • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                    • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                    tr-^ -- tr
                                                                                                                                    generator
                                                                                                                                    tr-_ -- tr
                                                                                                                                    Generate a pitch signal of alternating pitches.
                                                                                                                                    A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
                                                                                                                                    • note :: Pitch [*-note] — Base pitch.
                                                                                                                                    • neighbor :: ControlRef = %tr-neighbor,1d [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                                    • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                                    • tr-transitionenv :: ControlRef = %tr-transition,0 [tr-transition] — Alternate with a pitch at this interval.
                                                                                                                                    • tr-startenv :: Maybe Str (high low) = Nothing [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
                                                                                                                                    • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                    • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                    tr^ -- tr
                                                                                                                                    generator
                                                                                                                                    tr_ -- tr
                                                                                                                                    Generate a pitch signal of alternating pitches.
                                                                                                                                    A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
                                                                                                                                    • note :: Pitch [*-note] — Base pitch.
                                                                                                                                    • neighbor :: ControlRef = %tr-neighbor,1d [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                                    • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                                    • tr-transitionenv :: ControlRef = %tr-transition,0 [tr-transition] — Alternate with a pitch at this interval.
                                                                                                                                    • tr-endenv :: Maybe Str (high low) = Nothing [tr-end] — Which note the trill ends with. If not given, it can end with either.
                                                                                                                                    • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                    • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                    tr^^ -- tr
                                                                                                                                    generator
                                                                                                                                    tr^_ -- tr
                                                                                                                                    tr_^ -- tr
                                                                                                                                    tr__ -- tr
                                                                                                                                    Generate a pitch signal of alternating pitches.
                                                                                                                                    A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
                                                                                                                                    • note :: Pitch [*-note] — Base pitch.
                                                                                                                                    • neighbor :: ControlRef = %tr-neighbor,1d [*-neighbor] — Alternate with a pitch at this interval.
                                                                                                                                    • speed :: ControlRef = %tr-speed,14s [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
                                                                                                                                    • tr-transitionenv :: ControlRef = %tr-transition,0 [tr-transition] — Alternate with a pitch at this interval.
                                                                                                                                    • holdenv :: Num (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
                                                                                                                                    • adjustenv :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
                                                                                                                                    u -- up
                                                                                                                                    generator
                                                                                                                                    Ascend at the given speed until the next event.
                                                                                                                                    Tags: prev
                                                                                                                                    • slope :: Num (Transposition) = 1c [*-slope] — Ascend this many steps per second.
                                                                                                                                    • fromenv :: Maybe Pitch = Nothing [from, *-from] — Start from this pitch. If unset, use the previous pitch.
                                                                                                                                    • curveenv :: ControlFunction = ((ControlFunction cf-linear)) [curve, *-curve] — Curve function.
                                                                                                                                    when-c -- when-c
                                                                                                                                    transformer
                                                                                                                                    unless-c -- when-c
                                                                                                                                    Only derive if the control has the given value. E.g., you can use a %var control to select among different variations.
                                                                                                                                    • val :: Num (integral) [*-val] — Value.
                                                                                                                                    • control :: ControlRef = %var,0 [*-control] — Control.
                                                                                                                                    when-e -- when-e
                                                                                                                                    transformer
                                                                                                                                    unless-e -- when-e
                                                                                                                                    Only derive if environ value is set to the given value. In a block derived multiple times by different instruments, this can be used to solo a bit of score to one particular instrument.
                                                                                                                                    • name :: Str [*-name] — Environ key.
                                                                                                                                    • value :: Maybe Val = Nothing [*-value] — Environ value. If not given, require only that the environ key is set.
                                                                                                                                    xcut -- xcut
                                                                                                                                    generator
                                                                                                                                    xcut-h -- xcut
                                                                                                                                    Cross-cut between two pitches. The -h variant holds the value at the beginning of each transition.
                                                                                                                                    • val1 :: PControlRef = #xcut1 [*-val1] — First pitch.
                                                                                                                                    • val2 :: PControlRef = #xcut2 [*-val2] — Second pitch.
                                                                                                                                    • speed :: ControlRef = %xcut-speed,14s [*-speed] — Speed.

                                                                                                                                    val

                                                                                                                                    Module: prelude (29 calls)

                                                                                                                                    ts -- timestep
                                                                                                                                    val
                                                                                                                                    Compute the duration of the given RelativeMark timestep at the current position. This is for durations, so it only works with RelativeMark.
                                                                                                                                    • rank :: Str (section w h q e s t32 t64 t128 t256) [*-rank] — Emit a duration of this rank.
                                                                                                                                    • multiply :: Num = 1 [*-multiply] — Multiply duration.
                                                                                                                                    rt -- realtime
                                                                                                                                    val
                                                                                                                                    Convert a number to RealTime. This just changes the type annotation, the value remains the same.
                                                                                                                                    • val :: Num []
                                                                                                                                    st -- scoretime
                                                                                                                                    val
                                                                                                                                    Convert a number to ScoreTime. This just changes the type annotation, the value remains the same.
                                                                                                                                    • val :: Num []
                                                                                                                                    nn -- nn
                                                                                                                                    val
                                                                                                                                    Convert a pitch, hz, or twelve-tone pitch name to a NoteNumber. A pitch name looks like [a-g]s?[-1-9].
                                                                                                                                    • val :: Pitch or Num or Str [*-val]
                                                                                                                                    hz -- hz
                                                                                                                                    val
                                                                                                                                    Convert a pitch, twelve-tone pitch name, or NoteNumber to hz. A pitch name looks like [a-g]s?[-1-9]. If the octave isn't given, it defaults to 0. This is useful for %just-control, which ignores the octave.
                                                                                                                                    • val :: Pitch or Str or Num [*-val]
                                                                                                                                    # -- pcontrol-ref
                                                                                                                                    val
                                                                                                                                    Create a Derive.BaseTypes.PControlRef. For control literals, the #name syntax suffices, but if you want to give a default pitch, you need this call.
                                                                                                                                    • name :: PControl (#[a-z][a-z0-9.-]*) [*-name] — Name of pitch signal.
                                                                                                                                    • default :: Maybe Pitch = Nothing [*-default] — Default pitch, if the signal is not set.
                                                                                                                                    pitch -- pitch
                                                                                                                                    val
                                                                                                                                    Create a Perform.Pitch.Pitch.
                                                                                                                                    • oct :: Num (integral) or Str or Pitch = 0 [] — Octave, or a pitch name or pitch. If it's a pitch name or pitch, the pc and accs args must be 0.
                                                                                                                                    • pc :: Num (integral) = 0 [] — Pitch class.
                                                                                                                                    • accs :: Num (integral) = 0 [] — Accidentals.
                                                                                                                                    list -- list
                                                                                                                                    val
                                                                                                                                    Create a list.
                                                                                                                                    • val* :: Val [] — Value.
                                                                                                                                    e> -- exp-next
                                                                                                                                    val
                                                                                                                                    Create curved lines between the given breakpoints.
                                                                                                                                    • exp :: Num = 2 [*-exp] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
                                                                                                                                    • bp+ :: Val [] — Breakpoints are distributed evenly between the event start and the next event. They can be all numbers, or all pitches.
                                                                                                                                    i> -- linear-next
                                                                                                                                    val
                                                                                                                                    Create straight lines between the given breakpoints.
                                                                                                                                    • bp+ :: Val [] — Breakpoints are distributed evenly between the event start and the next event. They can be all numbers, or all pitches.
                                                                                                                                    1/ -- reciprocal
                                                                                                                                    val
                                                                                                                                    Find the reciprocal of a number. Useful for tempo, e.g. set the tempo to 1/time.
                                                                                                                                    • num :: Num [*-num]
                                                                                                                                    <-# -- pitch
                                                                                                                                    val
                                                                                                                                    Get the current pitch.
                                                                                                                                    • control :: PControl (#[a-z][a-z0-9.-]*) = # [*-control] — The default pitch if empty, otherwise, get the named pitch.
                                                                                                                                    df -- down-from
                                                                                                                                    val
                                                                                                                                    Go down from a starting value at a certain rate.
                                                                                                                                    • from :: Num = 1 [*-from] — Start at this value.
                                                                                                                                    • speed :: Num = 1 [*-speed] — Descend this amount per second.
                                                                                                                                    e -- env
                                                                                                                                    val
                                                                                                                                    Look up the given val in the environ.
                                                                                                                                    • name :: Str [*-name] — Look up the value of this key.
                                                                                                                                    • default :: Maybe Val = Nothing [*-default] — If given, this is the default value when the key isn't present. If not given, a missing key will throw an exception. The presence of a default will also make the lookup expect the same type as the default.
                                                                                                                                    ts/ -- timestep-reciprocal
                                                                                                                                    val
                                                                                                                                    This is the same as timestep except it returns the reciprocal. This is useful for e.g. trills which take cycles per second rather than duration.
                                                                                                                                    • rank :: Str (section w h q e s t32 t64 t128 t256) [*-rank] — Emit a duration of this rank.
                                                                                                                                    • multiply :: Num = 1 [*-multiply] — Multiply duration.
                                                                                                                                    cf-swing -- cf-swing
                                                                                                                                    val
                                                                                                                                    Add a curved offset to the control, suitable for swing tempo when added to %start-s. The curve is a sine wave, from trough to trough.
                                                                                                                                    Tags: control-function
                                                                                                                                    • rank :: Str (section w h q e s t32 t64 t128 t256) = q [*-rank] — The time steps are on the beat, and midway between offset by the given amount.
                                                                                                                                    • amount :: ControlRef = %swing,.333 [*-amount] — Swing amount, multiplied by the rank duration / 2.
                                                                                                                                    cf-clamp -- cf-clamp
                                                                                                                                    val
                                                                                                                                    Clamp the output of a control function to the given range.
                                                                                                                                    Tags: control-function
                                                                                                                                    • cf :: ControlFunction [*-cf] — Control function.
                                                                                                                                    • low :: Num = 0 [*-low] — Low value.
                                                                                                                                    • high :: Num = 1 [*-high] — High value.
                                                                                                                                    cf-expon -- cf-expon
                                                                                                                                    val
                                                                                                                                    Exponential interpolation function.
                                                                                                                                    Tags: control-function, curve
                                                                                                                                    • expon :: Num = 2 [*-expon] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
                                                                                                                                    cf-linear -- cf-linear
                                                                                                                                    val
                                                                                                                                    Linear interpolation function. It's just id.
                                                                                                                                    Tags: control-function, curve
                                                                                                                                      cf-jump -- cf-jump
                                                                                                                                      val
                                                                                                                                      No interpolation. Jump to the destination at 0.5.
                                                                                                                                      Tags: control-function, curve
                                                                                                                                        cf-sigmoid -- cf-sigmoid
                                                                                                                                        val
                                                                                                                                        Sigmoid interpolation function.
                                                                                                                                        Tags: control-function, curve
                                                                                                                                        • w1 :: Num = .5 [*-w1] — Weight of start.
                                                                                                                                        • w2 :: Num = .5 [*-w2] — Weight of end.
                                                                                                                                        cf-rnd-a -- cf-rnd-a
                                                                                                                                        val
                                                                                                                                        cf-rnd-a+ -- cf-rnd-a
                                                                                                                                        cf-rnd-a* -- cf-rnd-a
                                                                                                                                        Randomize a control around a center point. Normally it replaces the control of the same name, while the + and * variants add to and multiply with it.
                                                                                                                                        Tags: control-function, random
                                                                                                                                        • range :: Num [*-range] — Range this far from the center.
                                                                                                                                        • center :: Num = 0 [*-center] — Center of the range.
                                                                                                                                        • distributionenv :: Str (uniform normal bimodal) = normal [*-distribution] — Random distribution.
                                                                                                                                        cf-rnd -- cf-rnd
                                                                                                                                        val
                                                                                                                                        cf-rnd+ -- cf-rnd
                                                                                                                                        cf-rnd* -- cf-rnd
                                                                                                                                        Randomize a control. Normally it replaces the control of the same name, while the + and * variants add to and multiply with it.
                                                                                                                                        Tags: control-function, random
                                                                                                                                        • low :: Num [*-low] — Low end of the range.
                                                                                                                                        • high :: Num [*-high] — High end of the range.
                                                                                                                                        • distributionenv :: Str (uniform normal bimodal) = normal [*-distribution] — Random distribution.
                                                                                                                                        cf-rnd01 -- cf-rnd01
                                                                                                                                        val
                                                                                                                                        This is an abbreviation for (cf-clamp (cf-rnd+ ..) 0 1).
                                                                                                                                        Tags: control-function, random
                                                                                                                                        • low :: Num [*-low] — Low end of the range.
                                                                                                                                        • high :: Num [*-high] — High end of the range.
                                                                                                                                        • distributionenv :: Str (uniform normal bimodal) = normal [*-distribution] — Random distribution.
                                                                                                                                        > -- next-val
                                                                                                                                        val
                                                                                                                                        Evaluate the next event. Only works on pitch and control tracks, and if the next event doesn't need its previous event.
                                                                                                                                        Tags: next
                                                                                                                                          < -- prev-val
                                                                                                                                          val
                                                                                                                                          Return the previous value. Only works on pitch and control tracks.
                                                                                                                                          Tags: prev
                                                                                                                                            range -- range
                                                                                                                                            val
                                                                                                                                            Pick a random number within a range.
                                                                                                                                            Tags: random
                                                                                                                                            • low :: Num = 0 [*-low] — Bottom of range, inclusive.
                                                                                                                                            • high :: Num = 1 [*-high] — Top of range, inclusive.
                                                                                                                                            alt -- alternate
                                                                                                                                            val
                                                                                                                                            Pick one of the arguments randomly.
                                                                                                                                            Tags: random
                                                                                                                                            • val+ :: Val [] — Value of any type.
                                                                                                                                            alt-w -- alternate-weighted
                                                                                                                                            val
                                                                                                                                            Pick one of the arguments randomly.
                                                                                                                                            Tags: random
                                                                                                                                            • val+ :: (Num, Val) [] — (weight, val) pairs.