Sound.Tidal.Pattern

Documentation

data Pattern a

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

atom is a synonym for pure.

silence :: Pattern a

silence returns a pattern with no events.

mapQueryArc :: (Arc -> Arc) -> Pattern a -> Pattern a

mapQueryArc f p returns a new Pattern with function f applied to the Arc values passed to the original Pattern p.

mapQueryTime :: (Time -> Time) -> Pattern a -> Pattern a

mapQueryTime 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.

mapResultArc :: (Arc -> Arc) -> Pattern a -> Pattern a

mapResultArc f p returns a new Pattern with function f applied to the Arc values in the events returned from the original Pattern p.

mapResultTime :: (Time -> Time) -> Pattern a -> Pattern a

mapResultTime 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

overlay combines two Patterns into a new pattern, so that their events are combined over time.

(>+<) :: Pattern a -> Pattern a -> Pattern a

stack :: [Pattern a] -> Pattern a

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

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

append' does the same as append, but over two cycles, so that the cycles alternate between the two patterns.

cat :: [Pattern a] -> Pattern a

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

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

listToPat turns the given list of values to a Pattern, which cycles through the list.

maybeListToPat :: [Maybe a] -> Pattern a

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

run n returns a pattern representing a cycle of numbers from 0 to n-1.

density :: Time -> Pattern a -> Pattern a

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.

slow :: Time -> Pattern a -> Pattern a

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

The <~ operator shift (or rotate) 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

The ~> operator does the same as ~> but shifts events to the right (or clockwise) rather than to the left.

rev :: Pattern a -> Pattern a

rev p returns p with the event positions in each cycle reversed (or mirrored).

palindrome :: Pattern a -> Pattern a

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

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

every n f p applies the function f to p, but only affects every n cycles.

sig :: (Time -> a) -> Pattern a

sig f takes a function from time to values, and turns it into a Pattern.

sinewave :: Pattern Double

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

sine is a synonym for @sinewave.

sinerat :: Pattern Rational

sinerat is equivalent to sinewave for Rational values, suitable for use as Time offsets.

ratsine :: Pattern Rational

sinewave1 :: Pattern Double

sinewave1 is equivalent to sinewave, but with amplitude from 0 to 1.

sine1 :: Pattern Double

sine1 is a synonym for sinewave1.

sinerat1 :: Pattern Rational

sinerat1 is equivalent to sinerat, but with amplitude from 0 to 1.

sineAmp1 :: Double -> Pattern Double

sineAmp1 d returns sinewave1 with its amplitude offset by d.

sawwave :: Pattern Double

sawwave is the equivalent of sinewave for sawtooth waves.

saw :: Pattern Double

saw is a synonym for sawwave.

sawrat :: Pattern Rational

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

sawwave1 :: Pattern Double

saw1 :: Pattern Double

sawrat1 :: Pattern Rational

triwave :: Pattern Double

triwave is the equivalent of sinewave for triangular waves.

tri :: Pattern Double

tri is a synonym for triwave.

trirat :: Pattern Rational

trirat is the same as triwave but returns Rational values suitable for use as Time offsets.

triwave1 :: Pattern Double

tri1 :: Pattern Double

trirat1 :: Pattern Rational

squarewave1 :: Pattern Double

square1 :: Pattern Double

squarewave :: Pattern Double

square :: Pattern Double

filterOffsets :: 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