!̲j      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                 ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe>Safe?     Safe24=?)2tidal#A datatype that's basically a query!tidal8A function that represents events taking place over time"tidal$an Arc and some named control values'tidalzAn 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.-tidalHAn arc of time, with a start time (or onset) and a stop time (or offset)1tidalTime is rational2tidalThe 2* (start of cycle) for the given time value3tidal:Turns a number into a (rational) time value. An alias for .4tidalIThe end point of the current cycle (and starting point of the next cycle)5tidal@The position of a time value relative to the start of its cycle.7tidalconvex hull union8tidal 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.:tidalAThe arc of the whole cycle that the given time value falls within;tidalAShifts an arc to the equivalent one that starts during cycle zero<tidal;A list of cycle numbers which are included in the given arc=tidalFA list of arcs of the whole cycles which are included in the given arc>tidalSplits the given - into a list of -s, at cycle boundaries.?tidal+Like arcCycles, but returns zero-width arcs@tidal Similar to J but time is relative to the cycle (i.e. the sam of the start of the arc)AtidalisIn a t is True if t# is inside the arc represented by a.Dtidal if an ''s starts is within given -Etidal\Compares two lists of events, attempting to combine fragmented events in the process for a truer compareFtidalLReturns a list of events, with any adjacent parts of the same whole combinedGtidalReturns = if the two given events are adjacent parts of the same wholeItidalGet the onset of an event's )JtidalGet the offset of an event's )KtidalGet the onset of an event's )LtidalGet the offset of an event's *MtidalGet the timespan of an event's *UtidalLike  * , but the wholes come from the leftVtidalLike  * , but the wholes come from the rightWtidalFTurns a pattern of patterns into a single pattern. (this is actually join) 1/ For query $(, get the events from the outer pattern pp' 2/ Query the inner pattern using the * 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)KTODO - what if a continuous pattern contains a discrete one, or vice-versa?Xtidal8Turns a pattern of patterns into a single pattern. Like unwrap3, but structure only comes from the inner pattern.Ytidal8Turns a pattern of patterns into a single pattern. Like unwrap3, but structure only comes from the outer pattern.ZtidalLike 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?atidalSplits 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.btidalKApply a function to the arcs/timespans (both whole and parts) of the resultctidaliApply a function to the time (both start and end of the timespans of both whole and parts) of the resultdtidal-Apply a function to the timespan of the queryetidal>Apply a function to the time (both start and end) of the queryftidal withEvent f p returns a new Pattern' with each event mapped over function f.gtidal withEvent f p returns a new PatternI with f applied to the resulting list of events for each query function f.htidal withPart f p returns a new Pattern with function f applied to the part.itidal>Apply one of three functions to a Value, depending on its typejtidaloApply one of two functions to a Value, depending on its type (int or float; strings and rationals are ignored)stidalFShifts a pattern back in time by the given amount, expressed in cyclesttidalIShifts a pattern forward in time by the given amount, expressed in cyclesutidal;Remove events from patterns that to not meet the given testvtidalTurns a pattern of ; values in to a pattern of values, dropping the events of .tidal\Mark values in the first pattern which match with at least one value in the second pattern.v  !"#%$&'(*)+,-.0/123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~v12345-.0/,6789:;<=>?@A'(*)+&BCDEFGHIJKLMNOP"#%$! QRSTUVWXYZ[ \]^_`abcdefghijklmnopqrstuvwxyz{|}~U4V4Safe=?7-tidalAn empty patterntidal:Takes a function from time to values, and turns it into a .tidalsine returns a  of continuous U values following a sinewave with frequency of one cycle, and amplitude from 0 to 1.tidalcosine is a synonym for  0.25 ~> sine.tidalsaw is the equivalent of  for (ascending) sawtooth waves.tidalisaw is the equivalent of ) for inverse (descending) sawtooth waves.tidaltri is the equivalent of  for triangular waves.tidalsquare is the equivalent of  for square waves.tidalenvL is a  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 reversedtidalETurns a list of values into a pattern, playing one of them per cycle.tidalETurns a list of values into a pattern, playing one of them per cycle.tidalA synonym for tidal'fromMaybes; is similar to ., but allows values to be optional using the  type, so that ! results in gaps in the pattern.tidalIA pattern of whole numbers from 0 to the given number, in a single cycle.tidalFrom 1E for the first cycle, successively adds a number until it gets up to ntidal2Alternate between cycles of the two given patternstidalLike , but for a list of patterns. Interlaces them, playing the first cycle from each in turn, then the second cycle from each, and so on.tidal Alias for tidal Alias for tidalLike , but twice as fasttidal The same as }, but speeds up the result by the number of patterns there are, so the cycles from each are squashed to fit a single cycle.tidal Similar to fastCat/, but each pattern is given a relative durationtidal combines two Ds into a new pattern, so that their events are combined over time. tidalAn infix alias of overlaytidal combines a list of Cs into a new pattern, so that their events are combined over time.tidalFShifts a pattern back in time by the given amount, expressed in cyclestidalIShifts a pattern forward in time by the given amount, expressed in cyclestidal,Speed up a pattern by the given time patterntidal>Slow down a pattern by the factors in the given time pattern,  squeezing7 the pattern to fit the slot given in the time patterntidal An alias for fasttidal-Slow down a pattern by the given time patterntidal>Slow down a pattern by the factors in the given time pattern,  squeezing7 the pattern to fit the slot given in the time patterntidal An alias for slowtidalrev p returns p@ with the event positions in each cycle reversed (or mirrored).tidalPlays a portion of a pattern, specified by a time arc (start and end time). The new resulting pattern is played over the time period of the original pattern: :d1 $ zoom (0.25, 0.75) $ sound "bd*2 hh*3 [sn bd]*2 drum" In the pattern above, G is used with an arc from 25% to 75%. It is equivalent to this pattern: d1 $ sound "hh*3 [sn bd]*2" tidalfastGap is similar to 3 but maintains its cyclic alignment. For example,  fastGap 2 p% would squash the events in pattern pk into the first half of each cycle (and the second halves would be empty). The factor should be at least 1tidal An alias for fastGaptidalHigher order functions@Functions which work on other functions (higher order functions) every n f p applies the function f to p, but only affects every n cycles.tidal every n o f' is like  every n f with an offset of o cyclestidalfoldEvery ns f p applies the function f to p$, and is applied for each cycle in ns.tidalOnly ! the given test function returns r the given pattern transformation is applied. 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.UUSafe 2tidalchordate 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 mS 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  * pc/      !"#$%&'()*+,-./01234/      !"#$%&'()*+,-./01234None*JtidalUReturns the given time in terms of cycles relative to metrical grid of a given Tempo56;:978<=EDCBA@?>FGHIJKLMNO<=EDCBA@?>56;:978FGHIJKLMNONone,>MXhIPQRVUTSWX`_^]\[ZYabdcefgonlkihmjpsrqtuvwxyz{|}~IpsrqfgonlkihmjeabdcWX`_^]\[ZYtuvQRVUTSPwxyz{|}~NoneX NoneD Safe}tidalThe 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 Safe|3tidalgroup multiple params into onetidalGrouped paramstidalSingular paramstidal#patterns for internal sound routingtidalJa pattern of numbers that speed up (or slow down) samples while they play.tidalAmplitude; like gain , but linear.tidalya pattern of numbers to specify the attack time (in seconds) of an envelope applied to each sample. Only takes effect if   is also specified.tidalTa pattern of numbers from 0 to 1. Sets the center frequency of the band-pass filter.tidalMa pattern of numbers from 0 to 1. Sets the q-factor of the band-pass filter.ytidalKa pattern of numbers from 0 to 1. Skips the beginning of each sample, e.g. `0.25`/ to cut off the first quarter from each sample. Using `begin "-1"` combined with `cut "-1"` means that when the sample cuts itself it will begin playback from where the previous one left off, so it will sound like one seamless sample. This allows you to apply a synth param across a long sample in a way similar to chop: "cps 0.5 d1 $ sound "breaks125*8"  unit "c"  begin "-1"  cut "-1"  coarse "1 2 4 8 16 32 64 128" This will play the  breaks125 sample and apply the changing ' parameter over the sample. Compare to: #d1 $ (chop 8 $ sounds "breaks125")  unit "c"  coarse "1 2 4 8 16 32 64 128" [which performs a similar effect, but due to differences in implementation sounds different.tidalOchoose the physical channel the pattern is sent to, this is super dirt specifictidalKa pattern of numbers from 0 to 1. Skips the beginning of each sample, e.g. `0.25`/ to cut off the first quarter from each sample. Using `begin "-1"` combined with `cut "-1"` means that when the sample cuts itself it will begin playback from where the previous one left off, so it will sound like one seamless sample. This allows you to apply a synth param across a long sample in a way similar to chop: "cps 0.5 d1 $ sound "breaks125*8"  unit "c"  begin "-1"  cut "-1"  coarse "1 2 4 8 16 32 64 128" This will play the  breaks125 sample and apply the changing ' parameter over the sample. Compare to: #d1 $ (chop 8 $ sounds "breaks125")  unit "c"  coarse "1 2 4 8 16 32 64 128" [which performs a similar effect, but due to differences in implementation sounds different.tidalKa pattern of numbers from 0 to 1. Skips the beginning of each sample, e.g. `0.25`/ to cut off the first quarter from each sample. Using `begin "-1"` combined with `cut "-1"` means that when the sample cuts itself it will begin playback from where the previous one left off, so it will sound like one seamless sample. This allows you to apply a synth param across a long sample in a way similar to chop: "cps 0.5 d1 $ sound "breaks125*8"  unit "c"  begin "-1"  cut "-1"  coarse "1 2 4 8 16 32 64 128" This will play the  breaks125 sample and apply the changing ' parameter over the sample. Compare to: #d1 $ (chop 8 $ sounds "breaks125")  unit "c"  coarse "1 2 4 8 16 32 64 128" [which performs a similar effect, but due to differences in implementation sounds different.tidal|fake-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.tidalobit crushing, a pattern of numbers from 1 (for drastic reduction in bit-depth) to 16 (for barely no reduction).Ka pattern of numbers from 0 to 1. Skips the beginning of each sample, e.g. `0.25`/ to cut off the first quarter from each sample. Using `begin "-1"` combined with `cut "-1"` means that when the sample cuts itself it will begin playback from where the previous one left off, so it will sound like one seamless sample. This allows you to apply a synth param across a long sample in a way similar to chop: "cps 0.5 d1 $ sound "breaks125*8"  unit "c"  begin "-1"  cut "-1"  coarse "1 2 4 8 16 32 64 128" This will play the  breaks125 sample and apply the changing ' parameter over the sample. Compare to: #d1 $ (chop 8 $ sounds "breaks125")  unit "c"  coarse "1 2 4 8 16 32 64 128" [which performs a similar effect, but due to differences in implementation sounds different.tidal'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.YAn example would be an open hi-hat followed by a closed one, essentially muting the open. Ed1 $ stack [ sound "bd", sound "~ [~ [ho:2 hc/2]]" # cut "1" ] PThis will mute the open hi-hat every second cycle when the closed one is played.Using \ with negative values will only cut the same sample. This is useful to cut very long samples  d1 $ sound " 3,8 bev, [ho:3]" # cut "-1" -Using `cut "0"` is effectively _no_ cutgroup.tidalVa pattern of numbers from 0 to 1. Applies the cutoff frequency of the low-pass filter.tidalEa pattern of numbers from 0 to 1. Sets the level of the delay signal.tidalDa 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.tidal when set to `1`/ will disable all reverb for this pattern. See  and # for more information about reverb.tidala pattern of numbers that specify volume. Values less than 1 make the sound quieter. Values greater than 1 make the sound louder. For the linear equivalent, see amp.tidalWa pattern of numbers from 0 to 1. Applies the cutoff frequency of the high-pass filter.tidalwa 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.tidalPa pattern of numbers from 0 to 1. Applies the resonance of the high-pass filter.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.specifies the sample or note number to be usedtidalrPushes things forward (or backwards within built-in latency) in time. Allows for nice things like _swing_ feeling: Hd1 $ stack [ sound "bd bd/4", sound "hh(5,8)" ] # nudge "[0 0.04]*4"  -pitch model tidalrPushes things forward (or backwards within built-in latency) in time. Allows for nice things like _swing_ feeling: Hd1 $ stack [ sound "bd bd/4", sound "hh(5,8)" ] # nudge "[0 0.04]*4"  -pitch model tidalrPushes things forward (or backwards within built-in latency) in time. Allows for nice things like _swing_ feeling: Hd1 $ stack [ sound "bd bd/4", sound "hh(5,8)" ] # nudge "[0 0.04]*4"  -pitch model tidalrPushes things forward (or backwards within built-in latency) in time. Allows for nice things like _swing_ feeling: Hd1 $ stack [ sound "bd bd/4", sound "hh(5,8)" ] # nudge "[0 0.04]*4"  -pitch model tidalrPushes things forward (or backwards within built-in latency) in time. Allows for nice things like _swing_ feeling: Hd1 $ stack [ sound "bd bd/4", sound "hh(5,8)" ] # nudge "[0 0.04]*4"  -pitch model tidalrPushes things forward (or backwards within built-in latency) in time. Allows for nice things like _swing_ feeling: Hd1 $ stack [ sound "bd bd/4", sound "hh(5,8)" ] # nudge "[0 0.04]*4"  -pitch model tidala pattern of numbers. An  is a global parameter context for patterns. Patterns with the same orbit will share hardware output bus offset and global effects, e.g. reverb and delay. The maximum number of orbits is specified in the superdirt startup, numbers higher than maximum will wrap around.tidalwa pattern of numbers between 0 and 1, from left to right (assuming stereo), once round a circle (assuming multichannel)tidala pattern of numbers between -inf and inf, which controls how much multichannel output is fanned out (negative is backwards ordering)tidalja pattern of numbers between 0.0 and 1.0, which controls the multichannel spread range (multichannel only)tidala pattern of numbers between 0.0 and inf, which controls how much each channel is distributed over neighbours (multichannel only)tidala pattern of numbers between -1.0 and 1.0, which controls the relative position of the centre pan in a pair of adjacent speakers (multichannel only) tidal9used in SuperDirt softsynths as a control rate or "speed" tidalza pattern of numbers to specify the release time (in seconds) of an envelope applied to each sample. Only takes effect if  is also specified.tidalQa pattern of numbers from 0 to 1. Specifies the resonance of the low-pass filter.tidal;a pattern of numbers from 0 to 1. Sets the level of reverb.tidalgwave shaping distortion, a pattern of numbers from 0 for no distortion up to 1 for loads of distortion.tidalPa pattern of numbers from 0 to 1. Sets the perceptual size (reverb time) of the  to be used in reverb.tidala pattern of numbers which changes the speed of sample playback, i.e. a cheap way of changing pitch. Negative values will play the sample backwards!tidal6a pattern of strings. Selects the sample to be played.tidalused in conjunction with i, accepts values of "r" (rate, default behavior), "c" (cycles), or "s" (seconds). Using `unit "c"` means  will be interpreted in units of cycles, e.g. `speed "1"` means samples will be stretched to fill a cycle. Using `unit "s"` means the playback speed will be adjusted so that the duration is the number of seconds specified by .$tidalEformant filter to make things sound like vowels, a pattern of either a, e, i, o or u. Use a rest (`~`) for no effect.tidal is now an alias of .       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkplmnoqrstuvwxyz{|}~ None=?Vtidal RandomisationtidalC generates a continuous pattern of (pseudo-)random numbers between `0` and `1`. sound "bd*8" # pan rand pans bass drums randomly sound "sn sn ~ sn" # gain rand *makes the snares' randomly loud and quiet.%Numbers coming from this pattern are seeded by time. So if you reset time (via `cps (-1)`, then `cps 1.1` or whatever cps you want to restart with) 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: jux (! 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 rand 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 rand but smoothly moves between random values each cycle. V takes a pattern as the RNG's "input" instead of automatically using the cycle count. 9 d1 $ s "arpy*32" # cutoff (perlinWith (saw * 4) * 2000) y will generate a smooth random pattern for the cutoff frequency which will repeat every cycle (because the saw does) The B function uses the cycle count as input and can be used much like rand.tidal-Randomly picks an element from the given list =sound "superpiano(3,8)" # note (choose ["a", "e", "g", "c"]) Jplays a melody randomly choosing one of the four notes "a", "e", "g", "c".tidalLike choose8, but works on an a list of tuples of values and weights Psound "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.tidal Similar to  p allows you to control the percentage of events that are removed. For example, to remove events 90% of the time: qd1 $ slow 2 $ degradeBy 0.9 $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]" # accelerate "-6" # speed "2" 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: sometimes = sometimesBy 0.5 often = sometimesBy 0.75 rarely = sometimesBy 0.25 almostNever = sometimesBy 0.1 almostAlways = sometimesBy 0.9 tidal sometimes! is an alias for sometimesBy 0.5.tidaloften" is an alias for sometimesBy 0.75.tidalrarely" is an alias for sometimesBy 0.25.tidal almostNever is an alias for sometimesBy 0.1tidal almostAlways is an alias for sometimesBy 0.9tidal someCyclesBy is a cycle-by-cycle version of  sometimesBy1. It has a `someCycles = someCyclesBy 0.5` alias tidal8 randomly removes events from a pattern 50% of the time: kd1 $ slow 2 $ degrade $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]" # accelerate "-6" # speed "2" The shorthand syntax for  is a question mark: ?. Using ?F will allow you to randomly remove events from a portion of a pattern: 2d1 $ 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(The above means that I is a function from patterns of any type, to a pattern of the same type.)+Make a pattern sound a bit like a breakbeatExample: d1 $ sound (brak "bd sn kurt") tidalDivides a pattern into a given number of subdivisions, plays the subdivisions in order, but increments the starting subdivision each cycle. The pattern wraps to the first subdivision after the last subdivision is played.Example: "d1 $ iter 4 $ sound "bd hh sn cp" 1This will produce the following over four cycles: 0bd hh sn cp hh sn cp bd sn cp bd hh cp bd hh sn There is also 5, which shifts the pattern in the opposite direction.tidaliter' is the same as iterF, but decrements the starting subdivision instead of incrementing it.tidal palindrome p applies rev to pS every other cycle, so that the pattern alternates between forwards and backwards.tidalComposing patterns The function seqPw allows you to define when a sound within a list starts and ends. The code below contains three separate patterns in a , but each has different start times (zero cycles, eight cycles, and sixteen cycles, respectively). All patterns stop after 128 cycles: d1 $ seqP [ (0, 128, sound "bd bd*2"), (8, 128, sound "hh*2 [sn cp] cp future*4"), (16, 128, sound (samples "arpy*8" (run 16))) ] tidal'Degrades a pattern over the given time.tidalAlternate version to fadeOut: where you can provide the time from which the fade startstidal Undegrades a pattern over the given time.tidalAlternate version to fadeIn> where you can provide the time from which the fade in startstidalThe W function allows you to take a pattern transformation which takes a parameter, such as O, 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" <We can slow it down by different amounts, such as by a half: &d1 $ slow 2 $ sound "ho ho:2 ho:3 hc" 3Or by four thirds (i.e. speeding it up by a third; `4%3` means four over three): *d1 $ slow (4%3) $ sound "ho ho:2 ho:3 hc" But if we use @, we can make a pattern which alternates between the two speeds: 3d1 $ spread slow [2,4%3] $ sound "ho ho:2 ho:3 hc" zNote that if you pass ($) as the function to spread values over, you can put functions as the list of values. For example: {d1 $ spread ($) [density 2, rev, slow 2, striate 3, (# speed "0.8")] $ sound "[bd*2 [~ bd]] [sn future]*2 cp jvbass*4" VAbove, the pattern will have these transforms applied to it, one at a time, per cycle:5cycle 1: `density 2` - pattern will increase in speed cycle 2:  - pattern will be reversed2cycle 3: `slow 2` - pattern will decrease in speed2cycle 4: `striate 3` - pattern will be granualizedLcycle 5: `(# speed "0.8")` - pattern samples will be played back more slowlySAfter `(# speed "0.8")`, the transforms will repeat and start at `density 2` again.tidal fastspread works the same as spreadM, but the result is squashed into a single cycle. If you gave four values to spreadP, then the result would seem to speed up by a factor of four. Compare these two:7d1 $ spread chop [4,64,32,16] $ sound "ho ho:2 ho:3 hc";d1 $ fastspread chop [4,64,32,16] $ sound "ho ho:2 ho:3 hc"There is also  slowspread, which is an alias of spread.tidal$There's a version of this function, W (pronounced "spread prime"), which takes a *pattern* of parameters, instead of a list: 4d1 $ spread' slow "2 4%3" $ sound "ho ho:2 ho:3 hc" This is quite a messy area of Tidal - due to a slight difference of implementation this sounds completely different! One advantage of using < though is that you can provide polyphonic parameters, e.g.: 9d1 $ spread' slow "[2 4%3, 3]" $ sound "ho ho:2 ho:3 hc" tidal$`spreadChoose f xs p` is similar to  but picks values from xsN at random, rather than cycling through them in order. It has a shorter alias .tidalDecide whether to apply one or another function depending on the result of a test function that is passed the current cycle as a number. Td1 $ ifp ((== 0).(flip mod 2)) (striate 4) (# coarse "24 48") $ sound "hh hc" _This will apply `striate 4` for every _even_ cycle and aply `# coarse "24 48"` for every _odd_.JDetail: As you can see the test function is arbitrary and does not rely on anything tidal specific. In fact it uses only plain haskell functionality, that is: it calculates the modulo of 2 of the current cycle which is either 0 (for even cycles) or 1. It then compares this value against 0 and returns the result, which is either  or . This is what the k signature's first part signifies `(Int -> Bool)`, a function that takes a whole number and returns either  or .tidal wedge t p p' combines patterns p and p' by squashing the p) into the portion of each cycle given by t, and p'" into the remainer of each cycle.tidalwhenmod$ has a similar form and behavior to , but requires an additional number. Applies the function to the pattern, when the remainder of the current loop number divided by the first parameter, is greater or equal than the second parameter.OFor example the following makes every other block of four loops twice as dense: 2d1 $ whenmod 8 4 (density 2) (sound "bd sn kurt") tidal !superimpose f p = stack [p, f p]  plays a modified version of a pattern at the same time as the original pattern, resulting in two patterns being played at the same time. |d1 $ superimpose (density 2) $ sound "bd sn [cp ht] hh" d1 $ superimpose ((# speed "2") . (0.125 <~)) $ sound "bd sn cp hh" tidaltrunc truncates a pattern so that only a fraction of the pattern is played. The following example plays only the first quarter of the pattern: <d1 $ trunc 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2" tidallinger is similar to G but the truncated part of the pattern loops until the end of the cycle =d1 $ linger 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"  tidalUse  x to apply a function to only a part of a pattern. For example, to apply `density 2` to only the first half of a pattern: Ed1 $ within (0, 0.5) (density 2) $ sound "bd*2 sn lt mt hh hh hh hh" DOr, to apply `(# speed "0.5") to only the last quarter of a pattern: Jd1 $ 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 h. 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 5d1 $ 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' 6d1 $ within' (0, 0.25) (fast 2) $ sound "bd hh cp sd"  sounds like: d1 $ sound "[bd bd] hh cp sd"  tidalYou can use the eu function to apply a Euclidean algorithm over a complex pattern, although the structure of that pattern will be lost: "d1 $ e 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 `e 3 8`. It ends up picking two bd sounds, a cp and missing the sn entirely.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 [The Euclidean Algorithm Generates Traditional Musical Rhythms](http:/cgm.cs.mcgill.ca ~godfried publicationslbanff.pdf) by Toussaint. Some examples from this paper are included below, including rotation in some cases. b- (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) : A 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) : Yields the York-Samai pattern, a popular Arab rhythm. - (5,7) : The 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) : A 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) : A rhythm necklace used in the Central African Republic. - (11,24,14) : A rhythm necklace of the Aka Pygmies of Central Africa. - (13,24,5) : Another rhythm necklace of the Aka Pygmies of the upper Sangha. tidal`euclidfull n k pa pb` stacks e n k pa with  einv n k pb tidal fills in the blanks left by e -  e 3 8 "x" -> "x ~ ~ x ~ ~ x ~"euclidInv 3 8 "x" -> "~ x x ~ x x ~ x"tidalrot n p! rotates the values in a pattern p by n beats to the left. Example: 3d1 $ every 4 (rot 2) $ slow 2 $ sound "bd hh hh hh"tidal segment n p: e the pattern p at a rate of nQ events per cycle. Useful for turning a continuous pattern into a discrete one. tidal discretise : the old (deprecated) name for !tidal randcat ps : does a slowcat on the list of patterns ps4 but randomises the order in which they are played."tidalThe " function takes a pattern of integer numbers, which are used to select values from the given list. What makes this a bit strange is that only a given number of values are selected each cycle. For example: Id1 $ sound (fit 3 ["bd", "sn", "arpy", "arpy:1", "casio"] "0 [~ 1] 2 1") The above fits three samples into the pattern, i.e. for the first cycle this will be `"bd"`, `"sn"` and `"arpy"`, giving the result `"bd [~ sn] arpy sn"` (note that we start counting at zero, so that `0` picks the first value). The following cycle the *next* three values in the list will be picked, i.e. `"arpy:1"`, `"casio"` and `"bd"`, giving the pattern `"arpy:1 [~ casio] bd casio"` (note that the list wraps round here).$tidal struct a b: structures pattern b, in terms of the pattern of boolean values a. Only True) values in the boolean pattern are used.%tidal substruct a b : similar to struct, but each event in pattern a gets replaced with pattern b., compressed to fit the timespan of the event.)tidal stripe n p: repeats pattern p, n! times per cycle. So similar to fast, but with random durations. The repetitions will be continguous (touching, but not overlapping) and the durations will add up to a single cycle. n+ can be supplied as a pattern of integers.+tidalslowstripe n p: The same as stripe, but the result is also na times slower, so that the mean average duration of the stripes is exactly one cycle, and every nFth stripe starts on a cycle boundary (in indian classical terms, the sam)..tidal returns the nth iteration of a  &https://en.wikipedia.org/wiki/L-systemLindenmayer System with given start sequence. for example: 'lindenmayer 1 "a:b,b:ab" "ab" -> "bab" /tidal lindenmayerI> converts the resulting string into a a list of integers with  fromIntegralQ applied (so they can be used seamlessly where floats or rationals are required) 0tidalrunMarkov 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 A 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. 3tidalORemoves events from second pattern that don't start during an event from first.6Consider this, kind of messy rhythm without any rests. ?d1 $ sound (slowcat ["sn*8", "[cp*4 bd*4, hc*5]"]) # n (run 8) If we apply a mask to it md1 $ 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. ad1 $ s (mask ("1 ~ 1 ~ 1 1 ~ 1") (slowcat ["can*8", "[cp*4 sn*4, jvbass*16]"] )) # n (run 8) 4tidalTODO: refactor towards union6tidal6 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`K tells it to select two values each cycle, just like the first argument to "#. The next pattern `"0 1"` is the "from" pattern which tells it how to slice, which in this case means `"0"` maps to `"bd"`, and `"1"` maps to `"sn"`. The next pattern `"1 0"` is the "to" pattern, which tells it how to rearrange those slices. So the final result is the pattern `"sn bd"`.-A more useful example might be something like `d1 $ fit' 1 4 (run 4) "[0 3*2 2 1 0 3*2 2 [1*8 ~]]/2" $ chop 4 $ (sound "breaks152" # unit "c")  which uses chop8 to break a single sample into individual pieces, which 6p then puts into a list (using the `run 4` pattern) and reassembles according to the complicated integer pattern.7tidal chunk n f p treats 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. 6d1 $ chunk 4 (density 4) $ sound "cp sn arpy [mt lt]" 9tidalchunk' works much the same as 7, but runs from right to left.@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"`. It assumes your scale fits within an octave; to change this use A size`. Example: AA 24 [0,4,7,10,14,17] (run 8)` turns into `"0 4 7 10 14 17 24 28"`Btidal#`swingBy x n` divides a cycle into nA slices and delays the notes in the second half of each slice by x fraction of a slice . swing is an alias for `swingBy (1%3)`DtidalD is like 9 but only picks a new item from the list once each cycle Etidal/Internal function used by shuffle and scramble Ftidal6`shuffle n p` evenly divides one cycle of the pattern p into n parts, and returns a random permutation of the parts each cycle. For example, `shuffle 3 "a b c"` could return `"a b c"`, `"a c b"`, `"b a c"`, `"b c a"`, `"c a b"`, or `"c b a"`. But it will **never** return `"a a a"`, because that is not a permutation of the parts.Htidal`scramble n p` is like F( 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.Mtidal spaceOut xs p repeats a pattern p< at different durations given by the list of time values in xs NtidalflatpatI takes a Pattern of lists and pulls the list elements as separate EventsOtidallayerI takes a Pattern of lists and pulls the list elements as separate EventsPtidal arpeggiateg 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.QtidalShorthand alias for arpeggiate^tidalThe ^ function creates strange stereo effects, by applying a function to a pattern, but only in the right-hand channel. For example, the following reverses the pattern on the righthand side: =d1 $ slow 32 $ jux (rev) $ striateBy 32 (1/16) $ sound "bev" 2When passing pattern transforms to functions like  #juxjux and  #everyevery;, it's possible to chain multiple transforms together with g, for example this both reverses and halves the playback speed of the pattern in the righthand channel: Od1 $ slow 32 $ jux ((# speed "0.5") . rev) $ striateBy 32 (1/16) $ sound "bev" atidalIn addition to ^, a allows using a list of pattern transform. resulting patterns from each transformation will be spread via pan from left to right. For example: Ad1 $ jux' [iter 4, chop 16, id, rev, palindrome] $ sound "bd sn" 5will put `iter 4` of the pattern to the far left and  to the far right. In the center the original pattern will play and mid left mid right the chopped and the reversed version will appear.One could also write: d1 $ stack [ iter 4 $ sound "bd sn" # pan "0", chop 16 $ sound "bd sn" # pan "0.25", sound "bd sn" # pan "0.5", rev $ sound "bd sn" # pan "0.75", palindrome $ sound "bd sn" # pan "1", ] btidalMultichannel variant of ^, _not sure what it does_ctidalWith ^, the original and effected versions of the pattern are panned hard left and right (i.e., panned at 0 and 1). This can be a bit much, especially when listening on headphones. The variant cY has an additional parameter, which brings the channel closer to the centre. For example: -d1 $ juxBy 0.5 (density 2) $ sound "bd sn:1" dIn the above, the two versions of the pattern would be panned at 0.25 and 0.75, rather than 0 and 1.itidali2 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. Rd1 $ jux (iter 4) $ sound "arpy arpy:2*2" |+ speed (slow 4 $ range 1 1.5 sine1) ktidalk is an exponential version of iX, good for using with frequencies. Do *not* use negative numbers or zero as arguments! otidalStep sequencingqtidallike oC, but allows you to specify an array of strings to use for 0,1,2...utidal(tabby - A more literal weaving than the weave function, give number of threads^ per cycle and two patterns, and this function will weave them together using a plain (aka u+) weave, with a simple over/under structurevtidalHchooses between a list of patterns, using a pattern of floats (from 0-1)xtidalIchooses between a list of functions, using a pattern of floats (from 0-1)ztidal@chooses between a list of functions, using a pattern of integers|tidalcontrast p f f' p' splits controlpattern p' in two, applying the function f to one and f'\ to the other. This depends on whether events in it contains values matching with those in p. For example in contrast (n "1") ( crush 3) ( vowel "a") $ n "0 1"  s "bd sn"  speed 3b, the first event will have the vowel effect applied and the second will have the crush applied.tidalLike contrastJ, but one function is given, and applied to events with matching controls.tidalLike contrastT, but one function is given, and applied to events with controls which don't match.tidalQlimit values in a Pattern (or other Functor) to n equally spaced divisions of 1.tidal+Inverts all the values in a boolean patterntidalSSerialises a pattern so there's only one event playing at any one time, making it  monophonic4. Events which start/end earlier are given priority.tidalSLooks up values from a list of tuples, in order to swap values in the given pattern      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None=?_tidalAST representation of patternsMMNone=>?Qtidalx will "spin" a layer up a pattern the given number of times, with each successive layer offset in time by an additional `1/n`) of a cycle, and panned by an additional `1/n`f. The result is a pattern that seems to spin around. This function works best on multichannel systems. Ld1 $ slow 3 $ spin 4 $ sound "drum*3 tabla:4 [arpy:2 ~ arpy] [can:2 can:3]" tidal granualizes every sample in place as it is played, turning a pattern of samples into a pattern of sample parts. Use an integer value to specify how many granules each sample is chopped into: .d1 $ chop 16 $ sound "arpy arp feel*4 arpy*4" Different values of A can yield very different results, depending on the samples used: d1 $ chop 16 $ sound (samples "arpy*8" (run 16)) d1 $ chop 32 $ sound (samples "arpy*8" (run 16)) d1 $ chop 256 $ sound "bd*4 [sn cp] [hh future]*2 [cp feel]" tidal-Striate is a kind of granulator, for example: )d1 $ striate 3 $ sound "ho ho:2 ho:3 hc" lThis plays the loop the given number of times, but triggering progressive portions of each sample. So in this case it plays the loop three times, the first time playing the first third of each sample, then the second time playing the second third of each sample, etc.. With the highhat samples in the above example it sounds a bit like reverb, but it isn't really.You can also use striate with very long samples, to cut it into short chunks and pattern those chunks. This is where things get towards granular synthesis. The following cuts a sample into 128 parts, plays it over 8 cycles and manipulates those parts by reversing and rotating the loops. )d1 $ slow 8 $ striate 128 $ sound "bev" tidalThe  function is a variant of G with an extra parameter, which specifies the length of each part. The  function still scans across the sample over a single cycle, but if each bit is longer, it creates a sort of stuttering effect. For example the following will cut the bev sample into 32 parts, but each will be 1/16th of a sample long: 1d1 $ slow 32 $ striateBy 32 (1/16) $ sound "bev"  Note that  uses the begin and end8 parameters internally. This means that if you're using  (or &) you probably shouldn't also specify begin or end. 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: Bd1 $ gap 8 $ sound "jvbass" d1 $ gap 16 $ sound "[jvbass drum:4]" tidalM applies a function smoothly over an array of different patterns. It uses an  OscPatternV to apply the function at different levels to each pattern, creating a weaving effect. [d1 $ weave 3 (shape $ sine1) [sound "bd [sn drum:2*2] bd*2 [sn drum:1]", sound "arpy*8 ~"] tidal] is similar in that it blends functions at the same time at different amounts over a pattern: cd1 $ weaveWith 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]") [density 2, (# speed "0.5"), chop 16] tidal(A function that takes two ControlPatterns, and blends them together into a new ControlPattern. An ControlPattern is basically a pattern of messages to a synthesiser.)8Shifts between the two given patterns, using distortion.Example: Fd1 $ interlace (sound "bd sn kurt") (every 3 rev $ sound "bd sn:2") tidalT makes a sample fit the given number of cycles. Internally, it works by setting the unitF parameter to "c", changing the playback speed of the sample with the speed$ parameter, and setting setting the  of the pattern to match. zd1 $ loopAt 4 $ sound "breaks125" d1 $ juxBy 0.6 (|* speed "2") $ slowspread (loopAt) [4,6,2,3] $ chop 12 $ sound "fm:14"  tidalSmash is a combination of  and  - it cuts the samples into the given number of bits, and then cuts between playing the loop at different speeds according to the values in the list.So this: /d1 $ smash 3 [2,3,4] $ sound "ho ho:2 ho:3 hc" Is a bit like this: Ad1 $ spread (slow) [2,3,4] $ striate 3 $ sound "ho ho:2 ho:3 hc" This is quite dancehall: sd1 $ (spread' slow "1%4 2 1 3" $ spread (striate) [2,3,4,1] $ sound "sn:2 sid:3 cp sid:4") # speed "[1 2 1 1]/2"  tidalan altenative form to   is   which will use  instead of . tidalStut applies a type of delay to a pattern. It has three parameters, which could be called depth, feedback and time. Depth is an integer and the others floating point. This adds a bit of echo: $d1 $ stut 4 0.5 0.2 $ 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 $ stut 4 0.5 (-0.2) $ sound "bd sn" tidal5Instead of just decreasing volume to produce echoes, stut'\ allows to apply a function for each step and overlays the result delayed by the given time. =d1 $ stut' 2 (1%3) (# vowel "{a e i o u}%2") $ sound "bd sn" TIn this case there are two _overlays_ delayed by 1/3 of a cycle, where each has the vowel filter applied.tidalThe old name for stutWithtidalGTurns a pattern of seconds into a pattern of (rational) cycle durationstidallTurns a pattern of milliseconds into a pattern of (rational) cycle durations, according to the current cps.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Noneu 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 , M 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" tidalZJumps 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 R 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 == 0tidal: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.tidal|Also degrades the current pattern and undegrades the next. To change the number of cycles the transition takes, you can use clutchIn like so: Ad1 $ 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.: Dd1 $ sound "jvbass(3,8)" t1 (anticipateIn 4) $ sound "jvbass(5,8)" tidal is an increasing comb filter.QBuild up some tension, culminating in a _drop_ to the new pattern after 8 cycles.None=?v  SafewHNonew7  !"#$%&'(+)*,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~PQRSTUVWXYZ[\]^_`abcdefgjmhiklnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0112344567879:;<=<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABC44D>EFGHHIJKLMNOPQRSTUVWXYZ[\\]^_`aabcdefghijjklmnnopqrstuvwxyz{|}~                                                                                                                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                         K                                                                                                                                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"tidal-1.4.0-BI1CzdGBJdP1F3B47dk3n3Sound.Tidal.BjorklundSound.Tidal.ConfigSound.Tidal.PatternSound.Tidal.CoreSound.Tidal.ChordsSound.Tidal.TempoSound.Tidal.StreamSound.Tidal.EspGridSound.Tidal.CarabinerSound.Tidal.UtilsSound.Tidal.ScalesSound.Tidal.ParamsSound.Tidal.UISound.Tidal.ParseBPSound.Tidal.ControlSound.Tidal.TransitionSound.Tidal.SimpleSound.Tidal.VersionSound.Tidal.Context bjorklundConfig cCtrlListen cCtrlAddr cCtrlPortcFrameTimespan cTempoAddr cTempoPortcTempoClientPort cSendParts defaultConfig TolerantEq~==ControlPattern ControlMapStateMapValuabletoValueValueVSVFVRVIVBsvaluefvaluervalueivaluebvaluePatternqueryQueryStatearccontrolsEventEventFwholepartvalueArcArcFstartstopTimesamtoTimenextSamcyclePossecthullsubArc subMaybeArctimeToCycleArccycleArc cyclesInArccycleArcsInArc arcCycles arcCyclesZWmapCycleisInisAnalog isDigitalonsetIn compareDefrag defragParts isAdjacent wholeOrPart wholeStart wholeStopeventPartStart eventPartStop eventPart eventValue eventHasOnsettoEvent applyPatToPatapplyPatToPatBothapplyPatToPatLeftapplyPatToPatRight<**>unwrap innerJoin outerJoin squeezeJoinnoOv showPattern prettyRatshowFracemptyqueryArc splitQueries withResultArcwithResultTime withQueryArc withQueryTime withEvent withEventswithPartapplyFISfNum2getIgetFgetSgetBgetR compressArc compressArcTo_fastGaprotLrotR filterValues filterJust filterWhen filterOnsets filterEvents filterDigital filterAnalogplayFortParamtParam2tParam3 tParamSqueezematchManyToOne$fApplicativeArcF$fFractionalArcF $fNumArcF $fNFDataArcF $fShowArcF$fNFDataEventF $fShowEventF $fShowValue $fOrdValue $fEqValue $fNFDataValue$fValuableBool $fValuableInt$fValuableRatio$fValuableDouble $fValuable[] $fShowPattern$fRealFloatPattern$fRealFracPattern$fFloatingPattern$fFractionalPattern$fIntegralPattern $fRealPattern $fEnumPattern $fNumPattern $fOrdPattern $fEqPattern$fMonadPattern$fApplicativePattern$fFunctorPattern$fNFDataPattern $fShowMap$fFractionalMap$fNumMap$fTolerantEq[]$fTolerantEqEventF$fTolerantEqMap$fTolerantEqValue$fEqArcF $fOrdArcF $fFunctorArcF $fEqEventF $fOrdEventF$fFunctorEventF $fDataValue UnionableunionsilencesigsinecosinesawisawtrisquareenvLenvLRenvEqenvEqR|+||++||++||++++||/||//||*||**||-||--||%||%%||>||>>||<||<<|#fromList fastFromList listToPat fromMaybesrun_runscan_scanappendcatslowCatslowcat slowAppend fastAppendfastCatfastcattimeCatoverlay<>stack<~~>fast fastSqueezedensity_fastslow_slow slowSqueezesparsityrevzoomzoomArcfastGap densityGapcompress compressTo repeatCyclesfastRepeatCyclesevery_everyevery'_every' foldEverywhenwhenT$fUnionableMap $fUnionableamajorminormajor7dom7minor7augdimdim7onefiveplussharp5msharp5sus2sus4sixm6 sevenSus2 sevenSus4 sevenFlat5m7flat5 sevenSharp5m7sharp5ninem9m7sharp9maj9nineSus4sixby9m6by9 sevenFlat9m7flat9 sevenFlat10 nineSharp5m9sharp5sevenSharp5flat9 m7sharp5flat9elevenm11maj11 elevenSharpm11sharpthirteenm13 chordTablechordL chordListticksnowTimenowArcstartingTempoatTimeatCyclecpspausednudgedlocalUDP remoteAddrsynched changeTempo resetCyclessetCps defaultTempo timeToCyclesclocked clientListen sendTempo listenTempo serverListenPlayMap PlayStatepatternmutesolohistory OSCTargetoNameoAddressoPortoPathoShapeoLatency oPreamble oTimestampCxcxTargetcxUDPPatIdStreamsConfigsInputsOutput sListenTidsPMapMVsTempoMV sGlobalFMVsCxs TimeStamp BundleStamp MessageStampNoStampsuperdirtTarget dirtTarget startStreamtoDatumtoData toMessagedoCpsonTicksendschedstreamNudgeAllstreamResetCycleshasSolo streamList streamReplace streamMute streamMutes streamUnmute streamSolo streamUnsolo streamOnce withPatId withPatIds streamMuteAll streamHushstreamUnmuteAll streamAll streamSet streamSetI streamSetF streamSetS streamSetB streamSetR calcOutput startTidal startMulti ctrlListen $fEqTimeStamp$fShowTimeStamp$fShowOSCTarget$fShowPlayStatetidalEspGridLinkespgridcpsEsp carabinerclientlisteneractsendMsgmapBoth mapPartTimesmapFstmapSnddeltamid removeCommon readMaybe!!!nth accumulate enumeratewordsByscalegetScale scaleList scaleTablegrpmFmImSsoundsccpFpIpStoArgfromto accelerateampattackbandfbandqbeginchannellegato clhatdecaycoarsecrushcutcutoff cutoffegintdecaydelay delayfeedback delaytimedetunedjfdryendgaingatehatgrainhcutoffhold hresonancekriolelagogolclaplclaveslclhatlcrashleslielratelsizelfo lfocutoffintlfodelaylfoint lfopitchintlfoshapelfosynclhitomlkickllotomlocklooplophatlsnarennotedegree mtranspose ctransposeharmonicstepsPerOctave octaveRationudgeoctaveoffset ophatdecayorbitpanpanspanpansplaypanwidth panorientpitch1pitch2pitch3 portamentoraterelease resonanceroomsagogosclapsclavesscrashsemitoneshapesizeslidespeedsquizs' stutterdepth stuttertimesustaintomdecayunitvelocityvcfegintvcoegintvoicevowelwavelossdurmodwheel expression sustainpedal tremolorate tremolodepth phaserrate phaserdepthfshift fshiftphase fshiftnotetriodekrushkcutoffocteroctersub octersubsubringringfringdfdistortfreezexsdelaytsdelayrealimagenhancepartialscombsmearscrambinshifthbricklbrickattbpfbpqchdecayctfctfgdelayfbdelaytdetgathghpfhpqlaglbdlchlcllcplcrlfoclfoilfoplhtlltlohlpflpqlsnohdecayphasdpphasrpit1pit2pit3porrelsagsclscpscrszsldstdsttsustdecaytremdptremrvcfvcovoimidinotedrumdrumNarraymidichancontrolccnccvctlNum frameRateframeshoursmidicmdcommandminutesprogNumsecondssongPtruidvalupbutton0button1button2button3button4button5button6button7button8button9button10button11button12button13button14button15button16button17button18button19button20button21button22button23button24button25button26button27button28button29button30button31slider0slider1slider2slider3slider4slider5slider6slider7slider8slider9slider10slider11slider12slider13slider14slider15slider16slider17slider18slider19slider20slider21slider22slider23slider24slider25slider26slider27slider28slider29slider30slider31 timeToSeed timeToRand timeToRandsrandirand perlinWithperlin perlin2Withperlin2choosechooseBywchoose wchooseBy degradeBy _degradeBy unDegradeBy _unDegradeBy degradeOverBy sometimesBy sometimesoftenrarely almostNever almostAlwaysneveralways someCyclesBy somecyclesBy someCycles somecyclesdegradebrakiter_iteriter'_iter' palindromeseqPfadeOut fadeOutFromfadeIn fadeInFromspread slowspread fastspreadspread' spreadChoosespreadrifpwedgewhenmod superimposetrunc_trunclinger_lingerwithin withinArcwithin'revArceuclid_euclid euclidFull _euclidBool_euclid' euclidOffeoff _euclidOff euclidOffBool_euclidOffBooldistrib_distrib euclidInv _euclidInvindexrot_rotsegment_segment discretiserandcatfitpermstepstruct substructrandArcs randStruct substruct'stripe_stripe slowstripe parseLMRule parseLMRule' lindenmayer lindenmayerI runMarkov markovPat _markovPatmask enclosingArcstretchfit'chunkrunWithchunk'runWith'insideoutside loopFirsttimeLoopseqPLooptoScale'toScaleswingByswing cycleChoose_rearrangeWithshuffle_shufflescramble _scramblerandrunurinhabitspaceOutflatpatlayer arpeggiatearpgarpWitharp_arpply_plysewstitchstutterechotriplequaddoublejuxjuxcutjuxcut'jux'jux4juxBypicksamplessamples'spreadf stackwithrange_rangerangexoff_offoffaddstepstepsstep'ghost''ghost'ghosttabbyselect_selectselectF_selectFpickF_pickFcontrast contrastBy contrastRangefixunfixfixRange unfixRangequantiseinvmonosmoothswapsnowballsoak deconstructbitesqueeze squeezeJoinUpchew__binary_binarybinaryNbinaryasciiSignPositiveNegativeColourD EnumerablefromTo fromThenTo Parseable tPatParserdoEuclidTPat TPat_Atom TPat_Density TPat_Slow TPat_ZoomTPat_DegradeBy TPat_Silence TPat_Foot TPat_ElongateTPat_EnumFromToTPat_Cat TPat_TimeCat TPat_Overlay TPat_Stack TPat_ShiftLTPat_pETidalParseError parsecErrorcodetoPat durationsparseBP parseBP_E parseTPat enumFromTo'enumFromThenTo'lexerbracesbracketsparensanglessymbolnaturalintegerfloatnaturalOrFloat applySignsign intOrFloat parseRhythm pSequenceNelongate splitFeet pSequencepSinglepPartpPolyInpPolyOutpStringpVocablepDoublepBool parseIntNoteparseInt pIntegral parseChord parseNotefromNotepColourpMultpRandpE pReplicatepStretchpRatio pRational$fShowTidalParseError$fExceptionTidalParseError$fParseableRatio$fParseableInteger$fParseableInt$fParseableBool $fParseable[]$fParseableDouble$fIsStringPattern$fEnumerableRatio$fEnumerableInteger$fEnumerableInt$fEnumerableBool$fEnumerable[]$fEnumerableDouble$fEnumerableColour$fParseableColour$fEqTidalParseError $fShowTPatspin_spinchopchopArc_chopstriate_striatemergePlayRange striateBystriate' _striateBygap_gapweave weaveWithweave' interlaceslice_slice randsliceloopAthurrysmashsmash'stut_stutstutWith _stutWithstut'secmsec_triggertriggerqtriggerqt_getP__getP_cX_cX_cFcF_cF0cIcI_cI0cBcB_cB0cRcR_cR0cTcT0cT_cScS_cS0cPin0in1in2in3in4in5in6in7in8in9in10in11in12in13in14in15in16in17in18in19in20in21in22in23in24in25in26in27in28in29in30in31in32in33in34in35in36in37in38in39in40in41in42in43in44in45in46in47in48in49in50in51in52in53in54in55in56in57in58in59in60in61in62in63in64in65in66in67in68in69in70in71in72in73in74in75in76in77in78in79in80in81in82in83in84in85in86in87in88in89in90in91in92in93in94in95in96in97in98in99in100in101in102in103in104in105in106in107in108in109in110in111in112in113in114in115in116in117in118in119in120in121in122in123in124in125in126in127splice transition mortalOverlaywashwashInxfadeInhistpanwaitwaitTjumpjumpInjumpIn'jumpModmortal interpolate interpolateInclutchclutchIn anticipateIn anticipatecrunchscratchlouderquietersilentskipleftrighthigherlowerfasterslower tidal_versionbaseGHC.Real toRationalGHC.Basefmapghc-prim GHC.TypesTrue GHC.MaybeMaybeNothing FractionalDoubleGHC.List!!False.RatioRational Data.RatioapproxRational denominator numerator%