h*O      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     1.9.5 Safe-Inferred1 Safe-Inferred1F   Safe-Inferred1n     Safe-Inferred2tidalWrapper 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-Inferred9<=%tidalAn arc of time, with a start time (or onset) and a stop time (or offset))tidalTime is rational*tidalThe sam (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  toRational.,tidalTurns a (rational) time value into another number. An alias for  fromRational.-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.)5tidal1Returns 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 Arc3 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 0PITFALL: Don't be fooled by the name. The output cycles are not necessarily completely contained in the input Arc, but they definitely overlap it, and they include every cycle that overlaps it.6tidal.This provides exactly the same information as  cyclesInArc-, except that this represents its output as Arc s, whereas  cyclesInArc< represents the same information as integral indices. (The Arc from 0 to 1 corresponds to the index 0, the one from 1 to 2 has index 1, etc.)7tidalSplits the given Arc into a list of Arcs, at cycle boundaries.8tidal+Like arcCycles, but returns zero-width arcs9tidal Similar to fmap 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-Inferred79<[5Dtidal+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 querytidal3Apply a function to the control values 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 controltidalExtract a pattern of note values by from a control pattern, given the name of the controltidal-Speed up a pattern by the given time pattern.7For example, the following will play the sound pattern  "bd sn kurt" twice as fast (i.e., so it repeats twice per cycle), and the vowel pattern three times as fast: )|s: "bd" (>)|s: "bd" (>1)|s: "sn"This will give bd% played in the first half cycle, and bd sn< in the second half. On the other hand, using fastSqueeze;%print $ fastSqueeze "1 2" $ s "bd sn" (0>)|s: "bd" (>)|s: "sn" (>B)|s: "bd" (B>)|s: "sn" (>B)|s: "bd" (B>1)|s: "sn"The original pattern will play in the first half, and two repetitions of the original pattern will play in the second half. That is, every repetition contains the whole pattern.If the time pattern has a single value, it becomes equivalent to : d1 $ fastSqueeze 2 $ s "bd sn" d1 $ fast 2 $ s "bd sn" d1 $ s "[bd sn]*2"tidal An alias for fasttidal.Slow down a pattern by the given time pattern.7For example, the following will play the sound pattern  "bd sn kurt" twice as slow (i.e., so it repeats once every two cycles), and the vowel pattern three times as slow: 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_qrstnopfghmGklDEFJOLTKMNPQRSUVWXYZ[\]^ij`aecdbHIvuyz{w|x}~)%&'($*+,-./0213456789:_qrstnopfghmGklDEFJOLTKMNPQRSUVWXYZ[\]^ij`aecdbHIvuyz{w|x}~u4v4w4 Safe-Inferred%&^ Safe-Inferred^G    Safe-Inferred/tidal8Takes a function of time to values, and turns it into a n4. Useful for creating continuous patterns such as  or perlin. For example,  is defined as )saw = sig $ \t -> mod' (fromRational t) 1tidalsine - 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. The following are equivalent: d1 $ n (fromList [0, 1, 2]) # s "superpiano" d1 $ n "<0 1 2>" # s "superpiano"tidal/Turns a list of values into a pattern, playing all3 of them per cycle. The following are equivalent: d1 $ n (fastFromList [0, 1, 2]) # s "superpiano" d1 $ n "[0 1 2]" # s "superpiano"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. The following are equivalent: > d1 $ n (fromMaybes [Just 0, Nothing, Just 2]) # s "superpiano" > d1 $ n "0 ~ 2" # s "superpiano"tidalA pattern of whole numbers from 0 to the given number, in a single cycle. Can be used used to run& through a folder of samples in order: "d1 $ n (run 8) # sound "amencutup"5The first parameter to run can be given as a pattern: ,d1 $ n (run "<4 8 4 6>") # sound "amencutup"tidal Similar to , but starts from 1 for the first cycle, successively adds a number until it gets up to n(. > d1 $ n (scan 8) # sound "amencutup"tidalAlternate between cycles of the two given patterns > d1 $ append (sound "bd*2 sn") (sound "arpy jvbass*2")tidalLike , 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. It concatenates a list of patterns into a new pattern; each pattern in the list will maintain its original duration. For example: d1 $ cat [sound "bd*2 sn", sound "arpy jvbass*2"] d1 $ cat [sound "bd*2 sn", sound "arpy jvbass*2", sound "drum*2"] d1 $ cat [sound "bd*2 sn", sound "jvbass*3", sound "drum*2", sound "ht mt"]tidal Alias for tidal Alias for tidalLike , but twice as fast > d1 $ fastAppend (sound "bd*2 sn") (sound "arpy jvbass*2")tidal 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. d1 $ fastcat [sound "bd*2 sn", sound "arpy jvbass*2"] d1 $ fastcat [sound "bd*2 sn", sound "arpy jvbass*2", sound "drum*2"] d1 $ fastcat [sound "bd*2 sn", sound "jvbass*3", sound "drum*2", sound "ht mt"]tidal Alias for fastCattidal Similar to fastCat, but each pattern is given a relative duration. You provide proportionate sizes of the patterns to each other for when they@re concatenated into one cycle. The larger the value in the list, the larger relative size the pattern takes in the final loop. If all values are equal then this is equivalent to fastcat (e.g. the following two code fragments are equivalent). 9d1 $ fastcat [s "bd*4", s "hh27*8", s "superpiano" # n 0] d1 $ timeCat [ (1, s "bd*4") , (1, s "hh27*8") , (1, s "superpiano" # n 0) ]tidal Alias for timeCattidaloverlay combines two ns into a new pattern, so that their events are combined over time. For example, the following two lines are equivalent: d1 $ sound (overlay "bd sn:2" "cp*3") d1 $ sound "[bd sn:2, cp*3]"overlay is equal to , "(<>) :: Semigroup a => a -> a -> a:which can thus be used as an infix operator equivalent of :  d1 $ sound ("bd sn:2" <> "cp*3")tidal combines a list of ns into a new pattern, so that their events are combined over time, i.e., all of the patterns in the list are played simultaneously. d1 $ stack [ sound "bd bd*2", sound "hh*2 [sn cp] cp future*4", sound "arpy" +| n "0 .. 15" ]This is particularly useful if you want to apply a function or synth control pattern to multiple patterns at once: d1 $ whenmod 5 3 (striate 3) $ stack [ sound "bd bd*2", sound "hh*2 [sn cp] cp future*4", sound "arpy" +| n "0 .. 15" ] # speed "[[1 0.8], [1.5 2]*2]/3"tidalShifts a pattern back in time by the given amount, expressed in cyclestidalShifts a pattern forward in time by the given amount, expressed in cyclestidalSlow down a pattern by the factors in the given time pattern, "squeezing" the pattern to fit the slot given in the time pattern. It is the slow analogue to .8If the time pattern only has a single value in a cycle,  slowSqueeze2 becomes equivalent to slow. These are equivalent: d1 $ slow "<2 4>" $ s "bd*8" d1 $ slowSqueeze "<2 4>" $ s "bd*8"When the time pattern has multiple values, however, the behavior is a little different. Instead, a slowed version of the pattern will be made for each value in the time pattern, and they@re all combined together in a cycle according to the structure of the time pattern. For example, these are equivalent: d1 $ slowSqueeze "2 4 8 16" $ s "bd*8" d1 $ s "bd*4 bd*2 bd bd/2" as are these: d1 $ slowSqueeze "2 4 [8 16]" $ s "bd*8" d1 $ s "bd*4 bd*2 [bd bd/2]"tidal An alias for slowtidalPlays 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. 9d1 $ zoom (0.25, 0.75) $ sound "bd*2 hh*3 [sn bd]*2 drum"In the pattern above, zoom< is used with an arc from 25% to 75%. It is equivalent to: d1 $ sound "hh*3 [sn bd]*2"6Here@s an example of it being used with a conditional: d1 $ every 4 (zoom (0.25, 0.75)) $ sound "bd*2 hh*3 [sn bd]*2 drum"tidalfastGap is similar to  but maintains its cyclic alignment, i.e., rather than playing the pattern multiple times, it instead leaves a gap in the remaining space of the cycle. 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 1.tidal An alias for fastGaptidalcompress takes a pattern and squeezes it within the specified time span (i.e. the @arc@). The new resulting pattern is a sped up version of the original. 'd1 $ compress (1/4, 3/4) $ s "[bd sn]!"In the above example, the pattern will play in an arc spanning from 25% to 75% of the duration of a cycle. It is equivalent to: d1 $ s "~ [bd sn]! ~"0Another example, where all events are different: /d1 $ compress (1/4, 3/4) $ n (run 4) # s "arpy"It differs from  in that it preserves the original pattern but it speeds up its events so to match with the new time period.tidalHigher 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.It takes three inputs: how often the function should be applied (e.g. 3 to apply it every 3 cycles), the function to be applied, and the pattern you are applying it to. For example: to reverse a pattern every three cycles (and for the other two play it normally) 1d1 $ every 3 rev $ n "0 1 [~ 2] 3" # sound "arpy"Note that if the function you@re applying requires additional parameters itself (such as fast 2 to make a pattern twice as fast), then you@ll need to wrap it in parenthesis, like so: 6d1 $ every 3 (fast 2) $ n "0 1 [~ 2] 3" # sound "arpy"Otherwise, the every function will think it is being passed too many parameters.tidalevery' n o f p is like  every n f p but with an offset of o cycles. For example, every' 3 0 (fast 2)5 will speed up the cycle on cycles 0,3,6,@ whereas every' 3 1 (fast 2). will transform the pattern on cycles 1,4,7,@.2With this in mind, setting the second argument of every' to 0 gives the equivalent every function. For example, every 3 is equivalent to every' 3 0.The every functions can be used to silence a full cycle or part of a cycle by using silent or mask "~". Mask provides additional flexibility to turn on/off individual steps. d1 $ every 3 silent $ n "2 9 11 2" # s "hh27" d1 $ every 3 (mask "~") $ n "2 9 10 2" # s "hh27" d1 $ every 3 (mask "0 0 0 0") $ n "2 9 11 2" # s "hh27"tidalfoldEvery ns f p applies the function f to p%, and is applied for each cycle in ns.#It is similar to chaining multiple every functions together. It transforms a pattern with a function, once per any of the given number of cycles. If a particular cycle is the start of more than one of the given cycle periods, then it it applied more than once. 3d1 $ foldEvery [5,3] (|+ n 1) $ s "moog" # legato 1The first moog samples are tuned to C2, C3 and C4. Note how on cycles that are multiples of 3 or 5 the pitch is an octave higher, and on multiples of 15 the pitch is two octaves higher, as the transformation is applied twice.tidal1The given pattern transformation is applied only when! the given test function returns True. The test function will be called with the current cycle as a number. d1 $ when (elem '4' . show) (striate 4) $ sound "hh hc"The above will only apply  striate 4 to the pattern if the current cycle number contains the number 4. So the fourth cycle will be striated and the fourteenth and so on. Expect lots of striates after cycle number 399.tidalLike , but works on continuous time values rather than cycle numbers. The following will apply  # speed 2* only when the remainder of the current Time divided by 2 is less than 0.5: d1 $ whenT ((< 0.5) . (flip Data.Fixed.mod' 2)) (# speed 2) $ sound "hh(4,8) hc(3,8)"  Safe-Inferred]tidalchordate cs m n selects the n>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  * pcThe  chordTable function outputs a list of all available chords and their corresponding notes. For example, its first entry is ("major",[0,4,7]) which means that a major triad is formed by the root (0), the major third (4 semitones above the root), and the perfect fifth (7 semitones above the root).-As the list is big, you can use the function .If you know the notes from a chord, but can@t find the name of it, you can use this Haskell code to do a reverse look up into the table: )filter (\(_,x)->x==[0,4,7,10]) chordTableThis will output [("dom7",[0,4,7,10])](You@ll need to run import Sound.Tidal.Chords before using this function.)tidalLook up a specific chord: chordL "minor7" returns (0>1)|[0,3,7,10].tidal!Outputs all the available chords: major maj M aug plus sharp5 six 6 sixNine six9 sixby9 6by9 major7 maj7 major9 maj9 add9 major11 maj11 add11 major13 maj13 add13 dom7 dom9 dom11 dom13 sevenFlat5 7f5 sevenSharp5 7s5 sevenFlat9 7f9 nine eleven 11 thirteen 13 minor min m diminished dim minorSharp5 msharp5 mS5 minor6 min6 m6 minorSixNine minor69 min69 minSixNine m69 mSixNine m6by9 minor7flat5 minor7f5 min7flat5 min7f5 m7flat5 m7f5 minor7 min7 m7 minor7sharp5 minor7s5 min7sharp5 min7s5 m7sharp5 m7s5 minor7flat9 minor7f9 min7flat9 min7f9 m7flat9 m7f9 minor7sharp9 minor7s9 min7sharp9 min7s9 m7sharp9 m7s9 diminished7 dim7 minor9 min9 m9 minor11 min11 m11 minor13 min13 m13 minorMajor7 minMaj7 mmaj7 one 1 five 5 sus2 sus4 sevenSus2 7sus2 sevenSus4 7sus4 nineSus4 ninesus4 9sus4 sevenFlat10 7f10 nineSharp5 9sharp5 9s5 minor9sharp5 minor9s5 min9sharp5 min9s5 m9sharp5 m9s5 sevenSharp5flat9 7s5f9 minor7sharp5flat9 m7sharp5flat9 elevenSharp 11s minor11sharp m11sharp m11s (You@ll need to run import Sound.Tidal.Chords before using this function.)tidalTurns a given pattern of some  type, a pattern of chord names, and a list of patterns of modifiers into a chord pattern??  Safe-Inferred2tidalThe 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/tidal)Start cycles from the given cycle number. &setCycle 5 d1 $ n "6 2 0 8" # s "east"!!  Safe-Inferredtidal Another mode of major pentatonictidal Another mode of major pentatonictidalInterprets a pattern of note numbers into a particular named scale. For example: d1 $ jux rev $ chunk 4 (fast 2 . (|- n 12)) $ off 0.25 (|+ 7) $ struct (iter 4 "t(5,8)") $ n (scale "ritusen" "0 .. 7") # sound "superpiano"tidalBuild a scale function, with additional scales if you wish. For example: let myscale = getScale ( scaleTable ++ [ ("techno", [0,2,3,5,7,8,10]) , ("broken", [0,1,4,7,8,10]) ] )The above takes the standard  as a starting point and adds two custom scales to it. You@ll be able to use the new function in place of the normal one: d1 $ n (myscale "techno" "0 1 2 3 4 5 6 7") # sound "superpiano"tidal.Outputs this list of all the available scales: minPent majPent ritusen egyptian kumai hirajoshi iwato chinese indian pelog prometheus scriabin gong shang jiao zhi yu whole wholetone augmented augmented2 hexMajor7 hexDorian hexPhrygian hexSus hexMajor6 hexAeolian major ionian dorian phrygian lydian mixolydian aeolian minor locrian harmonicMinor harmonicMajor melodicMinor melodicMinorDesc melodicMajor bartok hindu todi purvi marva bhairav ahirbhairav superLocrian romanianMinor hungarianMinor neapolitanMinor enigmatic spanish leadingWhole lydianMinor neapolitanMajor locrianMajor diminished octatonic diminished2 octatonic2 messiaen1 messiaen2 messiaen3 messiaen4 messiaen5 messiaen6 messiaen7 chromatic bayati hijaz sikah rast saba iraq tidalOutputs a list of all available scales and their corresponding notes. For example, its first entry is ("minPent",[0,3,5,7,10]) which means that a minor pentatonic scale is formed by the root (0), the minor third (3 semitones above the root), the perfect fourth (5 semitones above the root), etc.As the list is big, you can use the Haskell function lookup to look up a specific scale: lookup "phrygian" scaleTable. This will output #Just [0.0,1.0,3.0,5.0,7.0,8.0,10.0].You can also do a reverse lookup into the scale table. For example: 4filter ( \(_, x) -> take 3 x == [0,2,4] ) scaleTableThe above example will output all scales of which the first three notes are the root, the major second (2 semitones above the fundamental), and the major third (4 semitones above the root). Safe-InferredtidalGroup multiple params into one.tidal is made with cyclic lists in mind, but it can even "cycle" through infinite lists.tidalA wrapper for 4 that accepts a `[Double]` rather than a `[Value]`.tidalA wrapper for 4 that accepts a `[String]` rather than a `[Value]`.tidalgrain' is a shortcut to join a begin and endThese are equivalent: d1 $ slow 2 $ s "bev" # grain' "0.2:0.3" # legato 1 d1 $ slow 2 $ s "bev" # begin 0.2 # end 0.3 # legato 1tidalA pattern of numbers that speed up (or slow down) samples while they play.In the following example, the sound starts at the original pitch and gets higher as it plays: d1 $ s "arpy" # accelerate 2You can use a negative number to make the sound get lower. In this example, a different acceleration is applied to each played note using state values: d1 $ arp "up" $ note "c'maj'4" # s "arpy" # accelerateTake "susan" [0.2,1,-1]tidal3Controls the amplitude (volume) of the sound. Like %, but linear. Default value is 0.4. #d1 $ s "arpy" # amp "<0.4 0.8 0.2>"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.tidalbegin receives a pattern of numbers from 0 to 1 and skips the beginning of each sample by the indicated proportion. I.e., 0 would play the sample from the start, 1 would skip the whole sample, and 0.25 would cut off the first quarter.In this example, the first 3 ade samples are played on every cycle, but the start point from which they are played changes on each cycle: ?d1 $ n "0 1 2" # s "ade" # begin "<0 0.25 0.5 0.75>" # legato 1tidalSpectral 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 combtidaltidalA control pattern; setcps is the standalone function.Patterns don@t (yet) have independent tempos though, if you change it on one pattern, it changes on all of them. 6p "cpsfun" $ s "bd sd(3,8)" # cps (slow 8 $ 0.5 + saw)tidalbit 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 Similar to , but cuts the end off samples, shortening them; e.g. 0.75 to cut off the last quarter of each sample. .d1 $ s "bev" >| begin 0.5 >| end "[0.65 0.55]"The example above will play the sample two times for cycle, but the second time will play a shorter segment than the first time, creating a kind of canon effect.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 shiftertidalUsed to control the amplitude (volume) of the sound. Values less than 1 make the sound quieter and values greater than 1 make the sound louder.gain uses a power function, so the volume change around 1 is subtle, but it gets more noticeable as it increases or decreases. Typical values for gain are between 0 and 1.5.For the linear equivalent, see . d1 $ s "arpy" # gain 0.8This plays the first arpy sample at a quieter level than the default. ,d1 $ s "ab*16" # gain (range 0.8 1.3 $ sine)5This plays a hihat sound, 16 times per cycle, with a gain. moving from 0.8 to 1.3 following a sine wave.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 filtertidaltidal tidal tidal 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 tidalA pattern of numbers. Specifies whether the pitch of played samples should be tuned relative to their pitch metadata, if it exists. When set to 1, pitch metadata is applied. When set to 0, pitch metadata is ignored. tidal tidal tidal tidal tidal tidal tidal tidalOr to enjoy a randomised speed from 0.5 to 1.5, add 0.5 to it: (d1 $ sound "arpy*4" # speed (rand + 0.5)+To make the snares randomly loud and quiet: sound "sn sn ~ sn" # gain randNumbers coming from this pattern are 'seeded' by time. So if you reset time (using  resetCycles, setCycle, or cps) the random pattern will emit the exact same _random_ numbers again.In cases where you need two different random patterns, you can shift one of them around to change the time from which the _random_ pattern is read, note the difference: 2jux (# gain rand) $ sound "sn sn ~ sn" # gain rand=and with the juxed version shifted backwards for 1024 cycles: jux (# ((1024 <~) $ gain rand)) $ sound "sn sn ~ sn" # gain randtidalBoolean rand - a continuous stream of true/false values, with a 50/50 chance.tidal-Boolean rand with probability as input, e.g.  brandBy 0.25 produces trues 25% of the time.tidal Just like  but for whole numbers, irand n? generates a pattern of (pseudo-) random whole numbers between 0 to n-1 inclusive. Notably used to pick a random samples from a folder: ,d1 $ segment 4 $ n (irand 5) # sound "drum" tidal%1D Perlin (smooth) noise, works like 6 but smoothly moves between random values each cycle.  perlinWith takes a pattern as the random number generator's "input" instead of automatically using the cycle count. 7d1 $ s "arpy*32" # cutoff (perlinWith (saw * 4) * 2000)will generate a smooth random pattern for the cutoff frequency which will repeat every cycle (because the saw does).The  function uses the cycle count as input and can be used much like rand.tidalAs * with a suitable choice of input pattern ( ).The perlin function produces a new random value to move to every cycle. If you want a new random value to be generated more or less frequently, you can use fast or slow, respectively: d1 $ sound "bd*32" # speed (fast 4 $ perlin + 0.5) d1 $ sound "bd*32" # speed (slow 4 $ perlin + 0.5)tidal perlin2With is Perlin noise with a 2-dimensional input. This can be useful for more control over how the randomness repeats (or doesn't). d1 $ s "[supersaw:-12*32]" # lpf (rangex 60 5000 $ perlin2With (cosine*2) (sine*2)) # lpq 0.3 The above will generate a smooth random cutoff pattern that repeats every cycle without any reversals or discontinuities (because the 2D path is a circle). See also: , which only needs one input because it uses the cycle count as the second input.tidalAs * with a suitable choice of input pattern ( ).tidal.Randomly picks an element from the given list. =sound "superpiano(3,8)" # note (choose ["a", "e", "g", "c"]) plays a melody randomly choosing one of the four notes "a", "e", "g", "c".As with all continuous patterns, you have to be careful to give them structure; in this case choose gives you an infinitely detailed stream of random choices. choose = 'chooseBy' 'rand'tidalGiven a pattern of doubles, chooseBy normalizes them so that each corresponds to an index in the provided list. The returned pattern contains the corresponding elements in the list.It is like choose, but instead of selecting elements of the list randomly, it uses the given pattern to select elements.  = chooseBy %The following results in the pattern "a b c": 'chooseBy "0 0.25 0.5" ["a","b","c","d"]tidalLike choose8, but works on an a list of tuples of values and weights sound "superpiano(3,8)" # note (wchoose [("a",1), ("e",0.5), ("g",2), ("c",1)]) In the above example, the "a" and "c" notes are twice as likely to play as the "e" note, and half as likely to play as the "g" note. wchoose = 'wchooseBy' 'rand'tidal/Given a pattern of probabilities and a list of (value, weight) pairs,  wchooseBy creates a n value by choosing values based on those probabilities and weighted appropriately by the weights in the list of pairs.tidal randcat ps : does a slowcat on the list of patterns ps5 but randomises the order in which they are played. ?d1 $ sound (randcat ["bd*2 sn", "jvbass*3", "drum*2", "ht mt"])tidalAs , but allowing weighted choice.In the following, the first pattern is the most likely and will play about half the time, and the last pattern is the less likely, with only a 10% probability. d1 $ sound $ wrandcat [ ("bd*2 sn", 5), ("jvbass*3", 2), ("drum*2", 2), ("ht mt", 1) ]tidaldegrade8 randomly removes events from a pattern 50% of the time: d1 $ slow 2 $ degrade $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]" # accelerate "-6" # speed "2"The shorthand syntax for degrade is a question mark: ?. Using ? will allow you to randomly remove events from a portion of a pattern: 1d1 $ slow 2 $ sound "bd ~ sn bd ~ bd? [sn bd?] ~"You can also use ?4 to randomly remove events from entire sub-patterns: =d1 $ slow 2 $ sound "[[[feel:5*8,feel*3] feel:3*8]?, feel*4]"tidal Similar to ,  degradeBy allows you to control the percentage of events that are removed. For example, to remove events 90% of the time: d1 $ slow 2 $ degradeBy 0.9 $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]" # accelerate "-6" # speed "2" You can also invoke this behavior in the shorthand notation by specifying a percentage, as a number between 0 and 1, after the question mark: d1 $ s "bd hh?0.8 bd hh?0.4" tidalAs , but the pattern of probabilities represents the chances to retain rather than remove the corresponding element.tidalUse  sometimesBy to apply a given function "sometimes". For example, the following code results in  density 2% being applied about 25% of the time: 1d1 $ sometimesBy 0.25 (density 2) $ sound "bd*8" There are some aliases as well:  = sometimesBy 0.5  = sometimesBy 0.75  = sometimesBy 0.25  = sometimesBy 0.1  = sometimesBy 0.9 tidalAs , but applies the given transformation to the pattern in its entirety before filtering its actual appearances. Less efficient than  but may be useful when the passed pattern transformation depends on properties of the pattern before probabilities are taken into account.  = sometimesBy' 0.5  = sometimesBy' 0.75  = sometimesBy' 0.25  = sometimesBy' 0.1  = sometimesBy' 0.9 tidal sometimes is an alias for  0.5.tidal sometimes' is an alias for  0.5.tidaloften is an alias for  0.75.tidaloften' is an alias for  0.75.tidalrarely is an alias for  0.25.tidalrarely' is an alias for  0.25.tidal almostNever is an alias for  0.1.tidal almostNever' is an alias for  0.1.tidal almostAlways is an alias for  0.9.tidal almostAlways' is an alias for  0.9.tidal?Never apply a transformation, returning the pattern unmodified. never = flip consttidal8Apply the transformation to the pattern unconditionally.  always = idtidal someCyclesBy is a cycle-by-cycle version of .For example the following will either distort all of the events in a cycle, or none of them: d1 $ someCyclesBy 0.5 (# crush 2) $ n "0 1 [~ 2] 3" # sound "arpy"tidal Alias of .tidal  someCycles =  0.5tidal Alias of .tidalbrak makes a pattern sound a bit like a breakbeat. It does this by, every other cycle, squashing the pattern to fit half a cycle, and offsetting it by a quarter of a cycle. d1 $ sound (brak "bd sn kurt") d1 $ brak $ sound "[feel feel:3, hc:3 hc:2 hc:4 ho:1]" 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 5, which shifts the pattern in the opposite direction.tidaliter' is the same as iter, but decrements the starting subdivision instead of incrementing it. For example, #d1 $ iter' 4 $ sound "bd hh sn cp" produces 0bd hh sn cp cp bd hh sn sn cp bd hh hh sn cp bd tidal palindrome p applies rev to p every other cycle, so that the pattern alternates between forwards and backwards. For example, these are equivalent: d1 $ palindrome $ sound "arpy:0 arpy:1 arpy:2 arpy:3" d1 $ slow 2 $ sound "arpy:0 arpy:1 arpy:2 arpy:3 arpy:3 arpy:2 arpy:1 arpy:0" d1 $ every 2 rev $ sound "arpy:0 arpy:1 arpy:2 arpy:3" 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 True or False.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. > d1 $ wedge (1/4) (sound "bd*2 arpy*3 cp sn*2") (sound "odx [feel future]*2 hh hh")tidalwhenmod$ has a similar form and behavior to , but requires an additional number. It 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: 1d1 $ whenmod 8 4 (density 2) (sound "bd sn kurt")tidal  superimpose f p = stack [p, f p] superimpose 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. The following are equivalent: d1 $ superimpose (fast 2) $ sound "bd sn [cp ht] hh" d1 $ stack [sound "bd sn [cp ht] hh", fast 2 $ sound "bd sn [cp ht] hh" ]More examples: 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: ;d1 $ trunc 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"You can also pattern the first parameter, for example to cycle through three values, one per cycle: 7d1 $ trunc "<0.75 0.25 1>" $ sound "bd sn:2 [mt rs] hc"tidallinger is similar to , in that it truncates a pattern so that only the first fraction of the pattern is played, but the truncated part of the pattern loops to fill the remainder of the cycle. or slightly more interesting, applied only every fourth cycle: ;d1 $ every 4 (linger 0.25) $ n "0 2 [3 4] 2" # sound "arpy"or to a chopped-up sample: d1 $ every 2 (linger 0.25) $ loopAt 2 $ chop 8 $ sound "breaks125"You can also pattern the first parameter, for example to cycle through three values, one per cycle: d1 $ linger "<0.75 0.25 1>" $ sound "bd sn:2 [mt rs] hc" d1 $ linger "<0.25 0.5 1>" $ loopAt 2 $ chop 8 $ sound "breaks125"If you give it a negative number, it will linger on the last part of the pattern, instead of the start of it. E.g. to linger on the last quarter: ?d1 $ linger (-0.25) $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"tidalUse within to apply a function to only a part of a pattern. It takes two arguments: a start time and an end time, specified as floats between 0 and 1, which are applied to the relevant pattern. Note that the second argument must be greater than the first for the function to have any effect.For example, to apply  2% to only the first half of a pattern: d1 $ within (0, 0.5) (fast 2) $ sound "bd*2 sn lt mt hh hh hh hh" Or, to apply (# speed "0.5")' to only the last quarter of a pattern: d1 $ within (0.75, 1) (# speed "0.5") $ sound "bd*2 sn lt mt hh hh hh hh"tidalFor many cases, within' will function exactly as within. The difference between the two occurs when applying functions that change the timing of notes such as  or . within first applies the function to all notes in the cycle, then keeps the results in the specified interval, and then combines it with the old cycle (an "apply split combine" paradigm). within' first keeps notes in the specified interval, then applies the function to these notes, and then combines it with the old cycle (a "split apply combine" paradigm).9For example, whereas using the standard version of within 4d1 $ within (0, 0.25) (fast 2) $ sound "bd hh cp sd" sounds like: d1 $ sound "[bd hh] hh cp sd"'using this alternative version, within' 5d1 $ within' (0, 0.25) (fast 2) $ sound "bd hh cp sd" sounds like: d1 $ sound "[bd bd] hh cp sd"tidal2Reverse the part of the pattern sliced out by the  (start, end) pair. revArc a = within a revtidalYou can use the euclid function to apply a Euclidean algorithm over a complex pattern, although the structure of that pattern will be lost: &d1 $ euclid 3 8 $ sound "bd*2 [sn cp]"In the above, three sounds are picked from the pattern on the right according to the structure given by the  euclid 3 8. It ends up picking two bd sounds, a cp and missing the sn entirely.A negative first argument provides the inverse of the euclidean pattern.These types of sequences use "Bjorklund's algorithm", which wasn't made for music but for an application in nuclear physics, which is exciting. More exciting still is that it is very similar in structure to the one of the first known algorithms written in Euclid's book of elements in 300 BC. You can read more about this in the paper  8http://cgm.cs.mcgill.ca/~godfried/publications/banff.pdf=The Euclidean Algorithm Generates Traditional Musical Rhythms by Toussaint. Some examples from this paper are included below, including rotation as a third parameter in some cases (see ).PatternExample(2,5):A thirteenth century Persian rhythm called Khafif-e-ramal.(3,4) The archetypal pattern of the Cumbia from Colombia, as well as a Calypso rhythm from Trinidad.(3,5,2) Another thirteenth century Persian rhythm by the name of Khafif-e-ramal, as well as a Rumanian folk-dance rhythm.(3,7)3A Ruchenitza rhythm used in a Bulgarian folk-dance.(3,8)The Cuban tresillo pattern.(4,7)/Another Ruchenitza Bulgarian folk-dance rhythm.(4,9)The Aksak rhythm of Turkey.(4,11) The metric pattern used by Frank Zappa in his piece titled Outside Now.(5,6)5Yields the York-Samai pattern, a popular Arab rhythm.(5,7)2The Nawakhat pattern, another popular Arab rhythm.(5,8)The Cuban cinquillo pattern.(5,9))A popular Arab rhythm called Agsag-Samai.(5,11) The metric pattern used by Moussorgsky in Pictures at an Exhibition.(5,12)>The Venda clapping pattern of a South African children@s song.(5,16))The Bossa-Nova rhythm necklace of Brazil.(7,8)3A typical rhythm played on the Bendir (frame drum).(7,12)#A common West African bell pattern. (7,16,14)$A Samba rhythm necklace from Brazil.(9,16)7A rhythm necklace used in the Central African Republic. (11,24,14)7A rhythm necklace of the Aka Pygmies of Central Africa. (13,24,5)?Another rhythm necklace of the Aka Pygmies of the upper Sangha.There was once a shorter alias e for this function. It has been removed, but you may see references to it in older Tidal code.tidaleuclidFull n k pa pb stacks  n k pa with  n k pb. That is, it plays one pattern on the euclidean rhythm and a different pattern on the off-beat.For example, to implement the traditional flamenco rhythm, you could use hard claps for the former and soft claps for the latter: 8d1 $ euclidFull 3 7 "realclaps" ("realclaps" # gain 0.8)tidalLess expressive than 9 due to its constrained types, but may be more efficient.tidalAs , but taking a third rotational parameter corresponding to the onset at which to start the rhythm.tidalA shorter alias for .tidalAs , but specialized to . May be more efficient than .tidal euclidInv fills in the blanks left by , i.e., it inverts the pattern.For example, whereas euclid 3 8 "x" produces "x ~ ~ x ~ ~ x ~"euclidInv 3 8 "x" produces "~ x x ~ x x ~ x"As another example, in d1 $ stack [ euclid 5 8 $ s "bd" , euclidInv 5 8 $ s "hh27" ]the hi-hat event fires on every one of the eight even beats that the bass drum does not.tidalrot n p# "rotates" the values in a pattern p by n beats to the left, preserving its structure. For example, in the following, each value will shift to its neighbour's position one step to the left, so that b takes the place of a, a of c, and c of b: rot 1 "a ~ b c"The result is equivalent of:  "b ~ c a"The first parameter is the number of steps, and may be given as a pattern. For example, in ;d1 $ rot "<0 0 1 3>" $ n "0 ~ 1 2 0 2 ~ 3*2" # sound "drum"the pattern will not be rotated for the first two cycles, but will rotate it by one the third cycle, and by three the fourth cycle.Additional example: 3d1 $ every 4 (rot 2) $ slow 2 $ sound "bd hh hh hh"tidalCalculates a whole cycle, rotates it, then constrains events to the original query arc.tidal segment n p @samples@ the pattern p at a rate of n events per cycle. Useful for turning a continuous pattern into a discrete one.In the following example, the pattern originates from the shape of a sine wave, a continuous pattern. Without segment, the samples will get triggered at an undefined frequency which may be very high. d1 $ n (slow 2 $ segment 16 $ range 0 32 $ sine) # sound "amencutup"tidal discretise : the old (deprecated) name for 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.The following are equivalent: ?d1 $ struct ("t ~ t*2 ~") $ sound "cp" d1 $ sound "cp ~ cp*2 ~"The structure comes from a boolean pattern, i.e. a binary pattern containing true or false values. Above we only used true values, denoted by t4. It@s also possible to include false values with f, which struct will simply treat as silence. For example, this would have the same outcome as the above: &d1 $ struct ("t f t*2 f") $ sound "cp"These true / false binary patterns become useful when you conditionally manipulate them, for example, @inverting@ the values using  and : 2d1 $ struct (every 3 inv "t f t*2 f") $ sound "cp"In the above, the boolean values will be @inverted@ every third cycle, so that the structure comes from the fs rather than t. Note that euclidean patterns also create true/false values, for example: /d1 $ struct (every 3 inv "t(3,8)") $ sound "cp",In the above, the euclidean pattern creates "t f t f t f f t" which gets inverted to "f t f t f t t f" every third cycle. Note that if you prefer you can use 1 and 0 instead of t and f.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, i.e., the first parameter gives the number of cycles to operate over. So, it is similar to fast), but with random durations. For example stripe 2- will repeat a pattern twice, over two cyclesIn the following example, the start of every third repetition of the d1) pattern will match with the clap on the d2 pattern. 7d1 $ stripe 3 $ sound "bd sd ~ [mt ht]" d2 $ sound "cp"The repetitions will be contiguous (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 is 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.It takes an integer b, a Lindenmayer system rule set, and an initiating string as input in order to generate an L-system tree string of b iterations. It can be used in conjunction with a step function to convert the generated string into a playable pattern. For example, d1 $ slow 16 $ sound $ step' ["feel:0", "sn:1", "bd:0"] ( take 512 $ lindenmayer 5 "0:1~~~,1:0~~~2~~~~~0~~~2~,2:2~1~,~:~~1~" "0" )-generates an L-system with initiating string "0"& and maps it onto a list of samples.Complex L-system trees with many rules and iterations can sometimes result in unwieldy strings. Using take n to only use the first n& elements of the string, along with a 9 function, can make the generated values more manageable.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. tidalmarkovPat n xi tp" generates a one-cycle pattern of n- steps in a Markov chain starting from state xi with transition matrix tp. Each row of the transition matrix is automatically normalized. For example:)markovPat 8 1 [[3,5,2], [4,4,2], [0,1,0]](0>B)|1(B>)|2(>B)|1(B>)|1(>B)|2(B>)|1(>B)|1(B>1)|0tidalmask takes a boolean pattern and @masks@ another pattern with it. That is, events are only carried over if they match within a @true@ event in the binary pattern, i.e., it removes events from the second pattern that don't start during an event from the first.For example, consider 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) tidalstretch takes a pattern, and if there@s silences at the start or end of the current cycle, it will zoom in to avoid them. The following are equivalent: d1 $ note (stretch "~ 0 1 5 8*4 ~") # s "superpiano" d1 $ note "0 1 5 8*4" # s "superpiano"You can pattern silences on the extremes of a cycle to make changes to the rhythm: 8d1 $ note (stretch "~ <0 ~> 1 5 8*4 ~") # s "superpiano"tidalfit' 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 fit. 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 fit'" 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 2d1 $ chunk 4 (fast 4) $ sound "cp sn arpy [mt lt]"The following: .d1 $ chunk 4 (# speed 2) $ sound "bd hh sn cp"applies  (# speed 2)+ to the uppercased part of the cycle below: /BD hh sn cp bd HH sn cp bd hh SN cp bd hh sn CPtidalDEPRECATED, use  with negative numbers insteadtidalDEPRECATED, use  with negative numbers insteadtidalinside carries out an operation inside a cycle. For example, while rev "0 1 2 3 4 5 6 7" is the same as "7 6 5 4 3 2 1 0", inside 2 rev "0 1 2 3 4 5 6 7" gives "3 2 1 0 7 6 5 4".What this function is really doing is @slowing down@ the pattern by a given factor, applying the given function to it, and then @speeding it up@ by the same factor. In other words, this: inside 2 rev "0 1 2 3 4 5 6 7"Is doing this: 'fast 2 $ rev $ slow 2 "0 1 2 3 4 5 6 7">so rather than whole cycles, each half of a cycle is reversed.tidaloutside is the inverse of the  function. outside applies its function outside the cycle. Say you have a pattern that takes 4 cycles to repeat and apply the rev function: d1 $ rev $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]The above generates: d1 $ rev $ cat [s "sn bd bd",s "bd sn sn", s "sd lt lt", s "bd sd sd"]However if you apply outside: d1 $ outside 4 (rev) $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]The result is: d1 $ rev $ cat [s "bd sd sd", s "sd lt lt", s "sn sn bd", s "bd bd sn"]Notice that the whole idea has been reversed. What this function is really doing is @speeding up@ the pattern by a given factor, applying the given function to it, and then @slowing it down@ by the same factor. In other words, this: d1 $ slow 4 $ rev $ fast 4 $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]This compresses the idea into a single cycle before rev operates and then slows it back to the original speed.tidalTakes a pattern and loops only the first cycle of the pattern. For example, the following code will only play the bass drum sample: 'd1 $ loopFirst $ s "< cp*4>"This function combines with  to insert events from the first cycle randomly into subsequent cycles of the pattern: 1d1 $ sometimes loopFirst $ s "< cp*4>"tidalseqPLoop8 will keep looping the sequence when it gets to the end: d1 $ qtrigger $ seqPLoop [ (0, 12, sound "bd bd*2") , (4, 12, sound "hh*2 [sn cp] cp future*4") , (8, 12, sound (samples "arpy*8" (run 16))) ]tidaltoScale 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".toScale9 is handy for quickly applying a scale without naming it: d1 $ n (toScale [0,2,3,5,7,8,10] "0 1 2 3 4 5 6 7") # sound "superpiano"This function assumes your scale fits within an octave; if that's not true, use . toScale = toScale' 12tidalAs +, though allowing scales of arbitrary size. An example: $toScale' 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. So if x is 0 it does nothing, 0.5 delays for half the note duration, and 1 will wrap around to doing nothing again. The end result is a shuffle or swing-like rhythm. For example, the following will delay every other "hh" 1/3 of the way to the next "hh": #d1 $ swingBy (1/3) 4 $ sound "hh*8"tidalAs #, with the cycle division set to B.tidal cycleChoose is like ; but only picks a new item from the list once each cycle. 7d1 $ sound "drum ~ drum drum" # n (cycleChoose [0,2,3])tidal/Internal function used by shuffle and scramble tidal 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"1, because that is not a permutation of the parts.9This could also be called @sampling without replacement@.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.6This could also be called @sampling with replacement@.tidal randrun n2 generates a pattern of random integers less than n..The following plays random notes in an octave: +d1 $ s "superhammond!12" # n (fromIntegral  $ randrun 13) tidal 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))) ] tidalThe ur function is designed for longer form composition, by allowing you to create @patterns of patterns@ in a repeating loop. It takes four parameters: how long the loop will take, a pattern giving the structure of the composition, a lookup table for named patterns to feed into that structure, and a second lookup table for named transformations/effects.The ur- prefix  )https://en.wiktionary.org/wiki/ur-#Germancomes from German and means proto- or original. For a mnemonic device, think of this function as assembling a set of original patterns (ur-patterns) into a larger, newer whole.(Lets say you had three patterns (called a, b and c), and that you wanted to play them four cycles each, over twelve cycles in total. Here is one way to do it: let pats = [ ( "a", stack [ n "c4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7" , n "[c3,g4,c4]" # s "superpiano"# gain "0.7" ] ) , ( "b", stack [ n "d4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7" , n "[d3,a4,d4]" # s "superpiano"# gain "0.7" ] ) , ( "c", stack [ n "f4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7" , n "[f4,c5,f4]" # s "superpiano"# gain "0.7" ] ) ] in d1 $ ur 12 "a b c" pats [] In the above, the fourth parameter is given as an empty list, but that is where you can put another lookup table, of functions rather than patterns this time. For example: let pats = ... fx = [ ("reverb", ( # (room 0.8 # sz 0.99 # orbit 1))) , ("faster", fast 2) ] in d1 $ ur 12 "a b:reverb c:faster" pats fx In this example, b8 has the function applied that@s named as reverb, while c is made to go faster. It@s also possible to schedule multiple patterns at once, like in the following: let pats = [ ("drums", s "drum cp*2") , ("melody", s "arpy:2 arpy:3 arpy:5") , ("craziness", s "cp:4*8" # speed ( sine + 0.5 )) ] fx = [("higher", ( # speed 2))] in d1 $ ur 8 "[drums, melody] [drums,craziness,melody] melody:higher" pats fx tidalA simpler version of  that just provides name-value bindings that are reflected in the provided pattern.inhabit% allows you to link patterns to some String, or in other words, to give patterns a name and then call them from within another pattern of Strings.For example, we can make our own bassdrum, hi-hat and snaredrum kit: do let drum = inhabit [ ("bd", s "sine" |- accelerate 1.5) , ("hh", s "alphabet:7" # begin 0.7 # hpf 7000) , ("sd", s "invaders:3" # speed 12) ] d1 $ drum "[bd*8?, [~hh]*4, sd(6,16)]"inhabit can be very useful when using MIDI controlled drum machines, since you can give understandable drum names to patterns of notes.tidal spaceOut xs p repeats a n p< at different durations given by the list of time values in xs. tidalflatpat takes a n4 of lists and pulls the list elements as separate `(s. For example, the following code uses flatpat in combination with  listToPat, to create an alternating pattern of chords: d1 $ n (flatpat $ listToPat [[0,4,7],[(-12),(-8),(-5)]]) # s "superpiano" # sustain 2This code is equivalent to: ;d1 $ n ("[0,4,7] [-12,-8,-5]") # s "superpiano" # sustain 2tidallayer takes a list of n-returning functions and a seed element, stacking the result of applying the seed element to each function in the list.It allows you to layer up multiple functions on one pattern. For example, the following will play two versions of the pattern at the same time, one reversed and one at twice the speed: 2d1 $ layer [rev, fast 2] $ sound "arpy [~ arpy:4]"The original version of the pattern can be included by using the id function: 6d1 $ layer [id, rev, fast 2] $ sound "arpy [~ arpy:4]"tidal 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 arpeggiatetidalThe arp function takes an additional pattern of arpeggiate modes. For example: "d1 $ sound "superpiano" # n (arp " up down diverge" " a'm9'8 e'7sus4'8") $The different arpeggiate modes are:  up down updown downup up&down down&up converge diverge disconverge pinkyup pinkyupdown thumbup thumbupdown tidalrolled plays each note of a chord quickly in order, as opposed to simultaneously; to give a chord a harp-like or strum effect.Notes are played low to high, and are evenly distributed within (1/4) of the chord event length, as opposed to arp6arpeggiate that spread the notes over the whole event.  rolled $ n "cmaj4" # s "superpiano" rolled = rolledBy (1/4)tidalply n repeats each event n times within its arc.*For example, the following are equivalent: d1 $ ply 3 $ s "bd ~ sn cp" d1 $ s "[bd bd bd] ~ [sn sn sn] [cp cp cp]" The first parameter may be given as a pattern, so that the following are equivalent: d1 $ ply "2 3" $ s "bd ~ sn cp" d1 $ s "[bd bd] ~ [sn sn sn] [cp cp cp]" 2Here is an example of it being used conditionally: &d1 $ every 3 (ply 4) $ s "bd ~ sn cp" tidalAs , but applies a function each time. The applications are compounded.tidalSyncopates a rhythm, shifting (delaying) each event halfway into its arc (timespan).In mini-notation terms, it basically turns every instance of a into [~ a] , e.g.,  "a b [c d] e" becomes the equivalent of !"[~ a] [~ b] [[~ c] [~ d]] [~ e]". Every beat then becomes an offbeat, and so the overall effect is to syncopate a pattern.In the following example, you can hear that the piano chords play between the snare and the bass drum. In 4/4 time, they are playing in the 2 and a half, and 4 and a half beats: do resetCycles d1 $ stack [ press $ n "~ c'maj ~ c'maj" # s "superpiano" # gain 0.9 # pan 0.6, s "[bd,clap sd bd sd]" # pan 0.4 ] # cps (90/60/4)In the next example, the C major chord plays before the G major. As the slot that occupies the C chord is that of one eighth note, it is displaced by press only a sixteenth note: do resetCycles d1 $ stack [ press $ n "~ [c'maj ~] ~ ~" # s "superpiano" # gain 0.9 # pan 0.6, press $ n "~ g'maj ~ ~" # s "superpiano" # gain 0.9 # pan 0.4, s "[bd,clap sd bd sd]" ] # cps (90/60/4)tidalLike press, but allows you to specify the amount in which each event is shifted as a float from 0 to 1 (exclusive). pressBy 0.5 is the same as press, while  pressBy (1/3)+ shifts each event by a third of its arc.You can pattern the displacement to create interesting rhythmic effects: d1 $ stack [ s "bd sd bd sd", pressBy "<0 0.5>" $ s "co:2*4" ] d1 $ stack [ s "[bd,co sd bd sd]", pressBy "<0 0.25 0.5 0.75>" $ s "cp" ]tidalUses the first (binary) pattern to switch between the following two patterns. The resulting structure comes from the binary pattern, not the source patterns. (In , by contrast, the resulting structure comes from the source patterns.)6The following uses a euclidean pattern to control CC0: 3d1 $ ccv (stitch "t(7,16)" 127 0) # ccn 0 # "midi"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.tidalstutter n t pat repeats each event in pat n times, separated by t, time (in fractions of a cycle). It is like $ that doesn't reduce the volume, or  if you controlled the timing. !d1 $ stutter 4 (1/16) $ s "bd cp"is functionally equivalent to  d1 $ stut 4 1 (1/16) $ s "bd cp"tidalThe jux 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:  Pattern Int -> Pattern String. samples = liftA2 picktidalEquivalent to +, though the sample specifier pattern (the f Int) will be evaluated first. Not a large difference in the majority of cases.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)The above is equivalent to: d1 $ jux (iter 4) $ sound "arpy arpy:2*2" |+ speed (slow 4 $ sine1 * 0.5 + 1)tidal is an exponential version of 0, good for using with frequencies. For example, range 20 2000 "0.5" will give 1010 - halfway between 20 and 2000. But rangex 20 2000 0.5 will give 200 - halfway between on a logarithmic scale. This usually sounds better if you@re using the numbers as pitch frequencies. Since rangex uses logarithms, don@t try to scale things to zero or less.tidaloff is similar to , in that it applies a function to a pattern and layers up the results on top of the original pattern. The difference is that off takes an extra pattern being a time (in cycles) to shift the transformed version of the pattern by.The following plays a pattern on top of itself, but offset by an eighth of a cycle, with a distorting bitcrush effect applied: 8d1 $ off 0.125 (# crush 2) $ sound "bd [~ sn:2] mt lt*2"The following makes arpeggios by adding offset patterns that are shifted up the scale: d1 $ slow 2 $ n (off 0.25 (+12) $ off 0.125 (+7) $ slow 2 "c(3,8) a(3,8,2) f(3,8) e(3,8,4)") # sound "superpiano"tidalstep acts as a kind of simple step-sequencer using strings. For example, step "sn" "x x 12"2 is equivalent to the pattern of strings given by "sn ~ sn ~ sn:1 sn:2 ~". step' substitutes the given string for each x, for each number it substitutes the string followed by a colon and the number, and for everything else it puts in a rest.In other words, step generates a pattern of strings in exactly the syntax you@d want for selecting samples and that can be fed directly into the s function. d1 $ s (step "sn" "x x 12 ")tidalsteps is like step but it takes a list of pairs, like step would, and it plays them all simultaneously. 7d1 $ s (steps [("cp","x x x x x x"),("bd", "xxxx")])tidallike ;, but allows you to specify an array of strings to use for 0,1,2... For example, d1 $ s (step' ["superpiano","supermandolin"] "0 1 000 1") # sustain 4 # n 0is equivalent to d1 $ s "superpiano ~ supermandolin ~ superpiano!3 ~ supermandolin" # sustain 4 # n 0tidal*Deprecated backwards-compatible alias for .tidalLike , but a user-supplied function describes how to alter the pattern.In this example, ghost notes are applied to the snare hit, but these notes will be louder, not quieter, and the sample will have its beginning slightly cut: d1 $ slow 2 $ ghostWith (1/16) ((|*| gain 1.1) . (|> begin 0.05)) $ sound "sn"tidalAs , but with the copies set to appear one-eighth of a cycle afterwards. ghost = ghost' 0.125The following creates a kick snare pattern with ghost notes applied to the snare hit: 8d1 $ stack [ ghost $ sound "~ sn", sound "bd*2 [~ bd]" ]tidal A more literal weaving than the weave function. Given tabby threads p1 p, parameters representing the threads per cycle and the patterns to weave, and this function will weave them together using a plain (aka @tabby@) weave, with a simple over/under structuretidalChooses from a list of patterns, using a pattern of floats (from 0 to 1).tidalChooses from a list of functions, using a pattern of floats (from 0 to 1).tidal>Chooses from a list of functions, using a pattern of integers.tidalcontrast f f' p p' splits the control pattern p'! in two, applying the function f to one and f'3 to the other. This depends on whether events in p'' contain values matching with those in p. For example, in contrast (# crush 3) (# vowel "a") (n "1") $ n "0 1" # s "bd sn" # speed 3the first event will have the vowel effect applied and the second will have the crush applied.contrast1 is like an if-else-statement over patterns. For contrast t f p you can think of t as the true branch, f as the false branch, and p as the test.=You can use any control pattern as a test of equality, e.g., n " 01", speed "0.5", or things like that. This lets you choose specific properties of the pattern you@re transforming for testing, like in the following example, d1 $ contrast (|+ n 12) (|- n 12) (n "c") $ n (run 4) # s "superpiano"where every note that isn@t middle-c will be shifted down an octave but middle-c will be shifted up to c5.Since the test given to contrast is also a pattern, you can do things like have it alternate between options: d1 $ contrast (|+ n 12) (|- n 12) (s "") $ s "superpiano superchip" # n 0If you listen to this you@ll hear that which instrument is shifted up and which instrument is shifted down alternates between cycles.tidal contrastBy) is contrastBy is the general version of , in which you can specify an abritrary boolean function that will be used to compare the control patterns. d2 $ contrastBy (>=) (|+ n 12) (|- n 12) (n "2") $ n "0 1 2 [3 4]" # s "superpiano"tidalThe fix function applies another function to matching events in a pattern of controls. fix is = where the false-branching function is set to the identity  . It is like , but one function is given and applied to events with matching controls.)For example, the following only adds the crush control when the n# control is set to either 1 or 4: d1 $ slow 2 $ fix (# crush 3) (n "[1,4]") $ n "0 1 2 3 4 5 6" # sound "arpy"You can be quite specific; for example, the following applies the function hurry 2 to sample 1 of the drum sample set, and leaves the rest as they are:  fix (hurry 2) (s "drum" # n "1")tidalLike , but one function is given, and applied to events with controls which don't match. unfix is / but only applies when the testing pattern is not a match.tidalThe fixRange function isn@t very user-friendly at the moment, but you can create a fix0 variant with a range condition. Any value of a m: wich matches the values will apply the passed function. d1 $ ( fixRange ( (# distort 1) . (# gain 0.8) ) ( pure $ Map.singleton "note" ((VN 0, VN 7)) ) ) $ s "superpiano" <| note "1 12 7 11"tidalquantise2 limits values in a Pattern (or other Functor) to n equally spaced divisions of 1.It is useful for rounding a collection of numbers to some particular base fraction. For example, "quantise 5 [0, 1.3 ,2.6,3.2,4.7,5],It will round all the values to the nearest  (1/5)=0.2 and thus will output the list [0.0,1.2,2.6,3.2,4.8,5.0]. You can use this function to force a continuous pattern like sine into specific values. In the following example: d1 $ s "superchip*8" # n (quantise 1 $ range (-10) (10) $ slow 8 $ cosine) # release (quantise 5 $ slow 8 $ sine + 0.1)4all the releases selected be rounded to the nearest 0.1' and the notes selected to the nearest 1.quantise3 with fractional inputs does the consistent thing:  quantise 0.5 rounds values to the nearest 2,  quantise 0.25 rounds the nearest 4, etc.tidalAs  , but uses  to calculate divisions.tidalAs  , but uses  to calculate divisions.tidal An alias for .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.tidalsmooth receives a pattern of numbers and linearly goes from one to the next, passing through all of them. As time is cycle-based, after reaching the last number in the pattern, it will smoothly go to the first one again. 5d1 $ sound "bd*4" # pan (slow 4 $ smooth "0 1 0.5 1")This sound will pan gradually from left to right, then to the center, then to the right again, and finally comes back to the left.tidalLooks up values from a list of tuples, in order to swap values in the given patterntidalsnowball2 takes a function that can combine patterns (like 0), a function that transforms a pattern (like ), a depth, and a starting pattern, it will then transform the pattern and combine it with the last transformation until the depth is reached. This is like putting an effect (like a filter) in the feedback of a delay line; each echo is more affected. d1 $ note ( scale "hexDorian" $ snowball 8 (+) (slow 2 . rev) "0 ~ . -1 . 5 3 4 . ~ -2" ) # s "gtr"tidalApplies a function to a pattern and cats the resulting pattern, then continues applying the function until the depth is reached this can be used to create a pattern that wanders away from the original pattern by continually adding random numbers. d1 $ note ( scale "hexDorian" mutateBy (+ (range -1 1 $ irand 2)) 8 $ "0 1 . 2 3 4" ) # s "gtr"tidal construct n p breaks p= into pieces and then reassembles them so that it fits into n steps.tidalbite n ipat pat slices a pattern pat into n pieces, then uses the ipat4 pattern of integers to index into those slices. So bite 4 "0 2*2" (run 8) is the same as "[0 1] [4 5]*2".I.e., it allows you to slice each cycle into a given number of equal sized bits, and then pattern those bits by number. It@s similar to slice, but is for slicing up patterns, rather than samples. The following slices the pattern into four bits, and then plays those bits in turn: 1d1 $ bite 4 "0 1 2 3" $ n "0 .. 7" # sound "arpy"Of course that doesn@t actually change anything, but then you can reorder those bits: 1d1 $ bite 4 "2 0 1 3" $ n "0 .. 7" # sound "arpy"The slices bits of pattern will be squeezed or contracted to fit: 7d1 $ bite 4 "2 [0 3] 1*4 1" $ n "0 .. 7" # sound "arpy"tidal=Chooses from a list of patterns, using a pattern of integers.tidalchew works the same as , but speeds up/slows down playback of sounds as well as squeezing/contracting the slices of the provided pattern. Compare: d1 $ 'bite' 4 "0 1*2 2*2 [~ 3]" $ n "0 .. 7" # sound "drum" d1 $ chew 4 "0 1*2 2*2 [~ 3]" $ n "0 .. 7" # sound "drum"tidalGiven a start point and a duration (both specified in cycles), this generates a control pattern that makes a sound begin at the start point and last the duration.The following are equivalent: d1 $ slow 2 $ s "bev" # grain 0.2 0.1 # legato 1 d1 $ slow 2 $ s "bev" # begin 0.2 # end 0.3 # legato 1grain is defined as: grain s d = 'Sound.Tidal.Params.begin' s # 'Sound.Tidal.Params.end' (s+d)tidalFor 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 ")*69tidalAST representation of patterns Safe-Inferred"!tidal will "spin" and 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 work well on multichannel systems. d1 $ slow 3 $ spin 4 $ sound "drum*3 tabla:4 [arpy:2 ~ arpy] [can:2 can:3]"tidal granularises every sample in place as it is played, turning a pattern of samples into a pattern of sample parts. Can be used to explore granular synthesis.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 chop 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]"You can also use chop (or ) with very long samples to cut them into short chunks and pattern those chunks. The following cuts a sample into 32 parts, and plays it over 8 cycles: %d1 $ loopAt 8 $ chop 32 $ sound "bev"The  takes care of changing the speed of sample playback so that the sample fits in the given number of cycles perfectly. As a result, in the above the granules line up perfectly, so you can@t really hear that the sample has been cut into bits. Again, this becomes more apparent when you do further manipulations of the pattern, for example + to reverse the order of the cut up bits: +d1 $ loopAt 8 $ rev $ chop 32 $ sound "bev"tidalStriate is a kind of granulator, cutting samples into bits in a similar to chop, but the resulting bits are organised differently. For example: (d1 $ striate 3 $ sound "ho ho:2 ho:3 hc"This plays the loop the given number of times, but triggers 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, and lastly playing the last third of each sample. Replacing striate with  above, one can hear that the ' version plays the bits from each chopped-up sample in turn, while striate2 "interlaces" the cut up bits of samples together.You can also use striate with very long samples, to cut them 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  striateBy function is a variant of  with an extra parameter which specifies the length of each part. The  striateBy 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: 0d1 $ slow 32 $ striateBy 32 (1/16) $ sound "bev" Note that  and  striateBy use the begin and end parameters internally. This means that 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]"tidalweave applies one control pattern to a list of other control patterns, with a successive time offset. It uses an  OscPattern to apply the function at different levels to each pattern, creating a weaving effect. For example: d1 $ weave 16 (pan sine) [ sound "bd sn cp" , sound "casio casio:1" , sound "[jvbass*2 jvbass:2]/2" , sound "hc*4" ]In the above, the pan sine control pattern is slowed down by the given number of cycles, in particular 16, and applied to all of the given sound patterns. What makes this interesting is that the pan control pattern is successively offset for each of the given sound patterns; because the pan is closed down by 16 cycles, and there are four patterns, they are @spread out@, i.e. with a gap of four cycles. For this reason, the four patterns seem to chase after each other around the stereo field. Try listening on headphones to hear this more clearly.You can even have it the other way round, and have the effect parameters chasing after each other around a sound parameter, like this: d1 $ weave 16 (sound "arpy" >| n (run 8)) [ vowel "a e i" , vowel "i [i o] o u" , vowel "[e o]/3 [i o u]/2" , speed "1 2 3" ]tidal weaveWith is similar to the above, but weaves with a list of functions, rather than a list of controls. For example: d1 $ weaveWith 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]") [ fast 2 , (# speed "0.5") , chop 16 ]tidalAn old alias for .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")tidalslice is similar to  and , in that it@s used to slice samples up into bits. The difference is that it allows you to rearrange those bits as a pattern. d1 $ slice 8 "7 6 5 4 3 2 1 0" $ sound "breaks165" # legato 1The above slices the sample into eight bits, and then plays them backwards, equivalent of applying rev $ chop 8. Here@s a more complex example: d1 $ slice 8 "[<0*8 0*2> 3*4 2 4] [4 .. 7]" $ sound "breaks165" # legato 1tidal randslice chops the sample into the given number of pieces and then plays back a random one each cycle: d1 $ randslice 32 $ sound "bev"Use  to get more than one per cycle: (d1 $ fast 4 $ randslice 32 $ sound "bev"tidalsplice is similar to , but the slices are automatically pitched up or down to fit their @slot@. d1 $ splice 8 "[<0*8 0*2> 3*4 2 4] [4 .. 7]" $ sound "breaks165"tidalloopAt makes a sample fit the given number of cycles. Internally, it works by setting the unit parameter to "c"7, 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"0It@s a good idea to use this in conjuction with , so the break is chopped into pieces and you don@t have to wait for the whole sample to start/stop. +d1 $ loopAt 4 $ chop 32 $ sound "breaks125"Like all Tidal functions, you can mess about with this considerably. The below example shows how you can supply a pattern of cycle counts to loopAt: d1 $ juxBy 0.6 (|* speed "2") $ slowspread (loopAt) [4,6,2,3] $ chop 12 $ sound "fm:14"tidalhurry is similiar to  in that it speeds up a pattern, but it also increases the speed control by the same factor. So, if you@re triggering samples, the sound gets higher in pitch. For example: -d1 $ every 2 (hurry 2) $ sound "bd sn:2 ~ cp"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 of  , which uses  instead of .!Compare the following variations: d1 $ smash 6 [2,3,4] $ sound "ho ho:2 ho:3 hc" d1 $ smash' 6 [2,3,4] $ sound "ho ho:2 ho:3 hc" d1 $ smash 12 [2,3,4] $ s "bev*4" d1 $ smash' 12 [2,3,4] $ s "bev*4"tidalApplies a type of delay to a pattern. It has three parameters, which could be called depth, time and feedback. depth is and integer, and time and feedback are floating point numbers.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: &d1 $ echo 4 (-0.2) 0.5 $ sound "bd sn"tidalechoWith is similar to =, but instead of just decreasing volume to produce echoes, echoWith applies a function 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. = 0) $ s "hh(5, 8)"Alternatively, you can use wait to achieve the same result: wait 1 1 $ s "bd hh hh hh"tidal Alias for .tidalCeiling trigger. Aligns the start of a pattern to the next cycle boundary, just like .tidalRounded trigger. Aligns the start of a pattern to the nearest cycle boundary, either next or previous.tidalFloor trigger. Aligns the start of a pattern to the previous cycle boundary.tidal(Alias mt) Mod trigger. Aligns the start of a pattern to the next cycle boundary where the cycle is evenly divisible by a given number.  is equivalent to  mtrigger 1..In the following example, when activating the d1 pattern, it will start at the same time as the next clap, even if it has to wait for 3 cycles. Once activated, the arpy= sound will play on every cycle, just like any other pattern: 5do resetCycles d2 $ every 4 (# s "clap") $ s "bd" -d1 $ mtrigger 4 $ filterWhen (>=0) $ s "arpy"tidal Alias for .tidalThis aligns the start of a pattern to some value relative to the time the pattern is evaluated. The provided function maps the evaluation time (on the global cycle clock) to a new time, and then  triggerWith: aligns the pattern's start to the time that's returned.This is a more flexible triggering function. In fact, all the other trigger functions are defined based on  triggerWith. For example,  is just triggerWith id.In the next example, use d1 as a metronome, and play with different values (from 0 to 1) on the const# expression. You@ll notice how the clap is displaced from the beginning of each cycle to the end, as the number increases: 9d1 $ s "bd hh!3" d2 $ triggerWith (const 0.1) $ s "clap"(This last example is equivalent to this: d2 $ rotR 0.1 $ s "clap"// Safe-Inferred   Safe-Inferred Safe-Inferred/6<tidal1Query 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'=_qrst)nop fghm%&'($GklDEFJOLTKMNPQRSUVWXYZ[\]^ij`aecdbHI vu      *+,-./0213456789: yz{w|x}~       Safe-Inferred9_qrst)nop fghm%&'($GklDEFJOLTKMNPQRSUVWXYZ[\]^ij`aecdbHI vu      *+,-./0213456789: yz{w|x}~       Safe-InferredNtidalResets the cycle count back to 0. Useful to make sure a pattern or set of patterns start from the beginning: >do resetCycles d1 $ s "bd hh hh hh" d2 $ s "ade" # cut 1Cycle count affects all patterns, so if there are any active, all of them will immediately jump to the beginning.  resetCycles% is also userful in multi-user Tidal. Also see setCycle, getnow.tidalAdjusts the number of cycles per second, i.e., tempo. Accepts integers, decimals, and fractions.The default number of cycles per second is 0.5625, equivalent to 135/60/4, i.e., 135 beats per minute if there are 4 beats per cycle.Representing cycles per second using fractions has the advantage of being more human-readable and more closely aligned with how tempo is commonly represented in music as beats per minute (bpm). For example, techno has a typical range of 120-140 bpm and house has a range of 115-130 bpm. To set the tempo in Tidal to fast house, e.g.,: setcps (130/60/4).The following sound the same: 6setcps (130/60/4) d1 $ n "1" # s "kick kick kick kick"and 'setcps (130/60/1) d1 $ n "1" # s "kick"44 !"#$%&'())*+,-./01234567899:;<=>?@ABACDEFGHIJKLMNOPQRSTUVWXYZ[\]^_``abcdefghijklmnopqrstuvwxyz{z|}~^                                                                                                                                                                                                                                                                                                                                                                C                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       "tidal-1.9.5-7AHiE4IEnHeHqbwX3gka7lSound.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.Boottidalecho Data.String fromStringSound.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 squeezeJoin _trigJointrigJoin trigZeroJoinresetresetTorestart restartTonoOvemptysilencequeryArc splitQueries withResultArcwithResultTime withQueryArc withQueryTimewithQueryControls withEvent withValue withEventswithPart_extractextractIextractFextractSextractBextractRextractN compressArc compressArcTofocusArcfast fastSqueezedensity_fastslow_slow_fastGaprotLrotRrevmatchManyToOne 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 $fStringyList$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$fValuableList$fValuableList0$fValuableNote$fValuableBool $fValuableInt$fValuableRatio$fValuableDouble$fValuableList1$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 patternTimeID$fShowTickState$fShowPlayState Unionableunionsigsinesine2cosinecosine2sawsaw2isawisaw2tritri2squaresquare2envLenvLRenvEqenvEqR|+||++|||+|++||++++|||++|/||//|||/|*||**|||*|-||--|||-|%||%%|||%|**||****|||**|>||>>|||>|<||<<|||<#fromList fastFromList listToPat fromMaybesrun_runscan_scanappendcatslowCatslowcat slowAppend slowappend fastAppend fastappendfastCatfastcattimeCattimecatoverlaystack<~~> slowSqueezesparsityzoomzoomArcfastGap 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 diminished7minor9minor11minor13 minorMajor7onefivesus2sus4 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 updatePatternticksnowArcnudged TempoActionSetCycle SingleTickSetNudge StreamReplace TransitionTransitionMappersetCyclesetNudge timeToCycles' cyclesToTimeaddMicrosToOscclocked $fShowUdp $fShowStatescalegetScale scaleList scaleTablegrpmFmImSpFpIpBpRpNpSpXpStateF pStateList pStateListF pStateListSsoundsTakeccnrpnnrpnnnrpnvgrain'midinotedrumdrumN accelerateaccelerateTakeaccelerateCountaccelerateCountTo acceleratebusampampTakeampCount ampCountToampbusamprecvarray arrayTakearraybusattack attackTake attackCount attackCountTo attackbus attackrecvbandf bandfTake bandfCount bandfCountTobandfbus bandfrecvbandq bandqTake bandqCount bandqCountTobandqbus bandqrecvbegin beginTake beginCount beginCountTobeginbusbinshift 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 lsnarerecvmetatune metatuneTake metatuneCountmetatuneCountTo metatunebus metatunerecvmidibend 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 wchooseByrandcatwrandcatdegrade degradeBy _degradeBy_degradeByUsing unDegradeBy _unDegradeBy degradeOverBy sometimesBy sometimesBy' sometimes sometimes'oftenoften'rarelyrarely' almostNever almostNever' almostAlways almostAlways'neveralways someCyclesBy _someCyclesBy somecyclesBy someCycles somecyclesbrakiter_iteriter'_iter' palindromefadeOut 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 discretisefit_fitpermstepstruct substructrandArcs randStruct substruct'stripe_stripe slowstripe parseLMRule parseLMRule' lindenmayer lindenmayerI runMarkov markovPat _markovPatmask enclosingArcstretchfit'chunk_chunkchunk'_chunk'inside_insideoutside_outside loopFirsttimeLoopseqPLooptoScaletoScale'swingByswing cycleChoose_rearrangeWithshuffle_shufflescramble _scramblerandrunseqPurinhabitspaceOutflatpatlayer arpeggiatearpgarpWitharp_arprolledrolledBy rolledWithply_plyplyWith_plyWithpresspressBy_pressBysewstitchwhilestutterjuxjuxcutjuxcut'jux'jux4juxBypicksamplessamples'spreadf stackwithrange_rangerangexoff_offoffaddstepstepsstep'ghost'' ghostWithghost'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$fEnumerableList$fEnumerableRatio$fEnumerableInteger$fEnumerableInt$fEnumerableBool$fEnumerableList0$fEnumerableNote$fEnumerableDouble$fEnumerableChar$fParseableList$fIsStringPattern$fParseableRatio$fParseableInteger$fParseableInt$fParseableBool$fParseableList0$fParseableNote$fParseableDouble$fParseableChar $fFunctorTPat $fShowTPat$fEnumerableColour$fParseableColour$fEqTidalParseErrorspin_spinchopchopArc_chopstriate_striatemergePlayRange striateBystriate' _striateBygap_gapweave weaveWithweave' interlaceslice_slice randslice_splicespliceloopAthurrysmashsmash'_echoechoWith _echoWithstut_stutstutWith _stutWithstut'secmsectriggerqtriggerqtctriggerrtriggerftriggermtriggermt triggerWithsplatcrunchscratchlouderquietersilentskipleftrighthigherlowerfasterslower 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$fMonadThrowOpphushlistunmuteunsolooncefirstasapnudgeAllall resetCyclessetcpsxfadeforIdd1d2d3d4d5d6d7d8d9d10d11d12d13d14d15d16setIsetFsetSsetRsetB GHC.MaybeMaybeNothingghc-prim GHC.TypesTrueDoubleGHC.Base<>GHC.NumNumGHC.List!!ritusenegyptian~StringGHC.Real fromRationalBool.idfloorceiling+doTickStreamsConfigsBussessStateMVsLinksListensPMapMV sActionsMV sGlobalFMVsCxsCxcxTargetcxUDPcxOSCscxAddr cxBusAddrOSC OSCContextpathargs StampStyle BundleStamp MessageStampSchedulePreLiveArgsNamedArgList requiredArgsProcessedEvent peHasOnsetpeEventpeCpspeDeltapeCyclepeOnWholeOrPartpeOnWholeOrPartOscpeOnPart peOnPartOscsend startTidalsuperdirtTargetsDefaultfDefaultrDefaultiDefaultbDefaultxDefaultrequiredsuperdirtShape dirtTarget dirtShape defaultCps startStreamverbose openListenerresolvesendHandshakes ctrlRespondersendOsendBndl startMultitoDatumtoDatasubstitutePath getString playStackhasSolotoOSC processCpssetPreviousPatternOrSilencestreamSetCycle withPatIds streamMutes streamMuteAllstreamUnmuteAllstreamUnsoloAll streamSilence streamGet streamSetrecvMessagesTimeout streamGetcps streamGetnowgetProcessAheadstreamGetAheadRationalRatio% numerator denominator Data.RatioapproxRational