Safe Haskell  None 

Language  Haskell98 
 data Pattern a = Pattern {}
 showTime :: (Integral a, Show a) => Ratio a > String
 showArc :: (Integral a, Integral a1, Show a, Show a1) => (Ratio a, Ratio a1) > [Char]
 showEvent :: (Integral a, Integral a1, Show a, Show a1, Show a2) => ((Ratio a, Ratio a1), (Ratio a, Ratio a1), a2) > [Char]
 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 :: (Enum a, Num a) => a > Pattern a
 scan :: (Enum a, Num 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
 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 r => r > Double
 irand :: Double > Pattern Int
 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 a > Pattern a
 preplace :: (Time, Time) > Pattern a > Pattern a > Pattern a
 prep :: (Time, Time) > Pattern a > Pattern a > Pattern a
 preplace1 :: Pattern a > Pattern a > Pattern a
 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 a > Pattern a
 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
 toMIDI :: Pattern String > Pattern Int
 tom :: Pattern String > Pattern Int
 fit :: Int > [a] > Pattern Int > Pattern a
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 

showEvent :: (Integral a, Integral a1, Show a, Show a1, Show a2) => ((Ratio a, Ratio a1), (Ratio a, Ratio a1), a2) > [Char] Source
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 :: (Enum a, Num 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.
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
.
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
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.
slowspread :: (a > t > Pattern b) > [a] > t > Pattern b Source
filterValues :: (a > Bool) > Pattern a > Pattern a Source
filterOnsets :: Pattern a > Pattern a Source
filterStartInRange :: Pattern a > Pattern a Source
filterOnsetsInRange :: Pattern a > Pattern a Source
seqToRelOnsets :: Arc > Pattern a > [(Double, a)] Source
groupByTime :: [Event a] > [Event [a]] Source
ifp :: (Int > Bool) > (Pattern a > Pattern a) > (Pattern a > Pattern a) > Pattern a > Pattern a Source
timeToRand :: RealFrac r => r > Double Source
unDegradeBy :: Double > Pattern a > Pattern a Source
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.
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.
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 a > Pattern a Source
prr rot (blen, vlen) beatPattern valuePattern
: pattern rotate/replace.
preplace :: (Time, Time) > Pattern a > Pattern a > Pattern a 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" @
preplaceWith1 :: (a > b > c) > Pattern a > Pattern b > Pattern c Source
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.