Safe Haskell  None 

Language  Haskell98 
 data Pattern a = Pattern {}
 showTime :: (Show a, Integral a) => Ratio a > String
 showArc :: Arc > String
 showEvent :: Show a => Event a > String
 unwrap :: Pattern (Pattern a) > Pattern a
 atom :: a > Pattern a
 silence :: Pattern a
 withQueryArc :: (Arc > Arc) > Pattern a > Pattern a
 withQueryTime :: (Time > Time) > Pattern a > Pattern a
 withResultArc :: (Arc > Arc) > Pattern a > Pattern a
 withResultTime :: (Time > Time) > Pattern a > Pattern a
 overlay :: Pattern a > Pattern a > Pattern a
 stack :: [Pattern a] > Pattern a
 append :: Pattern a > Pattern a > Pattern a
 append' :: Pattern a > Pattern a > Pattern a
 cat :: [Pattern a] > Pattern a
 splitAtSam :: Pattern a > Pattern a
 slowcat :: [Pattern a] > Pattern a
 listToPat :: [a] > Pattern a
 maybeListToPat :: [Maybe a] > Pattern a
 run :: (Num a, Enum a) => a > Pattern a
 scan :: (Num a, Enum a) => a > Pattern a
 density :: Time > Pattern a > Pattern a
 densityGap :: Time > Pattern a > Pattern a
 slow :: Time > Pattern a > Pattern a
 (<~) :: Time > Pattern a > Pattern a
 (~>) :: Time > Pattern a > Pattern a
 brak :: Pattern a > Pattern a
 iter :: Int > Pattern a > Pattern a
 iter' :: Int > Pattern a > Pattern a
 rev :: Pattern a > Pattern a
 palindrome :: Pattern a > Pattern a
 when :: (Int > Bool) > (Pattern a > Pattern a) > Pattern a > Pattern a
 whenT :: (Time > Bool) > (Pattern a > Pattern a) > Pattern a > Pattern a
 playWhen :: (Time > Bool) > Pattern a > Pattern a
 playFor :: Time > Time > Pattern a > Pattern a
 seqP :: [(Time, Time, Pattern a)] > Pattern a
 every :: Int > (Pattern a > Pattern a) > Pattern a > Pattern a
 foldEvery :: [Int] > (Pattern a > Pattern a) > Pattern a > Pattern a
 sig :: (Time > a) > Pattern a
 sinewave :: Pattern Double
 sine :: Pattern Double
 sinerat :: Pattern Rational
 ratsine :: Pattern Rational
 sinewave1 :: Pattern Double
 sine1 :: Pattern Double
 sinerat1 :: Pattern Rational
 sineAmp1 :: Double > Pattern Double
 sawwave :: Pattern Double
 saw :: Pattern Double
 sawrat :: Pattern Rational
 sawwave1 :: Pattern Double
 saw1 :: Pattern Double
 sawrat1 :: Pattern Rational
 triwave :: Pattern Double
 tri :: Pattern Double
 trirat :: Pattern Rational
 triwave1 :: Pattern Double
 tri1 :: Pattern Double
 trirat1 :: Pattern Rational
 squarewave1 :: Pattern Double
 square1 :: Pattern Double
 squarewave :: Pattern Double
 square :: Pattern Double
 envL :: Pattern Double
 envLR :: Pattern Double
 envEq :: Pattern Double
 envEqR :: Pattern Double
 fadeOut :: Time > Pattern a > Pattern a
 fadeOut' :: Time > Time > Pattern a > Pattern a
 fadeIn' :: Time > Time > Pattern a > Pattern a
 fadeIn :: Time > Pattern a > Pattern a
 spread :: (a > t > Pattern b) > [a] > t > Pattern b
 slowspread :: (a > t > Pattern b) > [a] > t > Pattern b
 spread' :: (a > Pattern b > Pattern c) > Pattern a > Pattern b > Pattern c
 filterValues :: (a > Bool) > Pattern a > Pattern a
 filterOnsets :: Pattern a > Pattern a
 filterStartInRange :: Pattern a > Pattern a
 filterOnsetsInRange :: Pattern a > Pattern a
 seqToRelOnsets :: Arc > Pattern a > [(Double, a)]
 segment :: Pattern a > Pattern [a]
 segment' :: [Event a] > [Event a]
 split :: Time > [Event a] > [Event a]
 points :: [Event a] > [Time]
 groupByTime :: [Event a] > [Event [a]]
 ifp :: (Int > Bool) > (Pattern a > Pattern a) > (Pattern a > Pattern a) > Pattern a > Pattern a
 rand :: Pattern Double
 timeToRand :: RealFrac a => a > Double
 irand :: Int > Pattern Int
 choose :: [a] > Pattern a
 degradeBy :: Double > Pattern a > Pattern a
 unDegradeBy :: Double > Pattern a > Pattern a
 sometimesBy :: Double > (Pattern a > Pattern a) > Pattern a > Pattern a
 sometimes :: (Pattern a > Pattern a) > Pattern a > Pattern a
 often :: (Pattern a > Pattern a) > Pattern a > Pattern a
 rarely :: (Pattern a > Pattern a) > Pattern a > Pattern a
 almostNever :: (Pattern a > Pattern a) > Pattern a > Pattern a
 almostAlways :: (Pattern a > Pattern a) > Pattern a > Pattern a
 degrade :: Pattern a > Pattern a
 wedge :: Time > Pattern a > Pattern a > Pattern a
 whenmod :: Int > Int > (Pattern a > Pattern a) > Pattern a > Pattern a
 superimpose :: (Pattern a > Pattern a) > Pattern a > Pattern a
 splitQueries :: Pattern a > Pattern a
 trunc :: Time > Pattern a > Pattern a
 zoom :: Arc > Pattern a > Pattern a
 compress :: Arc > Pattern a > Pattern a
 sliceArc :: Arc > Pattern a > Pattern a
 within :: Arc > (Pattern a > Pattern a) > Pattern a > Pattern a
 revArc :: Arc > Pattern a > Pattern a
 e :: Int > Int > Pattern a > Pattern a
 e' :: Int > Int > Pattern a > Pattern a
 index :: Real b => b > Pattern b > Pattern c > Pattern c
 prrw :: (a > b > c) > Int > (Time, Time) > Pattern a > Pattern b > Pattern c
 prr :: Int > (Time, Time) > Pattern a > Pattern b > Pattern b
 preplace :: (Time, Time) > Pattern a > Pattern b > Pattern b
 prep :: (Time, Time) > Pattern a > Pattern b > Pattern b
 preplace1 :: Pattern a > Pattern b > Pattern b
 preplaceWith :: (a > b > c) > (Time, Time) > Pattern a > Pattern b > Pattern c
 prw :: (a > b > c) > (Time, Time) > Pattern a > Pattern b > Pattern c
 preplaceWith1 :: (a > b > c) > Pattern a > Pattern b > Pattern c
 prw1 :: (a > b > c) > Pattern a > Pattern b > Pattern c
 (<~>) :: Pattern a > Pattern b > Pattern b
 protate :: Time > Int > Pattern a > Pattern a
 prot :: Time > Int > Pattern a > Pattern a
 prot1 :: Int > Pattern a > Pattern a
 (<<~) :: Int > Pattern a > Pattern a
 (~>>) :: Int > Pattern a > Pattern a
 pequal :: Ord a => Time > Pattern a > Pattern a > Bool
 discretise :: Time > Pattern a > Pattern a
 randcat :: [Pattern a] > Pattern a
 fit :: Int > [a] > Pattern Int > Pattern a
 permstep :: RealFrac b => Int > [a] > Pattern b > Pattern a
 struct :: Pattern String > Pattern a > Pattern a
 parseLMRule :: String > [(String, String)]
 parseLMRule' :: String > [(Char, String)]
 lindenmayer :: Int > String > String > String
 unwrap' :: Pattern (Pattern a) > Pattern a
 mask :: Pattern a > Pattern b > Pattern b
 enclosingArc :: [Arc] > Arc
 stretch :: Pattern a > Pattern a
 fit' :: Time > Int > Pattern Int > Pattern Int > Pattern a > Pattern a
 runWith :: Integral a => a > (Pattern b > Pattern b) > Pattern b > Pattern b
 runWith' :: Integral a => a > (Pattern b > Pattern b) > Pattern b > Pattern b
