h&nd      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Safe-Inferred0 Safe-Inferred0   Safe-Inferred1     Safe-Inferred2QtidalWrapper for literals that can be coerced to a string and used as an identifier. | Similar to Show typeclass, but constrained to strings and integers and designed | so that similar cases (such as 1 and "1") convert to the same value. Safe-Inferred8;;%tidalAn arc of time, with a start time (or onset) and a stop time (or offset))tidalTime is rational*tidalThe * (start of cycle) for the given time value. Cycles have duration 1, so every integer Time value divides two cycles.+tidal:Turns a number into a (rational) time value. An alias for .,tidalTurns a (rational) time value into another number. An alias for .-tidalThe end point of the current cycle (and starting point of the next cycle).tidalThe position of a time value relative to the start of its cycle./tidalconvex hull union0tidal subArc i j- is the timespan that is the intersection of i and j. intersection The definition is a bit fiddly as results might be zero-width, but not at the end of an non-zero-width arc - e.g. (0,1) and (1,2) do not intersect, but (1,1) (1,1) does.2tidalSimple intersection of two arcs3tidal9The Arc returned is the cycle that the Time falls within.Edge case: If the Time is an integer, the Arc claiming it is the one starting at that Time, not the previous one ending at that Time.4tidalShifts an Arc to one of equal duration that starts within cycle zero. (Note that the output Arc probably does not start *at* Time 0 -- that only happens when the input Arc starts at an integral Time.)5tidalReturns the numbers of the cycles that the input Arc overlaps (excluding the input Arc's endpoint, unless it has duration 0 -- see "Edge cases" below). The "cycle number" of an Arc is equal to its start value. Thus, for instance, `cyclesInArc (Arc 0 1.5) == [0,1]`. * Edge cases: `cyclesInArc $ Arc 0 1.0001 == [0,1]` `cyclesInArc $ Arc 0 1 == [0]` -- the endpoint is excluded `cyclesInArc $ Arc 1 1 == [1]` -- unless the Arc has duration 06tidalThe whole cycles that overlap the input Arc, (excluding its endpoint, unless it has duration 0, similarly to 52 -- see that function's description for details).7tidalSplits the given % into a list of %s, at cycle boundaries.8tidal+Like arcCycles, but returns zero-width arcs9tidal Similar to  but time is relative to the cycle (i.e. the sam of the start of the arc):tidalisIn a t is True if t# is inside the arc represented by a.$%('&)*+,-./0123456789:)%('&$*+,-./0123456789: Safe-Inferred68;N[.Dtidal+Note is Double, but with a different parserJtidalPolymorphic values`tidalAn event is a value that's active during a timespan. If a whole is present, the part should be equal to or fit inside it.ftidalSome context for an event, currently just position within sourcecodentidal5A datatype representing events taking place over timeqtidal$an Arc and some named control valuesutidalLike  * , but the wholes come from the leftvtidalLike  * , but the wholes come from the rightwtidalLike  * , but the wholes come from the left}tidalTurns a pattern of patterns into a single pattern. (this is actually join) 1/ For query s(, get the events from the outer pattern pp' 2/ Query the inner pattern using the d of the outer 3/ For each inner event, set the whole and part to be the intersection of the outer whole and part, respectively 47 Concatenate all the events together (discarding wholesparts that didn't intersect)TODO - what if a continuous pattern contains a discrete one, or vice-versa?~tidal8Turns a pattern of patterns into a single pattern. Like unwrap3, but structure only comes from the inner pattern.tidal8Turns a pattern of patterns into a single pattern. Like unwrap3, but structure only comes from the outer pattern.tidalLike unwrap, but cycles of the inner patterns are compressed to fit the timespan of the outer whole (or the original query if it's a continuous pattern?) TODO - what if a continuous pattern contains a discrete one, or vice-versa?tidalPatterns as numberstidalSplits queries that span cycles. For example `query p (0.5, 1.5)` would be turned into two queries, `(0.5,1)` and `(1,1.5)`, and the results combined. Being able to assume queries don't span cycles often makes transformations easier to specify.tidalApply a function to the arcs/timespans (both whole and parts) of the resulttidalApply a function to the time (both start and end of the timespans of both whole and parts) of the resulttidal-Apply a function to the timespan of the querytidal>Apply a function to the time (both start and end) of the querytidal withEvent f p returns a new Pattern' with each event mapped over function f.tidal withEvent f p returns a new Pattern' with each value mapped over function f.tidal withEvent f p returns a new Pattern with f applied to the resulting list of events for each query function f.tidal withPart f p returns a new Pattern with function f applied to the part.tidalExtract a pattern of integer values by from a control pattern, given the name of the controltidalExtract a pattern of floating point values by from a control pattern, given the name of the controltidalExtract a pattern of string values by from a control pattern, given the name of the controltidalExtract a pattern of boolean values by from a control pattern, given the name of the controltidalExtract a pattern of rational values by from a control pattern, given the name of the controltidalShifts a pattern back in time by the given amount, expressed in cyclestidalShifts a pattern forward in time by the given amount, expressed in cyclestidalMark values in the first pattern which match with at least one value in the second pattern.tidal;Remove events from patterns that to not meet the given testtidalTurns a pattern of : values into a pattern of values, dropping the events of .tidal if an `'s starts is within given %tidalReturns a list of events, with any adjacent parts of the same whole combinedtidalReturns = if the two given events are adjacent parts of the same wholetidalGet the onset of an event's ctidalGet the offset of an event's ctidalGet the onset of an event's ctidalGet the offset of an event's dtidalGet the timespan of an event's dtidalGeneral utilities..>Apply one of three functions to a Value, depending on its typetidalApply one of two functions to a pair of Values, depending on their types (int or float; strings and rationals are ignored)tidal>collects all events satisfying the same constraint into a listtidal?collects all events occuring at the exact same time into a listtidalmerges all values in a list into one pattern by stacking the values$%(&')*+,-./0123456789:DEFGHIJ^]\[ZYXWVUSRQPNMKTOL_`bdcaefghijklmnopqtrsuvwxyz{|}~DEFGHIJ^]\[ZYXWVUSRQPNMKTOL_`bdcaefghijklmnopqtrsuvwxyz{|}~u4v4w4 Safe-Inferred%&PZ Safe-InferredP    Safe-InferrediD4tidalAn empty patterntidal:Takes a function from time to values, and turns it into a n.tidalsine - unipolar sinewave. A pattern of continuous values following a sinewave with frequency of one cycle, and amplitude from 0 to 1.tidalsine2 - bipolar sinewave. A pattern of continuous values following a sinewave with frequency of one cycle, and amplitude from -1 to 1.tidalcosine - unipolar cosine wave. A pattern of continuous values following a cosine with frequency of one cycle, and amplitude from 0 to 1. Equivalent to `0.25 ~> sine`.tidalcosine2 - bipolar cosine wave. A pattern of continuous values following a cosine with frequency of one cycle, and amplitude from -1 to 1. Equivalent to `0.25 ~> sine2`.tidalsaw - unipolar ascending sawtooth wave. A pattern of continuous values following a sawtooth with frequency of one cycle, and amplitude from 0 to 1.tidalsaw2 - bipolar ascending sawtooth wave. A pattern of continuous values following a sawtooth with frequency of one cycle, and amplitude from -1 to 1.tidalisaw like saw&, but a descending (inverse) sawtooth.tidalisaw2 like saw2&, but a descending (inverse) sawtooth.tidaltri - unipolar triangle wave. A pattern of continuous values following a triangle wave with frequency of one cycle, and amplitude from 0 to 1.tidaltri2 - bipolar triangle wave. A pattern of continuous values following a triangle wave with frequency of one cycle, and amplitude from -1 to 1.tidalsquare - unipolar square wave. A pattern of continuous values following a square wave with frequency of one cycle, and amplitude from 0 to 1. | square is like , for square waves.tidalsquare2 - bipolar square wave. A pattern of continuous values following a square wave with frequency of one cycle, and amplitude from -1 to 1.tidalenvL is a n of continuous  values, representing a linear interpolation between 0 and 1 during the first cycle, then staying constant at 1 for all following cycles. Possibly only useful if you're using something like the retrig function defined in tidal.el.tidallike  but reversed.tidal'Equal power' version of env, for gain-based transitionstidalEqual power reversedtidalTurns a list of values into a pattern, playing one of them per cycle.tidalTurns a list of values into a pattern, playing all of them per cycle.tidalA synonym for tidal'fromMaybes; is similar to ., but allows values to be optional using the  type, so that ! results in gaps in the pattern.tidalA pattern of whole numbers from 0 to the given number, in a single cycle.tidalFrom 1 for the first cycle, successively adds a number until it gets up to ntidal2Alternate between cycles of the two given patternstidalLike , but for a list of patterns. Interlaces them, playing the first cycle from each in turn, then the second cycle from each, and so on.tidal Alias for tidal Alias for tidalLike , but twice as fasttidal The same as , but speeds up the result by the number of patterns there are, so the cycles from each are squashed to fit a single cycle.tidal Alias for fastCattidal Similar to fastCat/, but each pattern is given a relative durationtidal Alias for timeCattidal combines two ns into a new pattern, so that their events are combined over time. tidal combines a list of ns into a new pattern, so that their events are combined over time.tidalShifts a pattern back in time by the given amount, expressed in cyclestidalShifts a pattern forward in time by the given amount, expressed in cyclestidal,Speed up a pattern by the given time patterntidal>Slow down a pattern by the factors in the given time pattern,  squeezing7 the pattern to fit the slot given in the time patterntidal An alias for fasttidal-Slow down a pattern by the given time patterntidal>Slow down a pattern by the factors in the given time pattern,  squeezing7 the pattern to fit the slot given in the time patterntidal An alias for slowtidalrev p returns p with the event positions in each cycle reversed (or mirrored).tidalPlays a portion of a pattern, specified by a time arc (start and end time). The new resulting pattern is played over the time period of the original pattern: :d1 $ zoom (0.25, 0.75) $ sound "bd*2 hh*3 [sn bd]*2 drum" In the pattern above,  is used with an arc from 25% to 75%. It is equivalent to this pattern: d1 $ sound "hh*3 [sn bd]*2" tidalfastGap is similar to 3 but maintains its cyclic alignment. For example,  fastGap 2 p% would squash the events in pattern p into the first half of each cycle (and the second halves would be empty). The factor should be at least 1tidal An alias for fastGaptidalHigher order functionsFunctions which work on other functions (higher order functions) every n f p applies the function f to p, but only affects every n cycles.tidal every n o f' is like  every n f with an offset of o cyclestidalfoldEvery ns f p applies the function f to p$, and is applied for each cycle in ns.tidalOnly ! the given test function returns  the given pattern transformation is applied. The test function will be called with the current cycle as a number. th "chord" (a chord is a list of Ints) from a list of chords cs and transposes it by m chordate :: Num b => [[b]] -> b -> Int -> [b] chordate cs m n = map (+m) $ cs!!nenchord chords pn pc& turns every note in the note pattern pn/ into a chord, selecting from the chord lists chords using the index pattern pc. For example, 6Chords.enchord [Chords.major Chords.minor] "c g" "0 1" will create a pattern of a C-major chord followed by a G-minor chord. enchord :: Num a => [[a]] -> Pattern a -> Pattern Int -> Pattern a enchord chords pn pc = flatpat $ (chordate chords)  $ pn  * pctidalturns a given pattern of some Num type, a pattern of chord names and a list of patterns of modifiers into a chord pattern>>  Safe-InferredstidalThe midpoint of two valuestidallike  selects n1th element from xs, but wraps over at the end of xs!map ((!!!) [1,3,5]) [0,1,2,3,4,5] [1,3,5,1,3,5]tidalSafer version of !! -tidalenumerate a list of thingsenumerate ["foo","bar","baz"]![(1,"foo"), (2,"bar"), (3,"baz")]tidalsplit given list of a by given single a, e.g.wordsBy (== ':') "bd:3" ["bd", "3"]  Safe-Inferred/s""  Safe-Inferredt Safe-Inferredtidalgroup multiple params into onetidal Param makerstidalGrouped paramstidala pattern of numbers that speed up (or slow down) samples while they play.tidallike gain , but linear.tidaltidala pattern of numbers to specify the attack time (in seconds) of an envelope applied to each sample.tidala pattern of numbers from 0 to 1. Sets the center frequency of the band-pass filter.tidala pattern of anumbers from 0 to 1. Sets the q-factor of the band-pass filter.tidala pattern of numbers from 0 to 1. Skips the beginning of each sample, e.g. `0.25` to cut off the first quarter from each sample.tidalSpectral binshifttidaltidaltidaltidaltidaltidaltidaltidaltidaltidaltidaltidaltidaltidaltidaltidaltidaltidaltidal6choose the channel the pattern is sent to in superdirttidaltidalfake-resampling, a pattern of numbers for lowering the sample rate, i.e. 1 for original 2 for half, 3 for a third and so on.tidal Spectral combtidaltidaltidalbit crushing, a pattern of numbers from 1 (for drastic reduction in bit-depth) to 16 (for barely no reduction).tidaltidaltidal'In the style of classic drum-machines,  will stop a playing sample as soon as another samples with in same cutgroup is to be played. An example would be an open hi-hat followed by a closed one, essentially muting the open.tidala pattern of numbers from 0 to 1. Applies the cutoff frequency of the low-pass filter.tidaltidaltidaltidala pattern of numbers from 0 to 1. Sets the level of the delay signal.tidala pattern of numbers from 0 to 1. Sets the amount of delay feedback.tidal?a pattern of numbers from 0 to 1. Sets the length of the delay.tidaltidalnoisy fuzzy distortiontidalDJ filter, below 0.5 is low pass filter, above is high pass filter.tidal>when set to `1` will disable all reverb for this pattern. See   and  # for more information about reverb.tidaltidal the same as , but cuts the end off samples, shortening them; e.g. `0.75` to cut off the last quarter of each sample.tidalSpectral enhancetidaltidalAs with fadeTime, but controls the fade in time of the grain envelope. Not used if the grain begins at position 0 in the sample.tidalUsed when using begin end or chop8striate and friends, to change the fade out time of the grain envelope.tidaltidaltidalSpectral freezetidaltidalfor internal sound routingtidalfrequency shiftertidalfrequency shiftertidalfrequency shiftertidala pattern of numbers that specify volume. Values less than 1 make the sound quieter. Values greater than 1 make the sound louder. For the linear equivalent, see amp.tidaltidaltidaltidal!High pass sort of spectral filtertidala pattern of numbers from 0 to 1. Applies the cutoff frequency of the high-pass filter. Also has alias hpftidala pattern of numbers to specify the hold time (in seconds) of an envelope applied to each sample. Only takes effect if  and   are also specified.tidaltidala pattern of numbers from 0 to 1. Applies the resonance of the high-pass filter. Has alias hpqtidaltidaltidalshape/bass enhancertidaltidal Low pass sort of spectral filtertidaltidaltidaltidal tidal:controls the amount of overlap between two adjacent sounds tidal tidal tidal tidal tidal tidal tidal tidal tidal tidal tidal tidalA pattern of numbers. Specifies whether delaytime is calculated relative to cps. When set to 1, delaytime is a direct multiple of a cycle. tidalloops the sample (from  to  ) the specified number of times. tidal tidal tidal tidal tidal tidal tidal tidal tidal tidal tidal tidald1 $ slow 2 $ sound "[[[feel:5*8,feel*3] feel:3*8]?, feel*4]" tidal(The above means that  is a function from patterns of any type, to a pattern of the same type.)+Make a pattern sound a bit like a breakbeatExample: d1 $ sound (brak "bd sn kurt") tidalDivides a pattern into a given number of subdivisions, plays the subdivisions in order, but increments the starting subdivision each cycle. The pattern wraps to the first subdivision after the last subdivision is played.Example: "d1 $ iter 4 $ sound "bd hh sn cp" 1This will produce the following over four cycles: 0bd hh sn cp hh sn cp bd sn cp bd hh cp bd hh sn There is also 6`, which shifts the pattern in the opposite direction.tidaliter' is the same as iter, but decrements the starting subdivision instead of incrementing it.tidal palindrome p applies rev to p every other cycle, so that the pattern alternates between forwards and backwards.tidalComposing patterns The function seqP allows you to define when a sound within a list starts and ends. The code below contains three separate patterns in a , but each has different start times (zero cycles, eight cycles, and sixteen cycles, respectively). All patterns stop after 128 cycles: d1 $ seqP [ (0, 128, sound "bd bd*2"), (8, 128, sound "hh*2 [sn cp] cp future*4"), (16, 128, sound (samples "arpy*8" (run 16))) ] tidal'Degrades a pattern over the given time.tidalAlternate version to fadeOut: where you can provide the time from which the fade startstidal Undegrades a pattern over the given time.tidalAlternate version to fadeIn> where you can provide the time from which the fade in startstidalThe  function allows you to take a pattern transformation which takes a parameter, such as , and provide several parameters which are switched between. In other words it spreads" a function across several values.,Taking a simple high hat loop as an example: d1 $ sound "ho ho:2 ho:3 hc"  Bool)`, a function that takes a whole number and returns either  or .tidal wedge t p p' combines patterns p and p' by squashing the p) into the portion of each cycle given by t, and p'" into the remainer of each cycle.tidalwhenmod$ has a similar form and behavior to , but requires an additional number. Applies the function to the pattern, when the remainder of the current loop number divided by the first parameter, is greater or equal than the second parameter.For example the following makes every other block of four loops twice as dense: 2d1 $ whenmod 8 4 (density 2) (sound "bd sn kurt") tidal !superimpose f p = stack [p, f p]  plays a modified version of a pattern at the same time as the original pattern, resulting in two patterns being played at the same time. d1 $ superimpose (density 2) $ sound "bd sn [cp ht] hh" d1 $ superimpose ((# speed "2") . (0.125 <~)) $ sound "bd sn cp hh" tidaltrunc truncates a pattern so that only a fraction of the pattern is played. The following example plays only the first quarter of the pattern:  "x ~ ~ x ~ ~ x ~"euclidInv 3 8 "x" -> "~ x x ~ x x ~ x"tidalrot n p! rotates the values in a pattern p by n beats to the left. Example: 3d1 $ every 4 (rot 2) $ slow 2 $ sound "bd hh hh hh"tidal segment n p:  the pattern p at a rate of n events per cycle. Useful for turning a continuous pattern into a discrete one.tidal discretise : the old (deprecated) name for tidal randcat ps : does a slowcat on the list of patterns ps4 but randomises the order in which they are played.tidalThe  function takes a pattern of integer numbers, which are used to select values from the given list. What makes this a bit strange is that only a given number of values are selected each cycle. For example: d1 $ sound (fit 3 ["bd", "sn", "arpy", "arpy:1", "casio"] "0 [~ 1] 2 1") The above fits three samples into the pattern, i.e. for the first cycle this will be `"bd"`, `"sn"` and `"arpy"`, giving the result `"bd [~ sn] arpy sn"` (note that we start counting at zero, so that `0` picks the first value). The following cycle the *next* three values in the list will be picked, i.e. `"arpy:1"`, `"casio"` and `"bd"`, giving the pattern `"arpy:1 [~ casio] bd casio"` (note that the list wraps round here).tidal struct a b: structures pattern b, in terms of the pattern of boolean values a. Only True) values in the boolean pattern are used.tidal substruct a b : similar to struct, but each event in pattern a gets replaced with pattern b., compressed to fit the timespan of the event.tidal stripe n p: repeats pattern p, n! times per cycle. So similar to fast, but with random durations. The repetitions will be continguous (touching, but not overlapping) and the durations will add up to a single cycle. n+ can be supplied as a pattern of integers.tidalslowstripe n p: The same as stripe, but the result is also n times slower, so that the mean average duration of the stripes is exactly one cycle, and every nth stripe starts on a cycle boundary (in indian classical terms, the sam).tidal returns the nth iteration of a  &https://en.wikipedia.org/wiki/L-systemLindenmayer System with given start sequence. for example: 'lindenmayer 1 "a:b,b:ab" "ab" -> "bab" tidal lindenmayerI> converts the resulting string into a a list of integers with  fromIntegral applied (so they can be used seamlessly where floats or rationals are required) tidalrunMarkov n tmat xi seed0 generates a Markov chain (as a list) of length n using the transition matrix tmat starting from initial state xi., starting with random numbers generated from seed Each entry in the chain is the index of state (starting from zero). Each row of the matrix will be automatically normalized. For example:  runMarkov 8 [[2,3], [1,3]] 0 0  will produce a two-state chain 8 steps long, from initial state 07, where the transition probability from state 0->0 is 2 5, 0->1 is 3"5, 1->0 is 1/4, and 1->1 is 3/4. tidalRemoves events from second pattern that don't start during an event from first.6Consider this, kind of messy rhythm without any rests. ?d1 $ sound (slowcat ["sn*8", "[cp*4 bd*4, hc*5]"]) # n (run 8) If we apply a mask to it d1 $ s (mask ("1 1 1 ~ 1 1 ~ 1" :: Pattern Bool) (slowcat ["sn*8", "[cp*4 bd*4, bass*5]"] )) # n (run 8) Due to the use of  here, the same mask is first applied to `"sn*8"` and in the next cycle to `"[cp*4 bd*4, hc*5]".=You could achieve the same effect by adding rests within the  patterns, but mask allows you to do this more easily. It kind of keeps the rhythmic structure and you can change the used samples independently, e.g. d1 $ s (mask ("1 ~ 1 ~ 1 1 ~ 1") (slowcat ["can*8", "[cp*4 sn*4, jvbass*16]"] )) # n (run 8) tidalTODO: refactor towards uniontidal` is a generalization of , where the list is instead constructed by using another integer pattern to slice up a given pattern. The first argument is the number of cycles of that latter pattern to use when slicing. It's easier to understand this with a few examples: *d1 $ sound (fit' 1 2 "0 1" "1 0" "bd sn") So what does this do? The first `1` just tells it to slice up a single cycle of `"bd sn"`. The `2` tells it to select two values each cycle, just like the first argument to . The next pattern `"0 1"` is the "from" pattern which tells it how to slice, which in this case means `"0"` maps to `"bd"`, and `"1"` maps to `"sn"`. The next pattern `"1 0"` is the "to" pattern, which tells it how to rearrange those slices. So the final result is the pattern `"sn bd"`.-A more useful example might be something like d1 $ fit' 1 4 (run 4) "[0 3*2 2 1 0 3*2 2 [1*8 ~]]/2" $ chop 4 $ (sound "breaks152" # unit "c")  which uses chop8 to break a single sample into individual pieces, which ` then puts into a list (using the `run 4` pattern) and reassembles according to the complicated integer pattern.tidalTreats the given pattern p as having n" chunks, and applies the function f to one of those sections per cycle. Running: - from left to right if chunk number is positive - from right to left if chunk number is negative 5 d1 $ chunk 4 (fast 4) $ sound "cp sn arpy [mt lt]" tidalDEPRECATED, use  with negative numbers insteadtidalDEPRECATED, use  with negative numbers insteadtidaltoScale lets you turn a pattern of notes within a scale (expressed as a list) to note numbers. For example `toScale [0, 4, 7] "0 1 2 3"` will turn into the pattern `"0 4 7 12"`. It assumes your scale fits within an octave; to change this use  size`. Example:  24 [0,4,7,10,14,17] (run 8)` turns into `"0 4 7 10 14 17 24 28"`tidal#`swingBy x n` divides a cycle into n slices and delays the notes in the second half of each slice by x fraction of a slice . swing is an alias for `swingBy (1%3)`tidal is like 9 but only picks a new item from the list once each cycle tidal/Internal function used by shuffle and scramble tidal6`shuffle n p` evenly divides one cycle of the pattern p into n parts, and returns a random permutation of the parts each cycle. For example, `shuffle 3 "a b c"` could return `"a b c"`, `"a c b"`, `"b a c"`, `"b c a"`, `"c a b"`, or `"c b a"`. But it will **never** return `"a a a"`, because that is not a permutation of the parts.tidal`scramble n p` is like ( but randomly selects from the parts of p instead of making permutations. For example, `scramble 3 "a b c"` will randomly select 3 parts from `"a"` `"b"` and `"c"`, possibly repeating a single part.tidal spaceOut xs p repeats a pattern p< at different durations given by the list of time values in xs tidalflatpat takes a Pattern of lists and pulls the list elements as separate Eventstidallayer takes a Pattern of lists and pulls the list elements as separate Eventstidal arpeggiate finds events that share the same timespan, and spreads them out during that timespan, so for example arpeggiate "[bd,sn]" gets turned into "bd sn".. Useful for creating arpeggios/broken chords.tidalShorthand alias for arpeggiatetidal plays each note of a chord quickly in order, as opposed to simultaneously; to give a chord a harp-like effect. This will played from the lowest note to the highest note of the chord  rolled $ n "cmaj4" # s "superpiano" And you can use  or ` to specify the length of the roll. The value in the passed pattern is the divisor of the cycle length. A negative value will play the arpeggio in reverse order.  rolledBy " 1-0.5 0.25 -0.125#" $ note "c'maj9" # s "superpiano" tidalSyncopates a rhythm, shifting each event halfway into its arc (aka timespan), e.g.  "a b [c d] e" becomes the equivalent of !"[~ a] [~ b] [[~ c] [~ d]] [~ e]"tidalLike press, but allows you to specify the amount in which each event is shifted.  pressBy 0.5 is the same as press, while  pressBy (1/3)) shifts each event by a third of its arc.tidalUses the first (binary) pattern to switch between the following two patterns. The resulting structure comes from the source patterns, not the binary pattern. See also stitch.tidalUses the first (binary) pattern to switch between the following two patterns. The resulting structure comes from the binary pattern, not the source patterns. See also sew.tidalA binary pattern is used to conditionally apply a function to a source pattern. The function is applied when a True value is active, and the pattern is let through unchanged when a False value is active. No events are let through where no binary values are active.tidalThe  function creates strange stereo effects, by applying a function to a pattern, but only in the right-hand channel. For example, the following reverses the pattern on the righthand side: =d1 $ slow 32 $ jux (rev) $ striateBy 32 (1/16) $ sound "bev" 2When passing pattern transforms to functions like  #juxjux and  #everyevery;, it's possible to chain multiple transforms together with , for example this both reverses and halves the playback speed of the pattern in the righthand channel: d1 $ slow 32 $ jux ((# speed "0.5") . rev) $ striateBy 32 (1/16) $ sound "bev" tidalIn addition to , ` allows using a list of pattern transform. resulting patterns from each transformation will be spread via pan from left to right. For example: d1 $ jux' [iter 4, chop 16, id, rev, palindrome] $ sound "bd sn" 5will put `iter 4` of the pattern to the far left and  to the far right. In the center the original pattern will play and mid left mid right the chopped and the reversed version will appear.One could also write: d1 $ stack [ iter 4 $ sound "bd sn" # pan "0", chop 16 $ sound "bd sn" # pan "0.25", sound "bd sn" # pan "0.5", rev $ sound "bd sn" # pan "0.75", palindrome $ sound "bd sn" # pan "1", ] tidalMultichannel variant of , _not sure what it does_tidalWith , the original and effected versions of the pattern are panned hard left and right (i.e., panned at 0 and 1). This can be a bit much, especially when listening on headphones. The variant  has an additional parameter, which brings the channel closer to the centre. For example: -d1 $ juxBy 0.5 (density 2) $ sound "bd sn:1" In the above, the two versions of the pattern would be panned at 0.25 and 0.75, rather than 0 and 1.tidal2 will take a pattern which goes from 0 to 1 (like ), and range it to a different range - between the first and second arguments. In the below example, `range 1 1.5` shifts the range of sine1 from 0 - 1 to 1 - 1.5. d1 $ jux (iter 4) $ sound "arpy arpy:2*2" |+ speed (slow 4 $ range 1 1.5 sine1) tidal is an exponential version of , good for using with frequencies. Do *not* use negative numbers or zero as arguments! tidalStep sequencingtidallike , but allows you to specify an array of strings to use for 0,1,2...tidal(tabby - A more literal weaving than the weave function, give number of threads per cycle and two patterns, and this function will weave them together using a plain (aka +) weave, with a simple over/under structuretidalchooses between a list of patterns, using a pattern of floats (from 0-1)tidalchooses between a list of functions, using a pattern of floats (from 0-1)tidalchooses between a list of functions, using a pattern of integerstidalcontrast p f f' p' splits controlpattern p' in two, applying the function f to one and f' to the other. This depends on whether events in it contains values matching with those in p. For example in contrast (# crush 3) (# vowel "a") (n "1") $ n "0 1" # s "bd sn" # speed 3, the first event will have the vowel effect applied and the second will have the crush applied.tidalLike contrast, but one function is given, and applied to events with matching controls.tidalLike contrast, but one function is given, and applied to events with controls which don't match.tidallimit values in a Pattern (or other Functor) to n equally spaced divisions of 1.tidal+Inverts all the values in a boolean patterntidalSerialises a pattern so there's only one event playing at any one time, making it  monophonic4. Events which start/end earlier are given priority.tidalLooks up values from a list of tuples, in order to swap values in the given patterntidalFor specifying a boolean pattern according to a list of offsets (aka inter-onset intervals). For example `necklace 12 [4,2]` is the same as "t f f f t f t f f f t f". That is, 12 steps per cycle, with true values alternating between every 4 and every 2 steps. Safe-Inferred ")*58ztidalAST representation of patterns Safe-Inferred"2tidal will "spin" a layer up a pattern the given number of times, with each successive layer offset in time by an additional `1/n` of a cycle, and panned by an additional `1/n`. The result is a pattern that seems to spin around. This function works best on multichannel systems. d1 $ slow 3 $ spin 4 $ sound "drum*3 tabla:4 [arpy:2 ~ arpy] [can:2 can:3]" tidal granualizes every sample in place as it is played, turning a pattern of samples into a pattern of sample parts. Use an integer value to specify how many granules each sample is chopped into: .d1 $ chop 16 $ sound "arpy arp feel*4 arpy*4" Different values of  can yield very different results, depending on the samples used: d1 $ chop 16 $ sound (samples "arpy*8" (run 16)) d1 $ chop 32 $ sound (samples "arpy*8" (run 16)) d1 $ chop 256 $ sound "bd*4 [sn cp] [hh future]*2 [cp feel]" tidal-Striate is a kind of granulator, for example: )d1 $ striate 3 $ sound "ho ho:2 ho:3 hc" This plays the loop the given number of times, but triggering progressive portions of each sample. So in this case it plays the loop three times, the first time playing the first third of each sample, then the second time playing the second third of each sample, etc.. With the highhat samples in the above example it sounds a bit like reverb, but it isn't really.You can also use striate with very long samples, to cut it into short chunks and pattern those chunks. This is where things get towards granular synthesis. The following cuts a sample into 128 parts, plays it over 8 cycles and manipulates those parts by reversing and rotating the loops. )d1 $ slow 8 $ striate 128 $ sound "bev" tidalThe  function is a variant of  with an extra parameter, which specifies the length of each part. The  function still scans across the sample over a single cycle, but if each bit is longer, it creates a sort of stuttering effect. For example the following will cut the bev sample into 32 parts, but each will be 1/16th of a sample long: 1d1 $ slow 32 $ striateBy 32 (1/16) $ sound "bev"  Note that  uses the begin and end8 parameters internally. This means that if you're using  (or &) you probably shouldn't also specify begin or end. tidalDEPRECATED, use  instead.tidal is similar to  in that it granualizes every sample in place as it is played, but every other grain is silent. Use an integer value to specify how many granules each sample is chopped into: d1 $ gap 8 $ sound "jvbass" d1 $ gap 16 $ sound "[jvbass drum:4]" tidal applies a function smoothly over an array of different patterns. It uses an  OscPattern to apply the function at different levels to each pattern, creating a weaving effect. d1 $ weave 3 (shape $ sine1) [sound "bd [sn drum:2*2] bd*2 [sn drum:1]", sound "arpy*8 ~"] tidal is similar in that it blends functions at the same time at different amounts over a pattern: d1 $ weaveWith 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]") [density 2, (# speed "0.5"), chop 16] tidal(A function that takes two ControlPatterns, and blends them together into a new ControlPattern. An ControlPattern is basically a pattern of messages to a synthesiser.)8Shifts between the two given patterns, using distortion.Example: d1 $ interlace (sound "bd sn kurt") (every 3 rev $ sound "bd sn:2") tidal makes a sample fit the given number of cycles. Internally, it works by setting the unit parameter to "c", changing the playback speed of the sample with the speed$ parameter, and setting setting the  of the pattern to match. d1 $ loopAt 4 $ sound "breaks125" d1 $ juxBy 0.6 (|* speed "2") $ slowspread (loopAt) [4,6,2,3] $ chop 12 $ sound "fm:14" tidalSmash is a combination of  and  - it cuts the samples into the given number of bits, and then cuts between playing the loop at different speeds according to the values in the list.So this: /d1 $ smash 3 [2,3,4] $ sound "ho ho:2 ho:3 hc" Is a bit like this: d1 $ spread (slow) [2,3,4] $ striate 3 $ sound "ho ho:2 ho:3 hc" This is quite dancehall: d1 $ (spread' slow "1%4 2 1 3" $ spread (striate) [2,3,4,1] $ sound "sn:2 sid:3 cp sid:4") # speed "[1 2 1 1]/2" tidalan altenative form to  is ` which will use  instead of .tidalApplies a type of delay to a pattern. It has three parameters, which could be called depth, time and feedback.This adds a bit of echo: - d1 $ echo 4 0.2 0.5 $ sound "bd sn" The above results in 4 echos, each one 50% quieter than the last, with 1/5th of a cycle between them.(It is possible to reverse the echo: 0 d1 $ echo 4 (-0.2) 0.5 $ sound "bd sn" tidalAllows to apply a function for each step and overlays the result delayed by the given time.  d1 $ echoWith 2 "1%3" (# vowel "{a e i o u}%2") $ sound "bd sn" In this case there are two _overlays_ delayed by 1/3 of a cycle, where each has the vowel filter applied.tidalDEPRECATED, use  insteadtidalDEPRECATED, use  insteadtidalDEPRECATED, use  insteadtidalTurns a pattern of seconds into a pattern of (rational) cycle durationstidalTurns a pattern of milliseconds into a pattern of (rational) cycle durations, according to the current cps... Safe-Inferred2   Safe-Inferred3K Safe-Inferred/5;6Utidal1Query the current pattern (contained in argument stream :: Stream<) for the events in the current arc (contained in argument  st :: T.State3), translate them to OSC messages, and send these.If an exception occurs during sending, this functions prints a warning and continues, because the likely reason is that the backend (supercollider) isn't running.If any exception occurs before or outside sending (e.g., while querying the pattern, while computing a message), this function prints a warning and resets the current pattern to the previous one (or to silence if there isn't one) and continues, because the likely reason is that something is wrong with the current pattern. Safe-Inferred@tidalWashes away the current pattern after a certain delay by applying a function to it over time, then switching over to the next pattern to which another function is applied.tidal8Pans the last n versions of the pattern across the fieldtidal.Just stop for a bit before playing new patterntidalJust as ,  stops for a bit and then applies the given transition to the playing pattern 9d1 $ sound "bd" t1 (waitT (xfadeIn 8) 4) $ sound "hh*8" tidalJumps directly into the given pattern, this is essentially the _no transition_-transition. Variants of jump' provide more useful capabilities, see jumpIn and jumpModtidalSharp = transition after the specified number of cycles have passed. "t1 (jumpIn 2) $ sound "kick(3,8)" tidalUnlike  the variant ` will only transition at cycle boundary (e.g. when the cycle count is an integer).tidalSharp 9 transition at next cycle boundary where cycle mod n == 0tidalSharp 9 transition at next cycle boundary where cycle mod n == ptidal:Degrade the new pattern over time until it ends in silencetidal8Degrades the current pattern while undegrading the next. This is like xfade but not by gain of samples but by randomly removing events from the current pattern and slowly adding back in missing events from the next one. ;d1 $ sound "bd(3,8)" t1 clutch $ sound "[hh*4, odx(3,8)]" clutch: takes two cycles for the transition, essentially this is  clutchIn 2.tidalAlso degrades the current pattern and undegrades the next. To change the number of cycles the transition takes, you can use clutchIn like so: d1 $ sound "bd(5,8)" t1 (clutchIn 8) $ sound "[hh*4, odx(3,8)]" &will take 8 cycles for the transition.tidalsame as  though it allows you to specify the number of cycles until dropping to the new pattern, e.g.: d1 $ sound "jvbass(3,8)" t1 (anticipateIn 4) $ sound "jvbass(5,8)" tidal is an increasing comb filter.Build up some tension, culminating in a _drop_ to the new pattern after 8 cycles. Safe-Inferred@  $%(&')*+,-./0123456789:DEFGHIJ^]\[ZYXWVUSRQPNMKTOL_`bdcaefghijklmnopqtrsuvwxyz{|}~  Safe-InferredRB  $%(&')*+,-./0123456789:DEFGHIJ^]\[ZYXWVUSRQPNMKTOL_`bdcaefghijklmnopqtrsuvwxyz{|}~  Safe-Inferredc<44 !"#$%%&'()*+,-./01234556789:;<=>=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwvxyz{||}~Z                                                                                                                                                                                                                                                                                                                                                                       ?                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "tidal-1.9.2-KOctsaWIAqVLN5IbMcaXg6Sound.Tidal.Show Paths_tidalSound.Tidal.BjorklundSound.Tidal.ConfigSound.Tidal.IDSound.Tidal.TimeSound.Tidal.PatternSound.Tidal.StreamTypesSound.Tidal.CoreSound.Tidal.ChordsSound.Tidal.UtilsSound.Tidal.TempoSound.Tidal.ScalesSound.Tidal.ParamsSound.Tidal.UISound.Tidal.ParseBPSound.Tidal.ControlSound.Tidal.SimpleSound.Tidal.VersionSound.Tidal.Safe.ContextSound.Tidal.StreamSound.Tidal.TransitionSound.Tidal.Safe.BootSound.Tidal.ContextbaseGHC.ShowshowversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir bjorklundConfig cCtrlListen cCtrlAddr cCtrlPortcCtrlBroadcastcFrameTimespan cEnableLink cProcessAhead cTempoAddr cTempoPortcTempoClientPort cSkipTickscVerbosecQuantumcBeatsPerCycle defaultConfigIDfromID $fIsStringID$fNumID$fEqID$fShowID$fOrdID$fReadIDArcArcFstartstopTimesamtoTimefromTimenextSamcyclePoshullsubArc subMaybeArcsecttimeToCycleArccycleArc cyclesInArccycleArcsInArc arcCycles arcCyclesZWmapCycleisIn$fFractionalArcF $fNumArcF $fNFDataArcF$fApplicativeArcF$fEqArcF $fOrdArcF $fFunctorArcF $fShowArcF $fGenericArcFNoteunNoteValueMapValuabletoValueValueVSVFVNVRVIVBVXVPatternVListVStatesvaluefvaluenvaluervalueivaluebvaluexvaluepvaluelvalue statevalueEventEventFcontextwholepartvalueContextcontextPositionStringy deltaContextModdablegmodControlPatternPatternqueryStatearccontrols<**><<* applyPatToPatapplyPatToPatBothapplyPatToPatLeftapplyPatToPatRightapplyPatToPatSqueezeunwrap innerJoin outerJoin squeezeJoinnoOvemptyqueryArc splitQueries withResultArcwithResultTime withQueryArc withQueryTime withEvent withValue withEventswithPart_extractextractIextractFextractSextractBextractR compressArc compressArcTo_fastGaprotLrotRmatchManyToOne filterValues filterJust filterWhen filterOnsets filterEvents filterDigital filterAnalogplayFortParamtParam2tParam3 tParamSqueezecombineContexts setContext withContext deltaMiniisAnalog isDigitalonsetIn defragParts isAdjacent wholeOrPart wholeStart wholeStopeventPartStart eventPartStop eventPart eventValue eventHasOnsettoEvent resolveStateapplyFISfNum2getIgetFgetNgetSgetBgetRgetBlobgetListvalueToPatternsameDur groupEventsBy collectEventcollectEventsBy collectBycollectuncollectEventuncollectEvents uncollect $fModdableInt$fModdableRatio$fModdableDouble $fStringy[]$fNFDataContext$fNFDataEventF $fShowNote $fNFDataNote$fModdableNote $fOrdValue $fEqValue $fNFDataValue$fStringyPattern $fFloatingMap $fModdableMap$fFractionalMap$fNumMap$fRealFloatPattern$fRealFracPattern$fFloatingPattern$fFractionalPattern$fIntegralPattern $fRealPattern$fSemigroupPattern$fMonoidPattern $fEnumPattern $fNumPattern $fOrdPattern $fEqPattern$fMonadPattern$fApplicativePattern$fNFDataPattern $fValuable[] $fValuable[]0$fValuableNote$fValuableBool $fValuableInt$fValuableRatio$fValuableDouble $fValuable[]1$fGenericValue$fGenericPattern$fFunctorPattern $fDataNote $fGenericNote$fEqNote $fOrdNote $fEnumNote $fNumNote$fFractionalNote$fFloatingNote $fRealNote$fRealFracNote $fEqEventF $fOrdEventF$fFunctorEventF$fGenericEventF $fEqContext $fOrdContext$fGenericContext showStatefulshowAll stepcountdrawLine drawLineSzdraw $fShowEventF $fShowMap $fShowValue $fShowContext $fShowPattern $fShowRender TickStatetickArc tickNudgePlayMapPatId PlayStatepatternmutesolohistory$fShowTickState$fShowPlayState Unionableunionsilencesigsinesine2cosinecosine2sawsaw2isawisaw2tritri2squaresquare2envLenvLRenvEqenvEqR|+||++|||+|++||++++|||++|/||//|||/|*||**|||*|-||--|||-|%||%%|||%|**||****|||**|>||>>|||>|<||<<|||<#fromList fastFromList listToPat fromMaybesrun_runscan_scanappendcatslowCatslowcat slowAppend slowappend fastAppend fastappendfastCatfastcattimeCattimecatoverlaystack<~~>fast fastSqueezedensity_fastslow_slow slowSqueezesparsityrevzoomzoomArcfastGap densityGapcompress compressTo repeatCycles _repeatCyclesfastRepeatCyclesevery_everyevery'_every' foldEverywhenwhenT_getP__getP_cX_cX_cFcF_cF0cNcN_cN0cIcI_cI0cBcB_cB0cRcR_cR0cTcT0cT_cScS_cS0in0in1in2in3in4in5in6in7in8in9in10in11in12in13in14in15in16in17in18in19in20in21in22in23in24in25in26in27in28in29in30in31in32in33in34in35in36in37in38in39in40in41in42in43in44in45in46in47in48in49in50in51in52in53in54in55in56in57in58in59in60in61in62in63in64in65in66in67in68in69in70in71in72in73in74in75in76in77in78in79in80in81in82in83in84in85in86in87in88in89in90in91in92in93in94in95in96in97in98in99in100in101in102in103in104in105in106in107in108in109in110in111in112in113in114in115in116in117in118in119in120in121in122in123in124in125in126in127$fUnionableMap $fUnionableaModifierRangeDropInvertOpenmajoraugsixsixNinemajor7major9add9major11add11major13add13dom7dom9dom11dom13 sevenFlat5 sevenSharp5 sevenFlat9nineeleventhirteenminor diminished minorSharp5minor6 minorSixNine minor7flat5minor7 minor7sharp5 minor7flat9 minor7sharp9 diminished7minor9minor11minor13onefivesus2sus4 sevenSus2 sevenSus4nineSus4 sevenFlat10 nineSharp5 minor9sharp5sevenSharp5flat9minor7sharp5flat9 elevenSharp minor11sharp chordTablechordL chordList applyModifierapplyModifierPatapplyModifierPatSeq chordToPatSeqchord$fShowModifier $fEqModifier writeErrormapBoth mapPartTimesmapFstmapSnddeltamid removeCommon readMaybe!!!nth accumulate enumeratewordsBy matchMaybe fromRightLinkOperations timeAtBeat timeToCyclesgetTemposetTempo linkToOscTime beatToCycles cyclesToBeat ActionHandleronTick onSingleTick updatePatternticksnowEndnowArcnudged TempoAction ResetCycles SingleTickSetNudge StreamReplace TransitionTransitionMapper resetCyclessetNudge timeToCycles' cyclesToTimeaddMicrosToOscclocked $fShowUDP $fShowStatescalegetScale scaleList scaleTablegrpmFmImSpFpIpBpRpNpSpXpStateF pStateList pStateListF pStateListSsoundsTakeccnrpnnrpnnnrpnvgrain'midinotedrumdrumN accelerateaccelerateTakeaccelerateCountaccelerateCountTo acceleratebusacceleraterecvampampTakeampCount ampCountToampbusamprecvarray arrayTakearraybusattack attackTake attackCount attackCountTo attackbus attackrecvbandf bandfTake bandfCount bandfCountTobandfbus bandfrecvbandq bandqTake bandqCount bandqCountTobandqbus bandqrecvbegin beginTake beginCount beginCountTobeginbus beginrecvbinshift binshiftTake binshiftCountbinshiftCountTo binshiftbus binshiftrecvbutton0 button0Take button0Countbutton0CountTo button0bus button0recvbutton1 button1Take button1Countbutton1CountTo button1bus button1recvbutton10 button10Take button10Countbutton10CountTo button10bus button10recvbutton11 button11Take button11Countbutton11CountTo button11bus button11recvbutton12 button12Take button12Countbutton12CountTo button12bus button12recvbutton13 button13Take button13Countbutton13CountTo button13bus button13recvbutton14 button14Take button14Countbutton14CountTo button14bus button14recvbutton15 button15Take button15Countbutton15CountTo button15bus button15recvbutton2 button2Take button2Countbutton2CountTo button2bus button2recvbutton3 button3Take button3Countbutton3CountTo button3bus button3recvbutton4 button4Take button4Countbutton4CountTo button4bus button4recvbutton5 button5Take button5Countbutton5CountTo button5bus button5recvbutton6 button6Take button6Countbutton6CountTo button6bus button6recvbutton7 button7Take button7Countbutton7CountTo button7bus button7recvbutton8 button8Take button8Countbutton8CountTo button8bus button8recvbutton9 button9Take button9Countbutton9CountTo button9bus button9recvccnccnTakeccnCount ccnCountToccnbusccvccvTakeccvCount ccvCountToccvbuschannel channelTake channelCountchannelCountTo channelbus clhatdecayclhatdecayTakeclhatdecayCountclhatdecayCountTo clhatdecaybusclhatdecayrecvcoarse coarseTake coarseCount coarseCountTo coarsebus coarserecvcombcombTake combCount combCountTocombbuscombrecvcontrol controlTake controlCountcontrolCountTo controlbuscpscpsTakecpsCount cpsCountTocpsbuscpsrecvcrush crushTake crushCount crushCountTocrushbus crushrecvctlNum ctlNumTake ctlNumCount ctlNumCountTo ctlNumbus ctransposectransposeTakectransposeCountctransposeCountTo ctransposebusctransposerecvcutcutTakecutCount cutCountTocutbuscutrecvcutoff cutoffTake cutoffCount cutoffCountTo cutoffbus cutoffrecv cutoffegintcutoffegintTakecutoffegintCountcutoffegintCountTocutoffegintbuscutoffegintrecvdecay decayTake decayCount decayCountTodecaybus decayrecvdegree degreeTake degreeCount degreeCountTo degreebus degreerecvdelay delayTake delayCount delayCountTodelaybus delayrecv delayfeedbackdelayfeedbackTakedelayfeedbackCountdelayfeedbackCountTodelayfeedbackbusdelayfeedbackrecv delaytime delaytimeTakedelaytimeCountdelaytimeCountTo delaytimebus delaytimerecvdetune detuneTake detuneCount detuneCountTo detunebus detunerecvdistort distortTake distortCountdistortCountTo distortbus distortrecvdjfdjfTakedjfCount djfCountTodjfbusdjfrecvdrydryTakedryCount dryCountTodrybusdryrecvdurdurTakedurCount durCountTodurbusdurrecvendendTakeendCount endCountToendbusenhance enhanceTake enhanceCountenhanceCountTo enhancebus enhancerecv expressionexpressionTakeexpressionCountexpressionCountTo expressionbusexpressionrecv fadeInTimefadeInTimeTakefadeInTimeCountfadeInTimeCountTo fadeInTimebusfadeTime fadeTimeTake fadeTimeCountfadeTimeCountTo fadeTimebus frameRate frameRateTakeframeRateCountframeRateCountTo frameRatebusframes framesTake framesCount framesCountTo framesbusfreeze freezeTake freezeCount freezeCountTo freezebus freezerecvfreqfreqTake freqCount freqCountTofreqbusfreqrecvfromfromTake fromCount fromCountTofrombusfromrecvfshift fshiftTake fshiftCount fshiftCountTo fshiftbus fshiftrecv fshiftnotefshiftnoteTakefshiftnoteCountfshiftnoteCountTo fshiftnotebusfshiftnoterecv fshiftphasefshiftphaseTakefshiftphaseCountfshiftphaseCountTofshiftphasebusfshiftphaserecvgaingainTake gainCount gainCountTogainbusgategateTake gateCount gateCountTogatebusgaterecvharmonic harmonicTake harmonicCountharmonicCountTo harmonicbus harmonicrecvhatgrain hatgrainTake hatgrainCounthatgrainCountTo hatgrainbus hatgrainrecvhbrick hbrickTake hbrickCount hbrickCountTo hbrickbus hbrickrecvhcutoff hcutoffTake hcutoffCounthcutoffCountTo hcutoffbus hcutoffrecvholdholdTake holdCount holdCountToholdbusholdrecvhours hoursTake hoursCount hoursCountTohoursbus hresonancehresonanceTakehresonanceCounthresonanceCountTo hresonancebushresonancerecvimagimagTake imagCount imagCountToimagbusimagrecvkcutoff kcutoffTake kcutoffCountkcutoffCountTo kcutoffbus kcutoffrecvkrush krushTake krushCount krushCountTokrushbus krushrecvlagogo lagogoTake lagogoCount lagogoCountTo lagogobus lagogorecvlbrick lbrickTake lbrickCount lbrickCountTo lbrickbus lbrickrecvlclap lclapTake lclapCount lclapCountTolclapbus lclaprecvlclaves lclavesTake lclavesCountlclavesCountTo lclavesbus lclavesrecvlclhat lclhatTake lclhatCount lclhatCountTo lclhatbus lclhatrecvlcrash lcrashTake lcrashCount lcrashCountTo lcrashbus lcrashrecvlegato legatoTake legatoCount legatoCountTo legatobusleslie leslieTake leslieCount leslieCountTo lesliebus leslierecvlfolfoTakelfoCount lfoCountTolfobuslforecv lfocutoffintlfocutoffintTakelfocutoffintCountlfocutoffintCountTolfocutoffintbuslfocutoffintrecvlfodelay lfodelayTake lfodelayCountlfodelayCountTo lfodelaybus lfodelayrecvlfoint lfointTake lfointCount lfointCountTo lfointbus lfointrecv lfopitchintlfopitchintTakelfopitchintCountlfopitchintCountTolfopitchintbuslfopitchintrecvlfoshape lfoshapeTake lfoshapeCountlfoshapeCountTo lfoshapebus lfoshaperecvlfosync lfosyncTake lfosyncCountlfosyncCountTo lfosyncbus lfosyncrecvlhitom lhitomTake lhitomCount lhitomCountTo lhitombus lhitomrecvlkick lkickTake lkickCount lkickCountTolkickbus lkickrecvllotom llotomTake llotomCount llotomCountTo llotombus llotomrecvlocklockTake lockCount lockCountTolockbuslockrecvlooploopTake loopCount loopCountToloopbuslophat lophatTake lophatCount lophatCountTo lophatbus lophatrecvlrate lrateTake lrateCount lrateCountTolratebus lraterecvlsize lsizeTake lsizeCount lsizeCountTolsizebus lsizerecvlsnare lsnareTake lsnareCount lsnareCountTo lsnarebus lsnarerecvmidibend midibendTake midibendCountmidibendCountTo midibendbusmidichan midichanTake midichanCountmidichanCountTo midichanbusmidicmd midicmdTake midicmdbus miditouch miditouchTakemiditouchCountmiditouchCountTo miditouchbusminutes minutesTake minutesCountminutesCountTo minutesbusmodwheel modwheelTake modwheelCountmodwheelCountTo modwheelbus modwheelrecv mtransposemtransposeTakemtransposeCountmtransposeCountTo mtransposebusmtransposerecvnnTakenCountnCountTonbusnotenoteTake noteCount noteCountTonotebusnudge nudgeTake nudgeCount nudgeCountTonudgebus nudgerecvoctave octaveTake octaveCount octaveCountTo octavebusoctaveR octaveRTake octaveRCountoctaveRCountTo octaveRbus octaveRrecvocter octerTake octerCount octerCountToocterbus octerrecvoctersub octersubTake octersubCountoctersubCountTo octersubbus octersubrecv octersubsuboctersubsubTakeoctersubsubCountoctersubsubCountTooctersubsubbusoctersubsubrecvoffset offsetTake offsetCount offsetCountTo offsetbus ophatdecayophatdecayTakeophatdecayCountophatdecayCountTo ophatdecaybusophatdecayrecvorbit orbitTake orbitCount orbitCountToorbitbus orbitrecvovergain overgainTake overgainCountovergainCountTo overgainbus overshape overshapeTakeovershapeCountovershapeCountTo overshapebus overshaperecvpanpanTakepanCount panCountTopanbuspanrecv panorient panorientTakepanorientCountpanorientCountTo panorientbus panorientrecvpanspan panspanTake panspanCountpanspanCountTo panspanbus panspanrecvpansplay pansplayTake pansplayCountpansplayCountTo pansplaybus pansplayrecvpanwidth panwidthTake panwidthCountpanwidthCountTo panwidthbus panwidthrecvpartials partialsTake partialsCountpartialsCountTo partialsbus partialsrecv phaserdepthphaserdepthTakephaserdepthCountphaserdepthCountTophaserdepthbusphaserdepthrecv phaserratephaserrateTakephaserrateCountphaserrateCountTo phaserratebusphaserraterecvpitch1 pitch1Take pitch1Count pitch1CountTo pitch1bus pitch1recvpitch2 pitch2Take pitch2Count pitch2CountTo pitch2bus pitch2recvpitch3 pitch3Take pitch3Count pitch3CountTo pitch3bus pitch3recv polyTouch polyTouchTakepolyTouchCountpolyTouchCountTo polyTouchbus portamentoportamentoTakeportamentoCountportamentoCountTo portamentobusportamentorecvprogNum progNumTake progNumCountprogNumCountTo progNumbusraterateTake rateCount rateCountToratebusraterecvrealrealTake realCount realCountTorealbusrealrecvrelease releaseTake releaseCountreleaseCountTo releasebus releaserecv resonance resonanceTakeresonanceCountresonanceCountTo resonancebus resonancerecvringringTake ringCount ringCountToringbusringrecvringdf ringdfTake ringdfCount ringdfCountTo ringdfbus ringdfrecvringf ringfTake ringfCount ringfCountToringfbus ringfrecvroomroomTake roomCount roomCountToroombusroomrecvsagogo sagogoTake sagogoCount sagogoCountTo sagogobus sagogorecvsclap sclapTake sclapCount sclapCountTosclapbus sclaprecvsclaves sclavesTake sclavesCountsclavesCountTo sclavesbus sclavesrecvscram scramTake scramCount scramCountToscrambus scramrecvscrash scrashTake scrashCount scrashCountTo scrashbus scrashrecvseconds secondsTake secondsCountsecondsCountTo secondsbussemitone semitoneTake semitoneCountsemitoneCountTo semitonebus semitonerecvshape shapeTake shapeCount shapeCountToshapebus shaperecvsizesizeTake sizeCount sizeCountTosizebussizerecvslide slideTake slideCount slideCountToslidebus sliderecvslider0 slider0Take slider0Countslider0CountTo slider0bus slider0recvslider1 slider1Take slider1Countslider1CountTo slider1bus slider1recvslider10 slider10Take slider10Countslider10CountTo slider10bus slider10recvslider11 slider11Take slider11Countslider11CountTo slider11bus slider11recvslider12 slider12Take slider12Countslider12CountTo slider12bus slider12recvslider13 slider13Take slider13Countslider13CountTo slider13bus slider13recvslider14 slider14Take slider14Countslider14CountTo slider14bus slider14recvslider15 slider15Take slider15Countslider15CountTo slider15bus slider15recvslider2 slider2Take slider2Countslider2CountTo slider2bus slider2recvslider3 slider3Take slider3Countslider3CountTo slider3bus slider3recvslider4 slider4Take slider4Countslider4CountTo slider4bus slider4recvslider5 slider5Take slider5Countslider5CountTo slider5bus slider5recvslider6 slider6Take slider6Countslider6CountTo slider6bus slider6recvslider7 slider7Take slider7Countslider7CountTo slider7bus slider7recvslider8 slider8Take slider8Countslider8CountTo slider8bus slider8recvslider9 slider9Take slider9Countslider9CountTo slider9bus slider9recvsmear smearTake smearCount smearCountTosmearbus smearrecvsongPtr songPtrTake songPtrCountsongPtrCountTo songPtrbusspeed speedTake speedCount speedCountTospeedbussquiz squizTake squizCount squizCountTosquizbus squizrecvstepsPerOctavestepsPerOctaveTakestepsPerOctaveCountstepsPerOctaveCountTostepsPerOctavebusstepsPerOctaverecv stutterdepthstutterdepthTakestutterdepthCountstutterdepthCountTostutterdepthbusstutterdepthrecv stuttertimestuttertimeTakestuttertimeCountstuttertimeCountTostuttertimebusstuttertimerecvsustain sustainTake sustainCountsustainCountTo sustainbus sustainpedalsustainpedalTakesustainpedalCountsustainpedalCountTosustainpedalbussustainpedalrecv timescale timescaleTaketimescaleCounttimescaleCountTo timescalebus timescalewintimescalewinTaketimescalewinCounttimescalewinCountTotimescalewinbustotoTaketoCount toCountTotobustorecvtoArg toArgTaketoArgbus toArgrecvtomdecay tomdecayTake tomdecayCounttomdecayCountTo tomdecaybus tomdecayrecv tremolodepthtremolodepthTaketremolodepthCounttremolodepthCountTotremolodepthbustremolodepthrecv tremoloratetremolorateTaketremolorateCounttremolorateCountTotremoloratebustremoloraterecvtriode triodeTake triodeCount triodeCountTo triodebus trioderecvtsdelay tsdelayTake tsdelayCounttsdelayCountTo tsdelaybus tsdelayrecvuiduidTakeuidCount uidCountTouidbusunitunitTakeunitbusvalvalTakevalCount valCountTovalbusvcfegint vcfegintTake vcfegintCountvcfegintCountTo vcfegintbus vcfegintrecvvcoegint vcoegintTake vcoegintCountvcoegintCountTo vcoegintbus vcoegintrecvvelocity velocityTake velocityCountvelocityCountTo velocitybus velocityrecvvoice voiceTake voiceCount voiceCountTovoicebus voicerecvvowel vowelTakevowelbus vowelrecvwaveloss wavelossTake wavelossCountwavelossCountTo wavelossbus wavelossrecvxsdelay xsdelayTake xsdelayCountxsdelayCountTo xsdelaybus xsdelayrecvvoivoibusvoirecvvcovcobusvcorecvvcfvcfbusvcfrecvuptremrtremrbus tremrrecvtremdp tremdpbus tremdprecvtdecay tdecaybus tdecayrecvszszbusszrecvsussttsttbussttrecvstdstdbusstdrecvsldsldbussldrecvscrscrbusscrrecvscpscpbusscprecvsclsclbussclrecvsagsagbussagrecvsrelrelbusrelrecvporporbusporrecvpit3pit3buspit3recvpit2pit2buspit2recvpit1pit1buspit1recvphasrphasrbus phasrrecvphasdp phasdpbus phasdprecvohdecay ohdecaybus ohdecayrecvnumberlsnlsnbuslsnrecvlpqlpqbuslpqrecvlpflpfbuslpfrecvlohlohbuslohrecvlltlltbuslltrecvlhtlhtbuslhtrecvlfoplfopbuslfoprecvlfoilfoibuslfoirecvlfoclfocbuslfocrecvlcrlcrbuslcrrecvlcplcpbuslcprecvlcllclbuslclrecvlchlchbuslchrecvlbdlbdbuslbdrecvlaglagbuslagrecvhpqhpqbushpqrecvhpfhpfbushpfrecvhghgbushgrecvgatgatbusgatrecv fadeOutTimedtdtbusdtrecvdfbdfbbusdfbrecvdetdetbusdetrecvdelayt delaytbus delaytrecvdelayfb delayfbbus delayfbrecvctfgctfgbusctfgrecvctfctfbusctfrecvchdecay chdecaybus chdecayrecvbpqbpqbusbpqrecvbpfbpfbusbpfrecvattattbusattrecvxorwise timeToIntSeed intSeedToRand timeToRand timeToRands timeToRands'randbrandbrandBy_brandByirand_irand perlinWithperlin perlin2Withperlin2choosechooseBywchoose wchooseBy degradeBy _degradeBy_degradeByUsing unDegradeBy _unDegradeBy degradeOverBy sometimesBy sometimesBy' sometimes sometimes'oftenoften'rarelyrarely' almostNever almostNever' almostAlways almostAlways'neveralways someCyclesBy _someCyclesBy somecyclesBy someCycles somecyclesdegradebrakiter_iteriter'_iter' palindromeseqPfadeOut fadeOutFromfadeIn fadeInFromspread slowspread fastspreadspread' spreadChoosespreadrifpwedge_wedgewhenmod_whenmod superimposetrunc_trunclinger_lingerwithin withinArcwithin'revArceuclid_euclid euclidFull _euclidBool_euclid' euclidOffeoff _euclidOff euclidOffBool_euclidOffBooldistrib_distrib euclidInv _euclidInvindexrot_rotsegment_segment discretiserandcatwrandcat_fitfitpermstepstruct substructrandArcs randStruct substruct'stripe_stripe slowstripe parseLMRule parseLMRule' lindenmayer lindenmayerI runMarkov markovPat _markovPatmask enclosingArcstretchfit'chunk_chunkchunk'_chunk'_insideinside_outsideoutside loopFirsttimeLoopseqPLooptoScale'toScaleswingByswing cycleChoose_rearrangeWithshuffle_shufflescramble _scramblerandrunurinhabitspaceOutflatpatlayer arpeggiatearpgarpWitharp_arp rolledWithrolledByrolledply_plyplyWith_plyWithpresspressBy_pressBysewstitchwhilestutterjuxjuxcutjuxcut'jux'jux4juxBypicksamplessamples'spreadf stackwithrange_rangerangexoff_offoffaddstepstepsstep'ghost''ghost'ghosttabbyselect_selectselectF_selectFpickF_pickFcontrast contrastBy contrastRangefixunfixfixRange unfixRangequantiseqfloorqceilingqroundinvmonosmoothswapsnowballsoak deconstructbite_bitesqueeze squeezeJoinUp_chewchew__binary_binary_binaryNbinaryNbinaryasciigrainnecklaceSignPositiveNegativeColourD EnumerablefromTo fromThenTo Parseable tPatParserdoEuclid getControlTPat TPat_Atom TPat_Fast TPat_SlowTPat_DegradeByTPat_CycleChoose TPat_Euclid TPat_StackTPat_PolyrhythmTPat_Seq TPat_Silence TPat_Foot TPat_Elongate TPat_RepeatTPat_EnumFromToTPat_Var TPat_ChordMyParserTidalParseError parsecErrorcode tShowListtShowtoPat resolve_tpat resolve_seq resolve_size steps_tpat steps_seq steps_sizeparseBP parseBP_E parseTPatcP enumFromTo'enumFromThenTo'lexerbracesbracketsparensanglessymbolnaturalintegerdecimalfloatnaturalOrFloat applySignsign intOrFloat pSequencepRepeat pElongatepSinglepVarpPartnewSeedpPolyInpPolyOutpCharNumpStringwrapPospVocablepCharpDoublepDoubleWithoutChordpNotepNoteWithoutChordpBool parseIntNote pIntegralpIntegralWithoutChord parseChord parseNotefromNotepColourpMultpRandpE pRationalpRatiopIntegerpFloat pFraction pRatioCharpRatioSingleCharisInt parseModInvparseModInvNum parseModDrop parseModOpen parseModRangeparseModifiers pModifierspChord$fShowTidalParseError$fExceptionTidalParseError$fEnumerable[]$fEnumerableRatio$fEnumerableInteger$fEnumerableInt$fEnumerableBool$fEnumerable[]0$fEnumerableNote$fEnumerableDouble$fEnumerableChar $fParseable[]$fIsStringPattern$fParseableRatio$fParseableInteger$fParseableInt$fParseableBool$fParseable[]0$fParseableNote$fParseableDouble$fParseableChar $fFunctorTPat $fShowTPat$fEnumerableColour$fParseableColour$fEqTidalParseErrorspin_spinchopchopArc_chopstriate_striatemergePlayRange striateBystriate' _striateBygap_gapweave weaveWithweave' interlaceslice_slice randslice_splicespliceloopAthurrysmashsmash'echo_echoechoWith _echoWithstut_stutstutWith _stutWithstut'secmsec triggerWithtriggerctriggerqtriggerrtriggerftriggerqtresetsplatcrunchscratchlouderquietersilentskipleftrighthigherlowerfasterslower tidal_version tidal_statustidal_status_stringTargetoNameoAddressoPortoBusPortoLatencyoWindow oSchedule oHandshake$fShowCx $fShowOSC $fShowArgs $fShowTarget $fEqSchedule$fShowSchedule$fEqStampStyle$fShowStampStyle transition mortalOverlaywashwashInxfadeInhistpanwaitwaitTjumpjumpInjumpIn'jumpModjumpMod'mortal interpolate interpolateInclutchclutchIn anticipateIn anticipateOpexec streamReplace streamHush streamList streamMute streamUnmute streamSolo streamUnsolo streamOnce streamFirststreamNudgeAll streamAllstreamResetCycles streamSetI streamSetF streamSetS streamSetR streamSetB $fFunctorOp$fApplicativeOp $fMonadOp$fMonadCatchOp$fMonadThrowOpphushlistunmuteunsolooncefirstasapnudgeAllallsetcpsxfadeforIdd1d2d3d4d5d6d7d8d9d10d11d12d13d14d15d16setIsetFsetSsetRsetBGHC.Real toRational fromRationalGHC.Basefmap GHC.MaybeMaybeNothingghc-prim GHC.TypesTrueDoubleGHC.List!!False.doTickProcessedEvent peOnPartOscpeOnPartpeOnWholeOrPartOscpeOnWholeOrPartpeCyclepeDeltapeCpspeEvent peHasOnsetOSCargspath OSCContextArgs requiredArgsNamedArgListSchedulePreLive StampStyle BundleStamp MessageStampCx cxBusAddrcxAddrcxOSCscxUDPcxTargetStreamsCxs sGlobalFMV sActionsMVsPMapMVsListensLinksStateMVsBussessConfigsDefaultfDefaultrDefaultiDefaultbDefaultxDefaultrequiredsuperdirtTargetsuperdirtShape dirtTarget dirtShape defaultCps startStreamsendHandshakessendOsendBndlresolve startTidal startMultitoDatumtoDatasubstitutePath getString playStacktoOSC processCpssetPreviousPatternOrSilencesendhasSolo streamMutes withPatIds streamMuteAllstreamUnmuteAllstreamUnsoloAll streamSilence streamGet streamSet openListener ctrlResponderverboserecvMessagesTimeout streamGetcps streamGetnowRatioRational Data.RatioapproxRational numerator denominator%