tidal-0.4.23: Pattern language for improvised music

Safe HaskellNone
LanguageHaskell98

Sound.Tidal.Pattern

Synopsis

Documentation

data Pattern a Source

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.

Constructors

Pattern 

Fields

arc :: Arc -> [Event a]
 

Instances

Monad Pattern 
Functor Pattern 
Applicative Pattern

pure a returns a pattern with an event with value a, which has a duration of one cycle, and repeats every cycle.

Show a => Show (Pattern a)

show (p :: Pattern) returns a text string representing the event values active during the first cycle of the given pattern.

Parseable a => IsString (Pattern a) 
Monoid (Pattern a)

mempty is a synonym for silence. | mappend is a synonym for overlay.

atom :: a -> Pattern a Source

atom is a synonym for pure.

silence :: Pattern a Source

silence returns a pattern with no events.

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 Patterns into a new pattern, so that their events are combined over time.

stack :: [Pattern a] -> Pattern a Source

stack combines a list of Patterns into a new pattern, so that their events are combined over time.

append :: Pattern a -> Pattern a -> Pattern a Source

append combines two patterns Patterns 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.

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 n-1.

scan :: (Num a, Enum a) => a -> Pattern a Source

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 counter-clockwise) 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.

whenT :: (Time -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a Source

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.

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.

sine :: Pattern Double Source

sine is a synonym for @sinewave.

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.

sine1 :: Pattern Double Source

sine1 is a synonym for sinewave1.

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.

sawwave :: Pattern Double Source

sawwave is the equivalent of sinewave for sawtooth waves.

saw :: Pattern Double Source

saw is a synonym for sawwave.

sawrat :: Pattern Rational Source

sawrat is the same as sawwave but returns Rational values suitable for use as Time offsets.

triwave :: Pattern Double Source

triwave is the equivalent of sinewave for triangular waves.

tri :: Pattern Double Source

tri is a synonym for triwave.

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

slowspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b Source

spread' :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c Source

filterValues :: (a -> Bool) -> Pattern a -> Pattern a Source

segment' :: [Event a] -> [Event a] Source

split :: Time -> [Event a] -> [Event a] Source

points :: [Event a] -> [Time] Source

groupByTime :: [Event a] -> [Event [a]] Source

ifp :: (Int -> Bool) -> (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a Source

often :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a Source

rarely :: (Pattern a -> Pattern a) -> 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.

whenmod :: Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a Source

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.

within :: Arc -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a Source

e :: Int -> Int -> Pattern a -> Pattern a Source

e' :: Int -> Int -> Pattern a -> Pattern a Source