Documentation
The pattern datatype, a function from a time Arc
to Event
values. For discrete patterns, this returns the events which are
active during that time. For continuous patterns, events with
values for the midpoint of the given Arc
is returned.
Monad Pattern Source #  
Functor Pattern Source #  
Applicative Pattern Source # 

Show a => Show (Pattern a) Source # 

Monoid (Pattern a) Source # 

showTime :: (Show a, Integral a) => Ratio a > String Source #
converts a ratio into human readable string, e.g. 1/3
showEvent :: Show a => Event a > String Source #
converts an event into human readable string, e.g. ("bd" 14 23)
withQueryArc :: (Arc > Arc) > Pattern a > Pattern a Source #
withQueryArc f p
returns a new Pattern
with function f
applied to the Arc
values passed to the original Pattern
p
.
withQueryTime :: (Time > Time) > Pattern a > Pattern a Source #
withQueryTime f p
returns a new Pattern
with function f
applied to the both the start and end Time
of the Arc
passed to
Pattern
p
.
withResultArc :: (Arc > Arc) > Pattern a > Pattern a Source #
withResultArc f p
returns a new Pattern
with function f
applied to the Arc
values in the events returned from the
original Pattern
p
.
withResultTime :: (Time > Time) > Pattern a > Pattern a Source #
withResultTime f p
returns a new Pattern
with function f
applied to the both the start and end Time
of the Arc
values in
the events returned from the original Pattern
p
.
overlay :: Pattern a > Pattern a > Pattern a Source #
overlay
combines two Pattern
s into a new pattern, so that
their events are combined over time. This is the same as the infix
operator <>
.
stack :: [Pattern a] > Pattern a Source #
stack
combines a list of Pattern
s into a new pattern, so that
their events are combined over time.
append :: Pattern a > Pattern a > Pattern a Source #
append
combines two patterns Pattern
s into a new pattern, so
that the events of the second pattern are appended to those of the
first pattern, within a single cycle
append' :: Pattern a > Pattern a > Pattern a Source #
append'
does the same as append
, but over two cycles, so that
the cycles alternate between the two patterns.
cat :: [Pattern a] > Pattern a Source #
cat
returns a new pattern which interlaces the cycles of the
given patterns, within a single cycle. It's the equivalent of
append
, but with a list of patterns.
splitAtSam :: Pattern a > Pattern a Source #
slowcat :: [Pattern a] > Pattern a Source #
slowcat
does the same as cat
, but maintaining the duration of
the original patterns. It is the equivalent of append'
, but with
a list of patterns.
listToPat :: [a] > Pattern a Source #
listToPat
turns the given list of values to a Pattern, which
cycles through the list.
maybeListToPat :: [Maybe a] > Pattern a Source #
maybeListToPat
is similar to listToPat
, but allows values to
be optional using the Maybe
type, so that Nothing
results in
gaps in the pattern.
run :: (Num a, Enum a) => a > Pattern a Source #
run
n
returns a pattern representing a cycle of numbers from 0
to n1
.
density :: Time > Pattern a > Pattern a Source #
density
returns the given pattern with density increased by the
given Time
factor. Therefore density 2 p
will return a pattern
that is twice as fast, and density (1%3) p
will return one three
times as slow.
densityGap :: Time > Pattern a > Pattern a Source #
densityGap
is similar to density
but maintains its cyclic
alignment. For example, densityGap 2 p
would squash the events in
pattern p
into the first half of each cycle (and the second
halves would be empty).
slow :: Time > Pattern a > Pattern a Source #
slow
does the opposite of density
, i.e. slow 2 p
will
return a pattern that is half the speed.
(<~) :: Time > Pattern a > Pattern a Source #
The <~
operator shifts (or rotates) a pattern to the left (or
counterclockwise) by the given Time
value. For example
(1%16) <~ p
will return a pattern with all the events moved
one 16th of a cycle to the left.
(~>) :: Time > Pattern a > Pattern a Source #
The ~>
operator does the same as ~>
but shifts events to the
right (or clockwise) rather than to the left.
brak :: Pattern a > Pattern a Source #
(The above means that brak
is a function from patterns of any type,
to a pattern of the same type.)
Make a pattern sound a bit like a breakbeat
Example:
d1 $ sound (brak "bd sn kurt")
iter :: Int > Pattern a > Pattern a Source #
Divides 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"
This will produce the following over four cycles:
bd hh sn cp hh sn cp bd sn cp bd hh cp bd hh sn
There is also iter'
, which shifts the pattern in the opposite direction.
rev :: Pattern a > Pattern a Source #
rev p
returns p
with the event positions in each cycle
reversed (or mirrored).
palindrome :: Pattern a > Pattern a Source #
palindrome p
applies rev
to p
every other cycle, so that
the pattern alternates between forwards and backwards.
when :: (Int > Bool) > (Pattern a > Pattern a) > Pattern a > Pattern a Source #
when test f p
applies the function f
to p
, but in a way
which only affects cycles where the test
function applied to the
cycle number returns True
.
seqP :: [(Time, Time, Pattern a)] > Pattern a Source #
There is a similar function named seqP
which allows you to define when
a sound within a list starts and ends. The code below contains three
separate patterns in a "stack", 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))) ]
every :: Int > (Pattern a > Pattern a) > Pattern a > Pattern a Source #
every n f p
applies the function f
to p
, but only affects
every n
cycles.
foldEvery :: [Int] > (Pattern a > Pattern a) > Pattern a > Pattern a Source #
foldEvery ns f p
applies the function f
to p
, and is applied for
each cycle in ns
.
sig :: (Time > a) > Pattern a Source #
sig f
takes a function from time to values, and turns it into a
Pattern
.
sinewave :: Pattern Double Source #
sinewave
returns a Pattern
of continuous Double
values following a
sinewave with frequency of one cycle, and amplitude from 1 to 1.
sinerat :: Pattern Rational Source #
sinerat
is equivalent to sinewave
for Rational
values,
suitable for use as Time
offsets.
sinewave1 :: Pattern Double Source #
sinewave1
is equivalent to sinewave
, but with amplitude from 0 to 1.
sinerat1 :: Pattern Rational Source #
sinerat1
is equivalent to sinerat
, but with amplitude from 0 to 1.
sineAmp1 :: Double > Pattern Double Source #
sineAmp1 d
returns sinewave1
with its amplitude offset by d
.
sawrat :: Pattern Rational Source #
sawrat
is the same as sawwave
but returns Rational
values
suitable for use as Time
offsets.
trirat :: Pattern Rational Source #
trirat
is the same as triwave
but returns Rational
values
suitable for use as Time
offsets.
envL :: Pattern Double Source #
envL
is a Pattern
of continuous Double
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.
spread :: (a > t > Pattern b) > [a] > t > Pattern b Source #
(The above is difficult to describe, if you don't understand Haskell, just read the description and examples..)
The spread
function allows you to take a pattern transformation
which takes a parameter, such as slow
, 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"
Or 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 spread
, we can make a pattern which alternates between
the two speeds:
d1 $ spread slow [2,4%3] $ sound "ho ho:2 ho:3 hc"
slowspread :: (a > t > Pattern b) > [a] > t > Pattern b Source #
slowspread
takes a list of pattern transforms and applies them one at a time, per cycle,
then repeats.
Example:
d1 $ slowspread ($) [density 2, rev, slow 2, striate 3, (# speed "0.8")] $ sound "[bd*2 [~ bd]] [sn future]*2 cp jvbass*4"
Above, the pattern will have these transforms applied to it, one at a time, per cycle:
 cycle 1: `density 2`  pattern will increase in speed
 cycle 2:
rev
 pattern will be reversed  cycle 3: `slow 2`  pattern will decrease in speed
 cycle 4: `striate 3`  pattern will be granualized
 cycle 5: `(# speed "0.8")`  pattern samples will be played back more slowly
After `(# speed "0.8")`, the transforms will repeat and start at `density 2` again.
spread' :: (a > Pattern b > Pattern c) > Pattern a > Pattern b > Pattern c Source #
There's a version of this function, spread'
(pronounced "spread prime"), which takes a *pattern* of parameters, instead of a list:
d1 $ 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 spread'
though is that you can provide polyphonic parameters, e.g.:
d1 $ spread' slow "[2 4%3, 3]" $ sound "ho ho:2 ho:3 hc"
filterOnsets :: Pattern a > Pattern a Source #
filterStartInRange :: Pattern a > Pattern a Source #
filterOnsetsInRange :: Pattern a > Pattern a Source #
groupByTime :: [Event a] > [Event [a]] Source #
ifp :: (Int > Bool) > (Pattern a > Pattern a) > (Pattern a > Pattern a) > Pattern a > Pattern a Source #
rand :: Pattern Double Source #
rand
generates a continuous pattern of (pseudo)random, floating point numbers between `0` and `1`.
d1 $ sound "bd*8" # pan rand
pans bass drums randomly
d1 $ sound "sn sn ~ sn" # gain rand
makes the snares' randomly loud and quiet.
Numbers coming from this pattern are random, but dependent on time. So if you reset time via `cps (1)` 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:
d1 $ jux (+ gain rand) $ sound "sn sn ~ sn" # gain rand
and with the juxed version shifted backwards for 1024 cycles:
d1 $ jux (+ ((1024 <~) $ gain rand)) $ sound "sn sn ~ sn" # gain rand
timeToRand :: RealFrac a => a > Double Source #
irand :: Int > Pattern Int Source #
Just like rand
but for integers, `irand n` generates a pattern of (pseudo)random integers between `0` to `n1` inclusive. Notably used to pick a random
samples from a folder:
d1 $ sound (samples "drum*4" (irand 5))
choose :: [a] > Pattern a Source #
Randomly picks an element from the given list
d1 $ sound (samples "xx(3,8)" (tom $ choose ["a", "e", "g", "c"]))
plays a melody randomly choosing one of the four notes: `"a"`, `"e"`, `"g"`, `"c"`
sometimesBy :: Double > (Pattern a > Pattern a) > Pattern a > Pattern a Source #
Use sometimesBy
to apply a given function "sometimes". For example, the
following code results in `density 2` being applied about 25% of the time:
d1 $ 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
degrade :: Pattern a > Pattern a Source #
degrade
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:
d1 $ slow 2 $ sound "bd ~ sn bd ~ bd? [sn bd?] ~"
You can also use ?
to randomly remove events from entire subpatterns:
d1 $ slow 2 $ sound "[[[feel:5*8,feel*3] feel:3*8]?, feel*4]"
wedge :: Time > Pattern a > Pattern a > Pattern a Source #
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.
whenmod :: Int > Int > (Pattern a > Pattern a) > Pattern a > Pattern a Source #
whenmod
has a similar form and behavior to every
, 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 less than the second parameter.
For example the following makes every other block of four loops twice as dense:
d1 $ whenmod 8 4 (density 2) (sound "bd sn kurt")
superimpose :: (Pattern a > Pattern a) > Pattern a > Pattern a Source #
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.
d1 $ superimpose (density 2) $ sound "bd sn [cp ht] hh" d1 $ superimpose ((# speed "2") . (0.125 <~)) $ sound "bd sn cp hh"
splitQueries :: Pattern a > Pattern a Source #
splitQueries p
wraps p
to ensure that it does not get
queries that span arcs. For example `arc 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.
trunc :: Time > Pattern a > Pattern a Source #
Truncates a pattern so that only a fraction of the pattern is played. The following example plays only the first three quarters of the pattern:
d1 $ trunc 0.75 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
zoom :: Arc > Pattern a > Pattern a Source #
Plays a portion of a pattern, specified by a beginning and end arc of 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, zoom
is used with an arc from 25% to 75%. It is equivalent to this pattern:
d1 $ sound "hh*3 [sn bd]*2"
within :: Arc > (Pattern a > Pattern a) > Pattern a > Pattern a Source #
Use within
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:
d1 $ within (0, 0.5) (density 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"
prrw :: (a > b > c) > Int > (Time, Time) > Pattern a > Pattern b > Pattern c Source #
prr rot (blen, vlen) beatPattern valuePattern
: pattern rotate/replace.
prr :: Int > (Time, Time) > Pattern a > Pattern b > Pattern b Source #
prr rot (blen, vlen) beatPattern valuePattern
: pattern rotate/replace.
preplace :: (Time, Time) > Pattern a > Pattern b > Pattern b Source #
preplace (blen, plen) beats values
combines the timing of beats
with the values
of values
. Other ways of saying this are:
* sequential convolution
* values
quantized to beats
.
Examples:
d1 $ sound $ preplace (1,1) "x [~ x] x x" "bd sn"
d1 $ sound $ preplace (1,1) "x(3,8)" "bd sn"
d1 $ sound $ "x(3,8)" ~ "bd sn"
d1 $ sound "[jvbass jvbass:5]*3" + (shape $ "1 1 1 1 1" ~ "0.2 0.9")
It is assumed the pattern fits into a single cycle. This works well with
pattern literals, but not always with patterns defined elsewhere. In those cases
use prr
and provide desired pattern lengths:
@
let p = slow 2 $ "x x x"
d1 $ sound $ prr 0 (2,1) p "bd sn" @
protate :: Time > Int > Pattern a > Pattern a Source #
protate len rot p
rotates pattern p
by rot
beats to the left.
len
: length of the pattern, in cycles.
Example: d1 $ every 4 (protate 2 (1)) $ slow 2 $ sound "bd hh hh hh"
(<<~) :: Int > Pattern a > Pattern a Source #
The <<~
operator rotates a unit pattern to the left, similar to <~
,
but by events rather than linear time. The timing of the pattern remains constant:
d1 $ (1 <<~) $ sound "bd ~ sn hh"  will become d1 $ sound "sn ~ hh bd"
pequal :: Ord a => Time > Pattern a > Pattern a > Bool Source #
pequal cycles p1 p2
: quickly test if p1
and p2
are the same.
discretise :: Time > Pattern a > Pattern a Source #
discretise n p
: samples
the pattern p
at a rate of n
events per cycle. Useful for turning a continuous pattern into a
discrete one.
randcat :: [Pattern a] > Pattern a Source #
randcat ps
: does a slowcat
on the list of patterns ps
but
randomises the order in which they are played.
fit :: Int > [a] > Pattern Int > Pattern a Source #
fromNote p
: converts a pattern of humanreadable pitch names
into pitch numbers. For example, "cs2"
will be parsed as C Sharp
in the 2nd octave with the result of 11
, and "b3"
as
25
. Pitches can be decorated using:
 s = Sharp, a halfstep above (
"gs1"
)  f = Flat, a halfstep below (
"gf1"
)  n = Natural, no decoration (
"g1" and "gn1"
are equivalent)  ss = Double sharp, a whole step above (
"gss1"
)  ff = Double flat, a whole step below (
"gff1"
)
Note that TidalCycles now assumes that middle C is represented by
the value 0, rather than the previous value of 60. This function
is similar to previously available functions tom
and toMIDI
,
but the default octave is now 0 rather than 5.
tom p
: Alias for toMIDI
.
tom = toMIDI
The fit
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).
struct :: Pattern String > Pattern a > Pattern a Source #
struct a b
: structures pattern b
in terms of a
.
lindenmayer :: Int > String > String > String Source #
returns the n
th iteration of a Lindenmayer System with given start sequence.
for example:
~~~~{haskell}
lindenmayer 1 "a:b,b:ab" "ab" > "bab"
~~~~
mask :: Pattern a > Pattern b > Pattern b Source #
removes events from pattern b that don't start during an event from pattern a
enclosingArc :: [Arc] > Arc Source #
fit' :: Time > Int > Pattern Int > Pattern Int > Pattern a > Pattern a Source #
fit'
is a generalization of fit
, 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 chop
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.