tidal-1.10.1: Pattern language for improvised music
Safe HaskellNone
LanguageHaskell2010

Sound.Tidal.Boot

Synopsis

Documentation

class Tidally where Source #

Functions using this constraint can access the in-scope Tidal instance. You must implement an instance of this in hs. Note that GHC will complain that it is an "orphan" instance, but that is ok.

Methods

tidal :: Stream Source #

type OscMap = [(Target, [OSC])] Source #

mkOscMap :: OscMap Source #

A reasonable OscMap

mkTidal :: IO Stream Source #

Creates a Tidal instance using default config. Use mkTidalWith to customize.

only :: Tidally => IO () -> IO () Source #

hush then execute the given action.

_p :: Tidally => ID -> ControlPattern -> IO () Source #

Silences a specific stream, regardless of ControlPattern input. Useful for rapid muting of streams

p_ :: Tidally => ID -> ControlPattern -> IO () Source #

Silences a specific stream, regardless of ControlPattern input. Useful for rapid muting of streams

mute :: Tidally => ID -> IO () Source #

solo :: Tidally => ID -> IO () Source #

asap :: Tidally => ControlPattern -> IO () Source #

An alias for once.

d1 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d2 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d3 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d4 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d5 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d6 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d7 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d8 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d9 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d10 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d11 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d12 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d13 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d14 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d15 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

d16 :: Tidally => ControlPattern -> IO () Source #

Replace what's playing on the given orbit.

_d1 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d2 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d3 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d4 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d5 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d6 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d7 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d8 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d9 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d10 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d11 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d12 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d13 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d14 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d15 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

_d16 :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d1_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d2_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d3_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d4_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d5_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d6_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d7_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d8_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d9_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d10_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d11_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d12_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d13_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d14_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d15_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

d16_ :: Tidally => ControlPattern -> IO () Source #

Rapidly silence what's playing on the given orbit

freeze :: Pattern Double -> ControlPattern #

Spectral freeze

index :: Real b => b -> Pattern b -> Pattern c -> Pattern c #

range :: Num a => Pattern a -> Pattern a -> Pattern a -> Pattern a #

range will take a pattern which goes from 0 to 1 (like sine), 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.

d1 $ jux (iter 4) $ sound "arpy arpy:2*2"
  |+ speed (slow 4 $ range 1 1.5 sine1)

The above is equivalent to:

d1 $ jux (iter 4) $ sound "arpy arpy:2*2"
  |+ speed (slow 4 $ sine1 * 0.5 + 1)

show :: Show a => a -> String #

A specialised variant of showsPrec, using precedence context zero, and returning an ordinary String.

type Rational = Ratio Integer #

Arbitrary-precision rational numbers, represented as a ratio of two Integer values. A rational number may be constructed using the % operator.

mask :: Pattern Bool -> Pattern a -> Pattern a #

mask takes a boolean pattern and ‘masks’ another pattern with it. That is, events are only carried over if they match within a ‘true’ event in the binary pattern, i.e., it removes events from the second pattern that don't start during an event from the first.

For example, consider 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

d1 $ 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 slowcat 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 slowcat 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.,

d1 $ s ( mask ("1 ~ 1 ~ 1 1 ~ 1")
         ( slowcat ["can*8", "[cp*4 sn*4, jvbass*16]"] )
       )
  # n (run 8)

loop :: Pattern Double -> ControlPattern #

loops the sample (from begin to end) the specified number of times.

fromList :: [a] -> Pattern a #

Turns a list of values into a pattern, playing one of them per cycle. The following are equivalent:

d1 $ n (fromList [0, 1, 2]) # s "superpiano"
d1 $ n "<0 1 2>" # s "superpiano"

(*>) :: Pattern (a -> b) -> Pattern a -> Pattern b infixl 4 #

Like *, but the "wholes" come from the right

data Ratio a #

Rational numbers, with numerator and denominator of some Integral type.

Note that Ratio's instances inherit the deficiencies from the type parameter's. For example, Ratio Natural's Num instance has similar problems to Natural's.

Instances

Instances details
NFData1 Ratio

Available on base >=4.9

Since: deepseq-1.4.3.0

Instance details

Defined in Control.DeepSeq

Methods

liftRnf :: (a -> ()) -> Ratio a -> () #

Enumerable Rational 
Instance details

Defined in Sound.Tidal.ParseBP

Parseable Rational 
Instance details

Defined in Sound.Tidal.ParseBP

Moddable Rational 
Instance details

Defined in Sound.Tidal.Pattern

Methods

gmod :: Rational -> Rational -> Rational #

Valuable Rational 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toValue :: Rational -> Value #

Integral a => Lift (Ratio a :: Type) 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Ratio a -> m Exp #

liftTyped :: forall (m :: Type -> Type). Quote m => Ratio a -> Code m (Ratio a) #

(Data a, Integral a) => Data (Ratio a)

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ratio a -> c (Ratio a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ratio a) #

toConstr :: Ratio a -> Constr #

dataTypeOf :: Ratio a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ratio a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ratio a)) #

gmapT :: (forall b. Data b => b -> b) -> Ratio a -> Ratio a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Ratio a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ratio a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) #

(Storable a, Integral a) => Storable (Ratio a)

Since: base-4.8.0.0

Instance details

Defined in Foreign.Storable

Methods

sizeOf :: Ratio a -> Int #

alignment :: Ratio a -> Int #

peekElemOff :: Ptr (Ratio a) -> Int -> IO (Ratio a) #

pokeElemOff :: Ptr (Ratio a) -> Int -> Ratio a -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Ratio a) #

pokeByteOff :: Ptr b -> Int -> Ratio a -> IO () #

peek :: Ptr (Ratio a) -> IO (Ratio a) #

poke :: Ptr (Ratio a) -> Ratio a -> IO () #

Integral a => Enum (Ratio a)

Since: base-2.0.1

Instance details

Defined in GHC.Real

Methods

succ :: Ratio a -> Ratio a #

pred :: Ratio a -> Ratio a #

toEnum :: Int -> Ratio a #

fromEnum :: Ratio a -> Int #

enumFrom :: Ratio a -> [Ratio a] #

enumFromThen :: Ratio a -> Ratio a -> [Ratio a] #

enumFromTo :: Ratio a -> Ratio a -> [Ratio a] #

enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] #

Integral a => Num (Ratio a)

Since: base-2.0.1

Instance details

Defined in GHC.Real

Methods

(+) :: Ratio a -> Ratio a -> Ratio a #

(-) :: Ratio a -> Ratio a -> Ratio a #

(*) :: Ratio a -> Ratio a -> Ratio a #

negate :: Ratio a -> Ratio a #

abs :: Ratio a -> Ratio a #

signum :: Ratio a -> Ratio a #

fromInteger :: Integer -> Ratio a #

(Integral a, Read a) => Read (Ratio a)

Since: base-2.1

Instance details

Defined in GHC.Read

Integral a => Fractional (Ratio a)

Since: base-2.0.1

Instance details

Defined in GHC.Real

Methods

(/) :: Ratio a -> Ratio a -> Ratio a #

recip :: Ratio a -> Ratio a #

fromRational :: Rational -> Ratio a #

Integral a => Real (Ratio a)

Since: base-2.0.1

Instance details

Defined in GHC.Real

Methods

toRational :: Ratio a -> Rational #

Integral a => RealFrac (Ratio a)

Since: base-2.0.1

Instance details

Defined in GHC.Real

Methods

properFraction :: Integral b => Ratio a -> (b, Ratio a) #

truncate :: Integral b => Ratio a -> b #

round :: Integral b => Ratio a -> b #

ceiling :: Integral b => Ratio a -> b #

floor :: Integral b => Ratio a -> b #

Show a => Show (Ratio a)

Since: base-2.0.1

Instance details

Defined in GHC.Real

Methods

showsPrec :: Int -> Ratio a -> ShowS #

show :: Ratio a -> String #

showList :: [Ratio a] -> ShowS #

NFData a => NFData (Ratio a) 
Instance details

Defined in Control.DeepSeq

Methods

rnf :: Ratio a -> () #

Eq a => Eq (Ratio a)

Since: base-2.1

Instance details

Defined in GHC.Real

Methods

(==) :: Ratio a -> Ratio a -> Bool #

(/=) :: Ratio a -> Ratio a -> Bool #

Integral a => Ord (Ratio a)

Since: base-2.0.1

Instance details

Defined in GHC.Real

Methods

compare :: Ratio a -> Ratio a -> Ordering #

(<) :: Ratio a -> Ratio a -> Bool #

(<=) :: Ratio a -> Ratio a -> Bool #

(>) :: Ratio a -> Ratio a -> Bool #

(>=) :: Ratio a -> Ratio a -> Bool #

max :: Ratio a -> Ratio a -> Ratio a #

min :: Ratio a -> Ratio a -> Ratio a #

(<*) :: Pattern (a -> b) -> Pattern a -> Pattern b infixl 4 #

Like *, but the "wholes" come from the left

when :: (Int -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

The given pattern transformation is applied only when the given test function returns True. 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.

(%) :: Integral a => a -> a -> Ratio a infixl 7 #

Forms the ratio of two integral numbers.

numerator :: Ratio a -> a #

Extract the numerator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.

denominator :: Ratio a -> a #

Extract the denominator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.

swap :: Eq a => [(a, b)] -> Pattern a -> Pattern b #

Looks up values from a list of tuples, in order to swap values in the given pattern

fix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern #

The fix function applies another function to matching events in a pattern of controls. fix is contrast where the false-branching function is set to the identity id. It is like contrast, but one function is given and applied to events with matching controls.

For example, the following only adds the crush control when the n control is set to either 1 or 4:

d1 $ slow 2
   $ fix (# crush 3) (n "[1,4]")
   $ n "0 1 2 3 4 5 6"
   # sound "arpy"

You can be quite specific; for example, the following applies the function hurry 2 to sample 1 of the drum sample set, and leaves the rest as they are:

fix (hurry 2) (s "drum" # n "1")

choose :: [a] -> Pattern a #

Randomly picks an element from the given list.

sound "superpiano(3,8)" # note (choose ["a", "e", "g", "c"])

plays a melody randomly choosing one of the four notes "a", "e", "g", "c".

As with all continuous patterns, you have to be careful to give them structure; in this case choose gives you an infinitely detailed stream of random choices.

choose = 'chooseBy' 'rand'

from :: Pattern Double -> ControlPattern #

for internal sound routing

to :: Pattern Double -> ControlPattern #

for internal sound routing

class Unionable a where #

Methods

union :: a -> a -> a #

Instances

Instances details
Unionable ValueMap 
Instance details

Defined in Sound.Tidal.Core

Methods

union :: ValueMap -> ValueMap -> ValueMap #

Unionable a 
Instance details

Defined in Sound.Tidal.Core

Methods

union :: a -> a -> a #

type Event a = EventF (ArcF Time) a #

data EventF a b #

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

Constructors

Event 

Fields

Instances

Instances details
Functor (EventF a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

fmap :: (a0 -> b) -> EventF a a0 -> EventF a b #

(<$) :: a0 -> EventF a b -> EventF a a0 #

Generic (EventF a b) 
Instance details

Defined in Sound.Tidal.Pattern

Associated Types

type Rep (EventF a b) 
Instance details

Defined in Sound.Tidal.Pattern

type Rep (EventF a b) = D1 ('MetaData "EventF" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (C1 ('MetaCons "Event" 'PrefixI 'True) ((S1 ('MetaSel ('Just "context") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Context) :*: S1 ('MetaSel ('Just "whole") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe a))) :*: (S1 ('MetaSel ('Just "part") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b))))

Methods

from :: EventF a b -> Rep (EventF a b) x #

to :: Rep (EventF a b) x -> EventF a b #

(NFData a, NFData b) => NFData (EventF a b) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

rnf :: EventF a b -> () #

(Eq a, Eq b) => Eq (EventF a b) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

(==) :: EventF a b -> EventF a b -> Bool #

(/=) :: EventF a b -> EventF a b -> Bool #

(Ord a, Ord b) => Ord (EventF a b) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

compare :: EventF a b -> EventF a b -> Ordering #

(<) :: EventF a b -> EventF a b -> Bool #

(<=) :: EventF a b -> EventF a b -> Bool #

(>) :: EventF a b -> EventF a b -> Bool #

(>=) :: EventF a b -> EventF a b -> Bool #

max :: EventF a b -> EventF a b -> EventF a b #

min :: EventF a b -> EventF a b -> EventF a b #

type Rep (EventF a b) 
Instance details

Defined in Sound.Tidal.Pattern

type Rep (EventF a b) = D1 ('MetaData "EventF" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (C1 ('MetaCons "Event" 'PrefixI 'True) ((S1 ('MetaSel ('Just "context") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Context) :*: S1 ('MetaSel ('Just "whole") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe a))) :*: (S1 ('MetaSel ('Just "part") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b))))

squeeze :: Pattern Int -> [Pattern a] -> Pattern a #

Chooses from a list of patterns, using a pattern of integers.

release :: Pattern Double -> ControlPattern #

a pattern of numbers to specify the release time (in seconds) of an envelope applied to each sample.

approxRational :: RealFrac a => a -> a -> Rational #

approxRational, applied to two real fractional numbers x and epsilon, returns the simplest rational number within epsilon of x. A rational number y is said to be simpler than another y' if

Any real interval contains a unique simplest rational; in particular, note that 0/1 is the simplest rational of all.

(<|) :: Unionable a => Pattern a -> Pattern a -> Pattern a #

append :: Pattern a -> Pattern a -> Pattern a #

Alternate between cycles of the two given patterns > d1 $ append (sound "bd*2 sn") (sound "arpy jvbass*2")

size :: Pattern Double -> ControlPattern #

a pattern of numbers from 0 to 1. Sets the perceptual size (reverb time) of the room to be used in reverb.

chunk :: Pattern Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b #

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 if chunk number is positive - from right to left if chunk number is negative

d1 $ chunk 4 (fast 4) $ sound "cp sn arpy [mt lt]"

The following:

d1 $ chunk 4 (# speed 2) $ sound "bd hh sn cp"

applies (# speed 2) to the uppercased part of the cycle below:

BD hh sn cp
bd HH sn cp
bd hh SN cp
bd hh sn CP

sec :: Fractional a => Pattern a -> Pattern a #

Turns a pattern of seconds into a pattern of (rational) cycle durations

scale :: Fractional a => Pattern String -> Pattern Int -> Pattern a #

Interprets a pattern of note numbers into a particular named scale. For example:

d1
  $ jux rev
  $ chunk 4 (fast 2 . (|- n 12))
  $ off 0.25 (|+ 7)
  $ struct (iter 4 "t(5,8)")
  $ n (scale "ritusen" "0 .. 7")
  # sound "superpiano"

data State #

an Arc and some named control values

Constructors

State 

Fields

(|>) :: Unionable a => Pattern a -> Pattern a -> Pattern a #

data OSC Source #

Constructors

OSC 

Fields

OSCContext 

Fields

Instances

Instances details
Show OSC Source # 
Instance details

Defined in Sound.Tidal.Stream.Types

Methods

showsPrec :: Int -> OSC -> ShowS #

show :: OSC -> String #

showList :: [OSC] -> ShowS #

type Time = Rational #

Time is rational

send :: Cx -> Double -> Double -> (Double, Bool, Message) -> IO () Source #

select :: Pattern Double -> [Pattern a] -> Pattern a #

Chooses from a list of patterns, using a pattern of floats (from 0 to 1).

cat :: [Pattern a] -> Pattern a #

Like append, 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. It concatenates a list of patterns into a new pattern; each pattern in the list will maintain its original duration. For example:

d1 $ cat [sound "bd*2 sn", sound "arpy jvbass*2"]
d1 $ cat [sound "bd*2 sn", sound "arpy jvbass*2", sound "drum*2"]
d1 $ cat [sound "bd*2 sn", sound "jvbass*3", sound "drum*2", sound "ht mt"]

run :: (Enum a, Num a, Real a) => Pattern a -> Pattern a #

A pattern of whole numbers from 0 to the given number, in a single cycle. Can be used used to run through a folder of samples in order:

d1 $ n (run 8) # sound "amencutup"

The first parameter to run can be given as a pattern:

d1 $ n (run "<4 8 4 6>") # sound "amencutup"

iter :: Pattern Int -> Pattern c -> Pattern c #

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.

echo :: Pattern Integer -> Pattern Rational -> Pattern Double -> ControlPattern -> ControlPattern #

Applies a type of delay to a pattern. It has three parameters, which could be called depth, time and feedback. depth is and integer, and time and feedback are floating point numbers.

This adds a bit of echo:

d1 $ echo 4 0.2 0.5 $ 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 $ echo 4 (-0.2) 0.5 $ sound "bd sn"

type Arc = ArcF Time #

data ArcF a #

An arc of time, with a start time (or onset) and a stop time (or offset)

Constructors

Arc 

Fields

Instances

Instances details
Applicative ArcF 
Instance details

Defined in Sound.Tidal.Time

Methods

pure :: a -> ArcF a #

(<*>) :: ArcF (a -> b) -> ArcF a -> ArcF b #

liftA2 :: (a -> b -> c) -> ArcF a -> ArcF b -> ArcF c #

(*>) :: ArcF a -> ArcF b -> ArcF b #

(<*) :: ArcF a -> ArcF b -> ArcF a #

Functor ArcF 
Instance details

Defined in Sound.Tidal.Time

Methods

fmap :: (a -> b) -> ArcF a -> ArcF b #

(<$) :: a -> ArcF b -> ArcF a #

Generic (ArcF a) 
Instance details

Defined in Sound.Tidal.Time

Associated Types

type Rep (ArcF a) 
Instance details

Defined in Sound.Tidal.Time

type Rep (ArcF a) = D1 ('MetaData "ArcF" "Sound.Tidal.Time" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (C1 ('MetaCons "Arc" 'PrefixI 'True) (S1 ('MetaSel ('Just "start") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "stop") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

Methods

from :: ArcF a -> Rep (ArcF a) x #

to :: Rep (ArcF a) x -> ArcF a #

Num a => Num (ArcF a) 
Instance details

Defined in Sound.Tidal.Time

Methods

(+) :: ArcF a -> ArcF a -> ArcF a #

(-) :: ArcF a -> ArcF a -> ArcF a #

(*) :: ArcF a -> ArcF a -> ArcF a #

negate :: ArcF a -> ArcF a #

abs :: ArcF a -> ArcF a #

signum :: ArcF a -> ArcF a #

fromInteger :: Integer -> ArcF a #

Fractional a => Fractional (ArcF a) 
Instance details

Defined in Sound.Tidal.Time

Methods

(/) :: ArcF a -> ArcF a -> ArcF a #

recip :: ArcF a -> ArcF a #

fromRational :: Rational -> ArcF a #

Show a => Show (ArcF a) 
Instance details

Defined in Sound.Tidal.Time

Methods

showsPrec :: Int -> ArcF a -> ShowS #

show :: ArcF a -> String #

showList :: [ArcF a] -> ShowS #

NFData a => NFData (ArcF a) 
Instance details

Defined in Sound.Tidal.Time

Methods

rnf :: ArcF a -> () #

Eq a => Eq (ArcF a) 
Instance details

Defined in Sound.Tidal.Time

Methods

(==) :: ArcF a -> ArcF a -> Bool #

(/=) :: ArcF a -> ArcF a -> Bool #

Ord a => Ord (ArcF a) 
Instance details

Defined in Sound.Tidal.Time

Methods

compare :: ArcF a -> ArcF a -> Ordering #

(<) :: ArcF a -> ArcF a -> Bool #

(<=) :: ArcF a -> ArcF a -> Bool #

(>) :: ArcF a -> ArcF a -> Bool #

(>=) :: ArcF a -> ArcF a -> Bool #

max :: ArcF a -> ArcF a -> ArcF a #

min :: ArcF a -> ArcF a -> ArcF a #

type Rep (ArcF a) 
Instance details

Defined in Sound.Tidal.Time

type Rep (ArcF a) = D1 ('MetaData "ArcF" "Sound.Tidal.Time" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (C1 ('MetaCons "Arc" 'PrefixI 'True) (S1 ('MetaSel ('Just "start") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "stop") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

sam :: Time -> Time #

The sam (start of cycle) for the given time value. Cycles have duration 1, so every integer Time value divides two cycles.

toTime :: Real a => a -> Rational #

Turns a number into a (rational) time value. An alias for toRational.

fromTime :: Fractional a => Time -> a #

Turns a (rational) time value into another number. An alias for fromRational.

nextSam :: Time -> Time #

The end point of the current cycle (and starting point of the next cycle)

cyclePos :: Time -> Time #

The position of a time value relative to the start of its cycle.

hull :: Arc -> Arc -> Arc #

convex hull union

subArc :: Arc -> Arc -> Maybe Arc #

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.

sect :: Arc -> Arc -> Arc #

Simple intersection of two arcs

timeToCycleArc :: Time -> Arc #

The Arc returned is the cycle that the Time falls within.

Edge case: If the Time is an integer, the Arc claiming it is the one starting at that Time, not the previous one ending at that Time.

cycleArc :: Arc -> Arc #

Shifts an Arc to one of equal duration that starts within cycle zero. (Note that the output Arc probably does not start *at* Time 0 -- that only happens when the input Arc starts at an integral Time.)

cyclesInArc :: Integral a => Arc -> [a] #

Returns the numbers of the cycles that the input Arc overlaps (excluding the input Arc's endpoint, unless it has duration 0 -- see "Edge cases" below). (The "cycle number" of an Arc is equal to its start value. Thus, for instance, cyclesInArc (Arc 0 1.5) == [0,1].)

Edge cases: > cyclesInArc $ Arc 0 1.0001 == [0,1] > cyclesInArc $ Arc 0 1 == [0] -- the endpoint is excluded > cyclesInArc $ Arc 1 1 == [1] -- unless the Arc has duration 0

PITFALL: Don't be fooled by the name. The output cycles are not necessarily completely contained in the input Arc, but they definitely overlap it, and they include every cycle that overlaps it.

cycleArcsInArc :: Arc -> [Arc] #

This provides exactly the same information as cyclesInArc, except that this represents its output as Arcs, whereas cyclesInArc represents the same information as integral indices. (The Arc from 0 to 1 corresponds to the index 0, the one from 1 to 2 has index 1, etc.)

arcCycles :: Arc -> [Arc] #

Splits the given Arc into a list of Arcs, at cycle boundaries.

arcCyclesZW :: Arc -> [Arc] #

Like arcCycles, but returns zero-width arcs

mapCycle :: (Time -> Time) -> Arc -> Arc #

Similar to fmap but time is relative to the cycle (i.e. the sam of the start of the arc)

isIn :: Arc -> Time -> Bool #

isIn a t is True if t is inside the arc represented by a.

lcmr :: Rational -> Rational -> Rational #

Returns the lowest common multiple of two rational numbers

newtype Note #

Note is Double, but with a different parser

Constructors

Note 

Fields

Instances

Instances details
Data Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Note -> c Note #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Note #

toConstr :: Note -> Constr #

dataTypeOf :: Note -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Note) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Note) #

gmapT :: (forall b. Data b => b -> b) -> Note -> Note #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Note -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Note -> r #

gmapQ :: (forall d. Data d => d -> u) -> Note -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Note -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Note -> m Note #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Note -> m Note #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Note -> m Note #

Enum Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

succ :: Note -> Note #

pred :: Note -> Note #

toEnum :: Int -> Note #

fromEnum :: Note -> Int #

enumFrom :: Note -> [Note] #

enumFromThen :: Note -> Note -> [Note] #

enumFromTo :: Note -> Note -> [Note] #

enumFromThenTo :: Note -> Note -> Note -> [Note] #

Floating Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

pi :: Note #

exp :: Note -> Note #

log :: Note -> Note #

sqrt :: Note -> Note #

(**) :: Note -> Note -> Note #

logBase :: Note -> Note -> Note #

sin :: Note -> Note #

cos :: Note -> Note #

tan :: Note -> Note #

asin :: Note -> Note #

acos :: Note -> Note #

atan :: Note -> Note #

sinh :: Note -> Note #

cosh :: Note -> Note #

tanh :: Note -> Note #

asinh :: Note -> Note #

acosh :: Note -> Note #

atanh :: Note -> Note #

log1p :: Note -> Note #

expm1 :: Note -> Note #

log1pexp :: Note -> Note #

log1mexp :: Note -> Note #

Generic Note 
Instance details

Defined in Sound.Tidal.Pattern

Associated Types

type Rep Note 
Instance details

Defined in Sound.Tidal.Pattern

type Rep Note = D1 ('MetaData "Note" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'True) (C1 ('MetaCons "Note" 'PrefixI 'True) (S1 ('MetaSel ('Just "unNote") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Double)))

Methods

from :: Note -> Rep Note x #

to :: Rep Note x -> Note #

Num Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

(+) :: Note -> Note -> Note #

(-) :: Note -> Note -> Note #

(*) :: Note -> Note -> Note #

negate :: Note -> Note #

abs :: Note -> Note #

signum :: Note -> Note #

fromInteger :: Integer -> Note #

Fractional Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

(/) :: Note -> Note -> Note #

recip :: Note -> Note #

fromRational :: Rational -> Note #

Real Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toRational :: Note -> Rational #

RealFrac Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

properFraction :: Integral b => Note -> (b, Note) #

truncate :: Integral b => Note -> b #

round :: Integral b => Note -> b #

ceiling :: Integral b => Note -> b #

floor :: Integral b => Note -> b #

Show Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

showsPrec :: Int -> Note -> ShowS #

show :: Note -> String #

showList :: [Note] -> ShowS #

NFData Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

rnf :: Note -> () #

Eq Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

(==) :: Note -> Note -> Bool #

(/=) :: Note -> Note -> Bool #

Ord Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

compare :: Note -> Note -> Ordering #

(<) :: Note -> Note -> Bool #

(<=) :: Note -> Note -> Bool #

(>) :: Note -> Note -> Bool #

(>=) :: Note -> Note -> Bool #

max :: Note -> Note -> Note #

min :: Note -> Note -> Note #

Enumerable Note 
Instance details

Defined in Sound.Tidal.ParseBP

Parseable Note 
Instance details

Defined in Sound.Tidal.ParseBP

Moddable Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

gmod :: Note -> Note -> Note #

Valuable Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toValue :: Note -> Value #

type Rep Note 
Instance details

Defined in Sound.Tidal.Pattern

type Rep Note = D1 ('MetaData "Note" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'True) (C1 ('MetaCons "Note" 'PrefixI 'True) (S1 ('MetaSel ('Just "unNote") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Double)))

class Valuable a where #

Methods

toValue :: a -> Value #

Instances

Instances details
Valuable Rational 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toValue :: Rational -> Value #

Valuable Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toValue :: Note -> Value #

Valuable String 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toValue :: String -> Value #

Valuable Bool 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toValue :: Bool -> Value #

Valuable Double 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toValue :: Double -> Value #

Valuable Int 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toValue :: Int -> Value #

Valuable [Word8] 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toValue :: [Word8] -> Value #

Valuable [Value] 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toValue :: [Value] -> Value #

data Value #

Polymorphic values

Constructors

VS 

Fields

VF 

Fields

VN 

Fields

VR 

Fields

VI 

Fields

VB 

Fields

VX 

Fields

VPattern 

Fields

VList 

Fields

VState 

Instances

Instances details
Floating ValueMap 
Instance details

Defined in Sound.Tidal.Pattern

Generic Value 
Instance details

Defined in Sound.Tidal.Pattern

Associated Types

type Rep Value 
Instance details

Defined in Sound.Tidal.Pattern

type Rep Value = D1 ('MetaData "Value" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (((C1 ('MetaCons "VS" 'PrefixI 'True) (S1 ('MetaSel ('Just "svalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "VF" 'PrefixI 'True) (S1 ('MetaSel ('Just "fvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Double))) :+: (C1 ('MetaCons "VN" 'PrefixI 'True) (S1 ('MetaSel ('Just "nvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Note)) :+: (C1 ('MetaCons "VR" 'PrefixI 'True) (S1 ('MetaSel ('Just "rvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rational)) :+: C1 ('MetaCons "VI" 'PrefixI 'True) (S1 ('MetaSel ('Just "ivalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))))) :+: ((C1 ('MetaCons "VB" 'PrefixI 'True) (S1 ('MetaSel ('Just "bvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)) :+: C1 ('MetaCons "VX" 'PrefixI 'True) (S1 ('MetaSel ('Just "xvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Word8]))) :+: (C1 ('MetaCons "VPattern" 'PrefixI 'True) (S1 ('MetaSel ('Just "pvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pattern Value))) :+: (C1 ('MetaCons "VList" 'PrefixI 'True) (S1 ('MetaSel ('Just "lvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Value])) :+: C1 ('MetaCons "VState" 'PrefixI 'True) (S1 ('MetaSel ('Just "statevalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (ValueMap -> (ValueMap, Value))))))))

Methods

from :: Value -> Rep Value x #

to :: Rep Value x -> Value #

Num ValueMap 
Instance details

Defined in Sound.Tidal.Pattern

Fractional ValueMap 
Instance details

Defined in Sound.Tidal.Pattern

NFData Value 
Instance details

Defined in Sound.Tidal.Pattern

Methods

rnf :: Value -> () #

Eq Value 
Instance details

Defined in Sound.Tidal.Pattern

Methods

(==) :: Value -> Value -> Bool #

(/=) :: Value -> Value -> Bool #

Ord Value 
Instance details

Defined in Sound.Tidal.Pattern

Methods

compare :: Value -> Value -> Ordering #

(<) :: Value -> Value -> Bool #

(<=) :: Value -> Value -> Bool #

(>) :: Value -> Value -> Bool #

(>=) :: Value -> Value -> Bool #

max :: Value -> Value -> Value #

min :: Value -> Value -> Value #

Unionable ValueMap 
Instance details

Defined in Sound.Tidal.Core

Methods

union :: ValueMap -> ValueMap -> ValueMap #

Moddable ValueMap 
Instance details

Defined in Sound.Tidal.Pattern

Methods

gmod :: ValueMap -> ValueMap -> ValueMap #

Valuable [Value] 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toValue :: [Value] -> Value #

type Rep Value 
Instance details

Defined in Sound.Tidal.Pattern

type Rep Value = D1 ('MetaData "Value" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (((C1 ('MetaCons "VS" 'PrefixI 'True) (S1 ('MetaSel ('Just "svalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "VF" 'PrefixI 'True) (S1 ('MetaSel ('Just "fvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Double))) :+: (C1 ('MetaCons "VN" 'PrefixI 'True) (S1 ('MetaSel ('Just "nvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Note)) :+: (C1 ('MetaCons "VR" 'PrefixI 'True) (S1 ('MetaSel ('Just "rvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rational)) :+: C1 ('MetaCons "VI" 'PrefixI 'True) (S1 ('MetaSel ('Just "ivalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))))) :+: ((C1 ('MetaCons "VB" 'PrefixI 'True) (S1 ('MetaSel ('Just "bvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)) :+: C1 ('MetaCons "VX" 'PrefixI 'True) (S1 ('MetaSel ('Just "xvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Word8]))) :+: (C1 ('MetaCons "VPattern" 'PrefixI 'True) (S1 ('MetaSel ('Just "pvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pattern Value))) :+: (C1 ('MetaCons "VList" 'PrefixI 'True) (S1 ('MetaSel ('Just "lvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Value])) :+: C1 ('MetaCons "VState" 'PrefixI 'True) (S1 ('MetaSel ('Just "statevalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (ValueMap -> (ValueMap, Value))))))))

data Context #

Some context for an event, currently just position within sourcecode

Constructors

Context 

Fields

Instances

Instances details
Generic Context 
Instance details

Defined in Sound.Tidal.Pattern

Associated Types

type Rep Context 
Instance details

Defined in Sound.Tidal.Pattern

type Rep Context = D1 ('MetaData "Context" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (C1 ('MetaCons "Context" 'PrefixI 'True) (S1 ('MetaSel ('Just "contextPosition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((Int, Int), (Int, Int))])))

Methods

from :: Context -> Rep Context x #

to :: Rep Context x -> Context #

NFData Context 
Instance details

Defined in Sound.Tidal.Pattern

Methods

rnf :: Context -> () #

Eq Context 
Instance details

Defined in Sound.Tidal.Pattern

Methods

(==) :: Context -> Context -> Bool #

(/=) :: Context -> Context -> Bool #

Ord Context 
Instance details

Defined in Sound.Tidal.Pattern

type Rep Context 
Instance details

Defined in Sound.Tidal.Pattern

type Rep Context = D1 ('MetaData "Context" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (C1 ('MetaCons "Context" 'PrefixI 'True) (S1 ('MetaSel ('Just "contextPosition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((Int, Int), (Int, Int))])))

class Stringy a where #

Methods

deltaContext :: Int -> Int -> a -> a #

Instances

Instances details
Stringy String 
Instance details

Defined in Sound.Tidal.Pattern

Methods

deltaContext :: Int -> Int -> String -> String #

Stringy (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

deltaContext :: Int -> Int -> Pattern a -> Pattern a #

class Moddable a where #

Methods

gmod :: a -> a -> a #

Instances

Instances details
Moddable Rational 
Instance details

Defined in Sound.Tidal.Pattern

Methods

gmod :: Rational -> Rational -> Rational #

Moddable Note 
Instance details

Defined in Sound.Tidal.Pattern

Methods

gmod :: Note -> Note -> Note #

Moddable ValueMap 
Instance details

Defined in Sound.Tidal.Pattern

Methods

gmod :: ValueMap -> ValueMap -> ValueMap #

Moddable Double 
Instance details

Defined in Sound.Tidal.Pattern

Methods

gmod :: Double -> Double -> Double #

Moddable Int 
Instance details

Defined in Sound.Tidal.Pattern

Methods

gmod :: Int -> Int -> Int #

data Pattern a #

A datatype representing events taking place over time

Constructors

Pattern 

Fields

Instances

Instances details
Applicative Pattern 
Instance details

Defined in Sound.Tidal.Pattern

Methods

pure :: a -> Pattern a #

(<*>) :: Pattern (a -> b) -> Pattern a -> Pattern b #

liftA2 :: (a -> b -> c) -> Pattern a -> Pattern b -> Pattern c #

(*>) :: Pattern a -> Pattern b -> Pattern b #

(<*) :: Pattern a -> Pattern b -> Pattern a #

Functor Pattern 
Instance details

Defined in Sound.Tidal.Pattern

Methods

fmap :: (a -> b) -> Pattern a -> Pattern b #

(<$) :: a -> Pattern b -> Pattern a #

Monad Pattern 
Instance details

Defined in Sound.Tidal.Pattern

Methods

(>>=) :: Pattern a -> (a -> Pattern b) -> Pattern b #

(>>) :: Pattern a -> Pattern b -> Pattern b #

return :: a -> Pattern a #

Monoid (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

mempty :: Pattern a #

mappend :: Pattern a -> Pattern a -> Pattern a #

mconcat :: [Pattern a] -> Pattern a #

Semigroup (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

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

sconcat :: NonEmpty (Pattern a) -> Pattern a #

stimes :: Integral b => b -> Pattern a -> Pattern a #

Enum a => Enum (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

succ :: Pattern a -> Pattern a #

pred :: Pattern a -> Pattern a #

toEnum :: Int -> Pattern a #

fromEnum :: Pattern a -> Int #

enumFrom :: Pattern a -> [Pattern a] #

enumFromThen :: Pattern a -> Pattern a -> [Pattern a] #

enumFromTo :: Pattern a -> Pattern a -> [Pattern a] #

enumFromThenTo :: Pattern a -> Pattern a -> Pattern a -> [Pattern a] #

Floating a => Floating (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

pi :: Pattern a #

exp :: Pattern a -> Pattern a #

log :: Pattern a -> Pattern a #

sqrt :: Pattern a -> Pattern a #

(**) :: Pattern a -> Pattern a -> Pattern a #

logBase :: Pattern a -> Pattern a -> Pattern a #

sin :: Pattern a -> Pattern a #

cos :: Pattern a -> Pattern a #

tan :: Pattern a -> Pattern a #

asin :: Pattern a -> Pattern a #

acos :: Pattern a -> Pattern a #

atan :: Pattern a -> Pattern a #

sinh :: Pattern a -> Pattern a #

cosh :: Pattern a -> Pattern a #

tanh :: Pattern a -> Pattern a #

asinh :: Pattern a -> Pattern a #

acosh :: Pattern a -> Pattern a #

atanh :: Pattern a -> Pattern a #

log1p :: Pattern a -> Pattern a #

expm1 :: Pattern a -> Pattern a #

log1pexp :: Pattern a -> Pattern a #

log1mexp :: Pattern a -> Pattern a #

RealFloat a => RealFloat (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Generic (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Associated Types

type Rep (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

type Rep (Pattern a) = D1 ('MetaData "Pattern" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (C1 ('MetaCons "Pattern" 'PrefixI 'True) (S1 ('MetaSel ('Just "query") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (State -> [Event a])) :*: (S1 ('MetaSel ('Just "steps") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Rational)) :*: S1 ('MetaSel ('Just "pureValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe a)))))

Methods

from :: Pattern a -> Rep (Pattern a) x #

to :: Rep (Pattern a) x -> Pattern a #

Num a => Num (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

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

(-) :: Pattern a -> Pattern a -> Pattern a #

(*) :: Pattern a -> Pattern a -> Pattern a #

negate :: Pattern a -> Pattern a #

abs :: Pattern a -> Pattern a #

signum :: Pattern a -> Pattern a #

fromInteger :: Integer -> Pattern a #

Fractional a => Fractional (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

(/) :: Pattern a -> Pattern a -> Pattern a #

recip :: Pattern a -> Pattern a #

fromRational :: Rational -> Pattern a #

Integral a => Integral (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

quot :: Pattern a -> Pattern a -> Pattern a #

rem :: Pattern a -> Pattern a -> Pattern a #

div :: Pattern a -> Pattern a -> Pattern a #

mod :: Pattern a -> Pattern a -> Pattern a #

quotRem :: Pattern a -> Pattern a -> (Pattern a, Pattern a) #

divMod :: Pattern a -> Pattern a -> (Pattern a, Pattern a) #

toInteger :: Pattern a -> Integer #

(Num a, Ord a) => Real (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

toRational :: Pattern a -> Rational #

RealFrac a => RealFrac (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

properFraction :: Integral b => Pattern a -> (b, Pattern a) #

truncate :: Integral b => Pattern a -> b #

round :: Integral b => Pattern a -> b #

ceiling :: Integral b => Pattern a -> b #

floor :: Integral b => Pattern a -> b #

NFData a => NFData (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

rnf :: Pattern a -> () #

Eq (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

(==) :: Pattern a -> Pattern a -> Bool #

(/=) :: Pattern a -> Pattern a -> Bool #

Ord a => Ord (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

compare :: Pattern a -> Pattern a -> Ordering #

(<) :: Pattern a -> Pattern a -> Bool #

(<=) :: Pattern a -> Pattern a -> Bool #

(>) :: Pattern a -> Pattern a -> Bool #

(>=) :: Pattern a -> Pattern a -> Bool #

max :: Pattern a -> Pattern a -> Pattern a #

min :: Pattern a -> Pattern a -> Pattern a #

Stringy (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

Methods

deltaContext :: Int -> Int -> Pattern a -> Pattern a #

type Rep (Pattern a) 
Instance details

Defined in Sound.Tidal.Pattern

type Rep (Pattern a) = D1 ('MetaData "Pattern" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (C1 ('MetaCons "Pattern" 'PrefixI 'True) (S1 ('MetaSel ('Just "query") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (State -> [Event a])) :*: (S1 ('MetaSel ('Just "steps") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Rational)) :*: S1 ('MetaSel ('Just "pureValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe a)))))

pattern :: (State -> [Event a]) -> Pattern a #

(<<*) :: Pattern (a -> b) -> Pattern a -> Pattern b infixl 4 #

Like *, but the "wholes" come from the left

applyPatToPat :: (Maybe Arc -> Maybe Arc -> Maybe (Maybe Arc)) -> Pattern (a -> b) -> Pattern a -> Pattern b #

applyPatToPatBoth :: Pattern (a -> b) -> Pattern a -> Pattern b #

applyPatToPatLeft :: Pattern (a -> b) -> Pattern a -> Pattern b #

unwrap :: Pattern (Pattern a) -> Pattern a #

Turns a pattern of patterns into a single pattern. (this is actually join)

1/ For query arc, get the events from the outer pattern pp 2/ Query the inner pattern using the part of the outer 3/ For each inner event, set the whole and part to be the intersection of the outer whole and part, respectively 4 Concatenate all the events together (discarding wholesparts that didn't intersect)

TODO - what if a continuous pattern contains a discrete one, or vice-versa?

innerJoin :: Pattern (Pattern b) -> Pattern b #

Turns a pattern of patterns into a single pattern. Like unwrap, but structure only comes from the inner pattern.

outerJoin :: Pattern (Pattern a) -> Pattern a #

Turns a pattern of patterns into a single pattern. Like unwrap, but structure only comes from the outer pattern.

squeezeJoin :: Pattern (Pattern a) -> Pattern a #

Like 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? TODO - steps

noOv :: String -> a #

  • Patterns as numbers

queryArc :: Pattern a -> Arc -> [Event a] #

splitQueries :: Pattern a -> Pattern a #

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

withResultArc :: (Arc -> Arc) -> Pattern a -> Pattern a #

Apply a function to the arcs/timespans (both whole and parts) of the result

withResultTime :: (Time -> Time) -> Pattern a -> Pattern a #

Apply a function to the time (both start and end of the timespans of both whole and parts) of the result

withQueryArc :: (Arc -> Arc) -> Pattern a -> Pattern a #

Apply a function to the timespan of the query

withQueryTime :: (Time -> Time) -> Pattern a -> Pattern a #

Apply a function to the time (both start and end) of the query

withQueryControls :: (ValueMap -> ValueMap) -> Pattern a -> Pattern a #

Apply a function to the control values of the query

withEvent :: (Event a -> Event b) -> Pattern a -> Pattern b #

withEvent f p returns a new Pattern with each event mapped over function f.

withValue :: (a -> b) -> Pattern a -> Pattern b #

withEvent f p returns a new Pattern with each value mapped over function f.

withEvents :: ([Event a] -> [Event b]) -> Pattern a -> Pattern b #

withEvent f p returns a new Pattern with f applied to the resulting list of events for each query function f.

withPart :: (Arc -> Arc) -> Pattern a -> Pattern a #

withPart f p returns a new Pattern with function f applied to the part.

extractI :: String -> ControlPattern -> Pattern Int #

Extract a pattern of integer values by from a control pattern, given the name of the control

extractF :: String -> ControlPattern -> Pattern Double #

Extract a pattern of floating point values by from a control pattern, given the name of the control

extractS :: String -> ControlPattern -> Pattern String #

Extract a pattern of string values by from a control pattern, given the name of the control

extractB :: String -> ControlPattern -> Pattern Bool #

Extract a pattern of boolean values by from a control pattern, given the name of the control

extractR :: String -> ControlPattern -> Pattern Rational #

Extract a pattern of rational values by from a control pattern, given the name of the control

extractN :: String -> ControlPattern -> Pattern Note #

Extract a pattern of note values by from a control pattern, given the name of the control

fast :: Pattern Time -> Pattern a -> Pattern a #

Speed up a pattern by the given time pattern.

For example, the following will play the sound pattern "bd sn kurt" twice as fast (i.e., so it repeats twice per cycle), and the vowel pattern three times as fast:

d1 $ sound (fast 2 "bd sn kurt")
   # fast 3 (vowel "a e o")

The first parameter can be patterned to, for example, play the pattern at twice the speed for the first half of each cycle and then four times the speed for the second half:

d1 $ fast "2 4" $ sound "bd sn kurt cp"

fastSqueeze :: Pattern Time -> Pattern a -> Pattern a #

fastSqueeze speeds up a pattern by a time pattern given as input, squeezing the resulting pattern inside one cycle and playing the original pattern at every repetition.

To better understand how it works, compare it with fast:

>>> fast "1 2" $ s "bd sn"
(0>½)|s: "bd"
(½>¾)|s: "bd"
(¾>1)|s: "sn"

This will give bd played in the first half cycle, and bd sn in the second half. On the other hand, using fastSqueeze;

>>> print $ fastSqueeze "1 2" $ s "bd sn"
(0>¼)|s: "bd"
(¼>½)|s: "sn"
(½>⅝)|s: "bd"
(⅝>¾)|s: "sn"
(¾>⅞)|s: "bd"
(⅞>1)|s: "sn"

The original pattern will play in the first half, and two repetitions of the original pattern will play in the second half. That is, every repetition contains the whole pattern.

If the time pattern has a single value, it becomes equivalent to fast:

d1 $ fastSqueeze 2 $ s "bd sn"
d1 $ fast 2 $ s "bd sn"
d1 $ s "[bd sn]*2"

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

An alias for fast

_fast :: Time -> Pattern a -> Pattern a #

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

Slow down a pattern by the given time pattern.

For example, the following will play the sound pattern "bd sn kurt" twice as slow (i.e., so it repeats once every two cycles), and the vowel pattern three times as slow:

d1 $ sound (slow 2 "bd sn kurt")
   # slow 3 (vowel "a e o")

_slow :: Time -> Pattern a -> Pattern a #

rotL :: Time -> Pattern a -> Pattern a #

Shifts a pattern back in time by the given amount, expressed in cycles.

This will skip to the fourth cycle:

do
  resetCycles
  d1 $ rotL 4 $ seqP
    [ (0, 12, sound "bd bd*2")
    , (4, 12, sound "hh*2 [sn cp] cp future*4")
    , (8, 12, sound (samples "arpy*8" (run 16)))
    ]

Useful when building and testing out longer sequences.

rotR :: Time -> Pattern a -> Pattern a #

Shifts a pattern forward in time by the given amount, expressed in cycles. Opposite of rotL.

rev :: Pattern a -> Pattern a #

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

For example rev "1 [~ 2] ~ 3" is equivalent to rev "3 ~ [2 ~] 1".

Note that rev reverses on a cycle-by-cycle basis. This means that rev (slow 2 "1 2 3 4") would actually result in (slow 2 "2 1 4 3"). This is because the slow 2 makes the repeating pattern last two cycles, each of which is reversed independently.

In practice rev is generally used with conditionals, for example with every:

d1 $ every 3 rev $ n "0 1 [~ 2] 3" # sound "arpy"

or jux:

d1 $ jux rev $ n (iter 4 "0 1 [~ 2] 3") # sound "arpy"

matchManyToOne :: (b -> a -> Bool) -> Pattern a -> Pattern b -> Pattern (Bool, b) #

Mark values in the first pattern which match with at least one value in the second pattern.

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

Remove events from patterns that to not meet the given test

filterJust :: Pattern (Maybe a) -> Pattern a #

Turns a pattern of Maybe values into a pattern of values, dropping the events of Nothing.

filterWhen :: (Time -> Bool) -> Pattern a -> Pattern a #

filterEvents :: (Event a -> Bool) -> Pattern a -> Pattern a #

playFor :: Time -> Time -> Pattern a -> Pattern a #

separateCycles :: Int -> Pattern a -> [Pattern a] #

Splits a pattern into a list containing the given n number of patterns. Each one plays every nth cycle, successfully offset by a cycle.

patternify :: (t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> Pattern a #

patternify' :: (b -> Pattern c -> Pattern a) -> Pattern b -> Pattern c -> Pattern a #

patternify2 :: (a -> b -> c -> Pattern d) -> Pattern a -> Pattern b -> c -> Pattern d #

patternify2' :: (a -> b -> Pattern c -> Pattern d) -> Pattern a -> Pattern b -> Pattern c -> Pattern d #

patternify3 :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e #

patternify3' :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e #

patternifySqueeze :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c #

onsetIn :: Arc -> Event a -> Bool #

True if an Event's starts is within given Arc

defragParts :: Eq a => [Event a] -> [Event a] #

Returns a list of events, with any adjacent parts of the same whole combined

isAdjacent :: Eq a => Event a -> Event a -> Bool #

Returns True if the two given events are adjacent parts of the same whole

wholeStart :: Event a -> Time #

Get the onset of an event's whole

wholeStop :: Event a -> Time #

Get the offset of an event's whole

eventPartStart :: Event a -> Time #

Get the onset of an event's whole

eventPartStop :: Event a -> Time #

Get the offset of an event's part

eventPart :: Event a -> Arc #

Get the timespan of an event's part

eventValue :: Event a -> a #

toEvent :: (((Time, Time), (Time, Time)), a) -> Event a #

applyFIS :: (Double -> Double) -> (Int -> Int) -> (String -> String) -> Value -> Value #

General utilities..

Apply one of three functions to a Value, depending on its type

fNum2 :: (Int -> Int -> Int) -> (Double -> Double -> Double) -> Value -> Value -> Value #

Apply one of two functions to a pair of Values, depending on their types (int or float; strings and rationals are ignored)

sameDur :: Event a -> Event a -> Bool #

groupEventsBy :: Eq a => (Event a -> Event a -> Bool) -> [Event a] -> [[Event a]] #

collectEvent :: [Event a] -> Maybe (Event [a]) #

collectEventsBy :: Eq a => (Event a -> Event a -> Bool) -> [Event a] -> [Event [a]] #

collectBy :: Eq a => (Event a -> Event a -> Bool) -> Pattern a -> Pattern [a] #

collects all events satisfying the same constraint into a list

collect :: Eq a => Pattern a -> Pattern [a] #

collects all events occuring at the exact same time into a list

uncollectEvent :: Event [a] -> [Event a] #

uncollectEvents :: [Event [a]] -> [Event a] #

uncollect :: Pattern [a] -> Pattern a #

merges all values in a list into one pattern by stacking the values

showAll :: Show a => Arc -> Pattern a -> String #

drawLine :: Pattern Char -> Render #

drawLineSz :: Int -> Pattern Char -> Render #

draw :: Pattern Char -> Render #

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

Takes a function of time to values, and turns it into a Pattern. Useful for creating continuous patterns such as sine or perlin.

For example, saw is defined as

saw = sig $ \t -> mod' (fromRational t) 1

sine :: Fractional a => Pattern a #

sine - unipolar sinewave. A pattern of continuous values following a sinewave with frequency of one cycle, and amplitude from 0 to 1.

sine2 :: Fractional a => Pattern a #

sine2 - bipolar sinewave. A pattern of continuous values following a sinewave with frequency of one cycle, and amplitude from -1 to 1.

cosine :: Fractional a => Pattern a #

cosine - unipolar cosine wave. A pattern of continuous values following a cosine with frequency of one cycle, and amplitude from 0 to 1. Equivalent to 0.25 ~> sine.

cosine2 :: Fractional a => Pattern a #

cosine2 - bipolar cosine wave. A pattern of continuous values following a cosine with frequency of one cycle, and amplitude from -1 to 1. Equivalent to 0.25 ~> sine2.

saw :: (Fractional a, Real a) => Pattern a #

saw - unipolar ascending sawtooth wave. A pattern of continuous values following a sawtooth with frequency of one cycle, and amplitude from 0 to 1.

saw2 :: (Fractional a, Real a) => Pattern a #

saw2 - bipolar ascending sawtooth wave. A pattern of continuous values following a sawtooth with frequency of one cycle, and amplitude from -1 to 1.

isaw :: (Fractional a, Real a) => Pattern a #

isaw like saw, but a descending (inverse) sawtooth.

isaw2 :: (Fractional a, Real a) => Pattern a #

isaw2 like saw2, but a descending (inverse) sawtooth.

tri :: (Fractional a, Real a) => Pattern a #

tri - unipolar triangle wave. A pattern of continuous values following a triangle wave with frequency of one cycle, and amplitude from 0 to 1.

tri2 :: (Fractional a, Real a) => Pattern a #

tri2 - bipolar triangle wave. A pattern of continuous values following a triangle wave with frequency of one cycle, and amplitude from -1 to 1.

square :: Fractional a => Pattern a #

square - unipolar square wave. A pattern of continuous values following a square wave with frequency of one cycle, and amplitude from 0 to 1. | square is like sine, for square waves.

square2 :: Fractional a => Pattern a #

square2 - bipolar square wave. A pattern of continuous values following a square wave with frequency of one cycle, and amplitude from -1 to 1.

envL :: Pattern Double #

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.

envLR :: Pattern Double #

like envL but reversed.

envEq :: Pattern Double #

'Equal power' version of env, for gain-based transitions

envEqR :: Pattern Double #

Equal power reversed

(|+|) :: (Applicative a, Num b) => a b -> a b -> a b #

(|+) :: Num a => Pattern a -> Pattern a -> Pattern a #

(+|) :: Num a => Pattern a -> Pattern a -> Pattern a #

(||+) :: Num a => Pattern a -> Pattern a -> Pattern a #

(|++|) :: Applicative a => a String -> a String -> a String #

(|/|) :: (Applicative a, Fractional b) => a b -> a b -> a b #

(|/) :: Fractional a => Pattern a -> Pattern a -> Pattern a #

(/|) :: Fractional a => Pattern a -> Pattern a -> Pattern a #

(||/) :: Fractional a => Pattern a -> Pattern a -> Pattern a #

(|*|) :: (Applicative a, Num b) => a b -> a b -> a b #

(|*) :: Num a => Pattern a -> Pattern a -> Pattern a #

(*|) :: Num a => Pattern a -> Pattern a -> Pattern a #

(||*) :: Num a => Pattern a -> Pattern a -> Pattern a #

(|-|) :: (Applicative a, Num b) => a b -> a b -> a b #

(|-) :: Num a => Pattern a -> Pattern a -> Pattern a #

(-|) :: Num a => Pattern a -> Pattern a -> Pattern a #

(||-) :: Num a => Pattern a -> Pattern a -> Pattern a #

(|%|) :: (Applicative a, Moddable b) => a b -> a b -> a b #

(|%) :: Moddable a => Pattern a -> Pattern a -> Pattern a #

(%|) :: Moddable a => Pattern a -> Pattern a -> Pattern a #

(||%) :: Moddable a => Pattern a -> Pattern a -> Pattern a #

(|**|) :: (Applicative a, Floating b) => a b -> a b -> a b #

(|**) :: Floating a => Pattern a -> Pattern a -> Pattern a #

(**|) :: Floating a => Pattern a -> Pattern a -> Pattern a #

(||**) :: Floating a => Pattern a -> Pattern a -> Pattern a #

(|>|) :: (Applicative a, Unionable b) => a b -> a b -> a b #

(>|) :: Unionable a => Pattern a -> Pattern a -> Pattern a #

(||>) :: Unionable a => Pattern a -> Pattern a -> Pattern a #

(|<|) :: (Applicative a, Unionable b) => a b -> a b -> a b #

(|<) :: Unionable a => Pattern a -> Pattern a -> Pattern a #

(||<) :: Unionable a => Pattern a -> Pattern a -> Pattern a #

(#) :: Unionable b => Pattern b -> Pattern b -> Pattern b #

fastFromList :: [a] -> Pattern a #

Turns a list of values into a pattern, playing all of them per cycle. The following are equivalent:

d1 $ n (fastFromList [0, 1, 2]) # s "superpiano"
d1 $ n "[0 1 2]" # s "superpiano"

listToPat :: [a] -> Pattern a #

A synonym for fastFromList

fromMaybes :: [Maybe a] -> Pattern a #

'fromMaybes; is similar to fromList, but allows values to be optional using the Maybe type, so that Nothing results in gaps in the pattern. The following are equivalent: > d1 $ n (fromMaybes [Just 0, Nothing, Just 2]) # s "superpiano" > d1 $ n "0 ~ 2" # s "superpiano"

_run :: (Enum a, Num a) => a -> Pattern a #

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

Similar to run, but starts from 1 for the first cycle, successively adds a number until it gets up to n. > d1 $ n (scan 8) # sound "amencutup"

_scan :: (Enum a, Num a) => a -> Pattern a #

slowCat :: [Pattern a] -> Pattern a #

Alias for cat

slowcat :: [Pattern a] -> Pattern a #

slowAppend :: Pattern a -> Pattern a -> Pattern a #

Alias for append

fastAppend :: Pattern a -> Pattern a -> Pattern a #

Like append, but twice as fast > d1 $ fastAppend (sound "bd*2 sn") (sound "arpy jvbass*2")

fastCat :: [Pattern a] -> Pattern a #

The same as cat, but speeds up the result by the number of patterns there are, so the cycles from each are squashed to fit a single cycle.

d1 $ fastcat [sound "bd*2 sn", sound "arpy jvbass*2"]
d1 $ fastcat [sound "bd*2 sn", sound "arpy jvbass*2", sound "drum*2"]
d1 $ fastcat [sound "bd*2 sn", sound "jvbass*3", sound "drum*2", sound "ht mt"]

fastcat :: [Pattern a] -> Pattern a #

Alias for fastCat

timeCat :: [(Time, Pattern a)] -> Pattern a #

Similar to fastCat, but each pattern is given a relative duration. You provide proportionate sizes of the patterns to each other for when they’re concatenated into one cycle. The larger the value in the list, the larger relative size the pattern takes in the final loop. If all values are equal then this is equivalent to fastcat (e.g. the following two code fragments are equivalent).

d1 $ fastcat [s "bd*4", s "hh27*8", s "superpiano" # n 0]
d1 $ timeCat [ (1, s "bd*4")
             , (1, s "hh27*8")
             , (1, s "superpiano" # n 0)
             ]

timecat :: [(Time, Pattern a)] -> Pattern a #

Alias for timeCat

overlay :: Pattern a -> Pattern a -> Pattern a #

overlay combines two Patterns into a new pattern, so that their events are combined over time. For example, the following two lines are equivalent:

d1 $ sound (overlay "bd sn:2" "cp*3")
d1 $ sound "[bd sn:2, cp*3]"

overlay is equal to <>,

(<>) :: Semigroup a => a -> a -> a

which can thus be used as an infix operator equivalent of overlay:

d1 $ sound ("bd sn:2" <> "cp*3")

mono :: Pattern a -> Pattern a #

Serialises a pattern so there's only one event playing at any one time, making it monophonic. Events which start/end earlier are given priority.

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

stack combines a list of Patterns into a new pattern, so that their events are combined over time, i.e., all of the patterns in the list are played simultaneously.

d1 $ stack [
 sound "bd bd*2",
 sound "hh*2 [sn cp] cp future*4",
 sound "arpy" +| n "0 .. 15"
]

This is particularly useful if you want to apply a function or synth control pattern to multiple patterns at once:

d1 $ whenmod 5 3 (striate 3) $ stack [
 sound "bd bd*2",
 sound "hh*2 [sn cp] cp future*4",
 sound "arpy" +| n "0 .. 15"
] # speed "[[1 0.8], [1.5 2]*2]/3"

(<~) :: Pattern Time -> Pattern a -> Pattern a #

Shifts a pattern back in time by the given amount, expressed in cycles

(~>) :: Pattern Time -> Pattern a -> Pattern a #

Shifts a pattern forward in time by the given amount, expressed in cycles

slowSqueeze :: Pattern Time -> Pattern a -> Pattern a #

Slow down a pattern by the factors in the given time pattern, "squeezing" the pattern to fit the slot given in the time pattern. It is the slow analogue to fastSqueeze.

If the time pattern only has a single value in a cycle, slowSqueeze becomes equivalent to slow. These are equivalent:

d1 $ slow "<2 4>" $ s "bd*8"
d1 $ slowSqueeze "<2 4>" $ s "bd*8"

When the time pattern has multiple values, however, the behavior is a little different. Instead, a slowed version of the pattern will be made for each value in the time pattern, and they’re all combined together in a cycle according to the structure of the time pattern. For example, these are equivalent:

d1 $ slowSqueeze "2 4 8 16" $ s "bd*8"
d1 $ s "bd*4 bd*2 bd bd/2"

as are these:

d1 $ slowSqueeze "2 4 [8 16]" $ s "bd*8"
d1 $ s "bd*4 bd*2 [bd bd/2]"

sparsity :: Pattern Time -> Pattern a -> Pattern a #

An alias for slow

zoom :: (Time, Time) -> Pattern a -> Pattern a #

Plays 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, zoom is used with an arc from 25% to 75%. It is equivalent to:

d1 $ sound "hh*3 [sn bd]*2"

Here’s an example of it being used with a conditional:

d1 $ every 4 (zoom (0.25, 0.75)) $ sound "bd*2 hh*3 [sn bd]*2 drum"

zoomArc :: Arc -> Pattern a -> Pattern a #

fastGap :: Pattern Time -> Pattern a -> Pattern a #

fastGap is similar to fast but maintains its cyclic alignment, i.e., rather than playing the pattern multiple times, it instead leaves a gap in the remaining space of the cycle. For example, fastGap 2 p would squash the events in pattern p into the first half of each cycle (and the second halves would be empty). The factor should be at least 1.

densityGap :: Pattern Time -> Pattern a -> Pattern a #

An alias for fastGap

compress :: (Time, Time) -> Pattern a -> Pattern a #

compress takes a pattern and squeezes it within the specified time span (i.e. the ‘arc’). The new resulting pattern is a sped up version of the original.

d1 $ compress (1/4, 3/4) $ s "[bd sn]!"

In the above example, the pattern will play in an arc spanning from 25% to 75% of the duration of a cycle. It is equivalent to:

d1 $ s "~ [bd sn]! ~"

Another example, where all events are different:

d1 $ compress (1/4, 3/4) $ n (run 4) # s "arpy"

It differs from zoom in that it preserves the original pattern but it speeds up its events so to match with the new time period.

every :: Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

  • Higher 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.

It takes three inputs: how often the function should be applied (e.g. 3 to apply it every 3 cycles), the function to be applied, and the pattern you are applying it to. For example: to reverse a pattern every three cycles (and for the other two play it normally)

d1 $ every 3 rev $ n "0 1 [~ 2] 3" # sound "arpy"

Note that if the function you’re applying requires additional parameters itself (such as fast 2 to make a pattern twice as fast), then you’ll need to wrap it in parenthesis, like so:

d1 $ every 3 (fast 2) $ n "0 1 [~ 2] 3" # sound "arpy"

Otherwise, the every function will think it is being passed too many parameters.

_every :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

every' :: Pattern Int -> Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

every' n o f p is like every n f p but with an offset of o cycles.

For example, every' 3 0 (fast 2) will speed up the cycle on cycles 0,3,6,… whereas every' 3 1 (fast 2) will transform the pattern on cycles 1,4,7,….

With this in mind, setting the second argument of every' to 0 gives the equivalent every function. For example, every 3 is equivalent to every' 3 0.

The every functions can be used to silence a full cycle or part of a cycle by using silent or mask "~". Mask provides additional flexibility to turn on/off individual steps.

d1 $ every 3 silent $ n "2 9 11 2" # s "hh27"
d1 $ every 3 (mask "~") $ n "2 9 10 2" # s "hh27"
d1 $ every 3 (mask "0 0 0 0") $ n "2 9 11 2" # s "hh27"

_every' :: Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

foldEvery :: [Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

foldEvery ns f p applies the function f to p, and is applied for each cycle in ns.

It is similar to chaining multiple every functions together. It transforms a pattern with a function, once per any of the given number of cycles. If a particular cycle is the start of more than one of the given cycle periods, then it it applied more than once.

d1 $ foldEvery [5,3] (|+ n 1) $ s "moog" # legato 1

The first moog samples are tuned to C2, C3 and C4. Note how on cycles that are multiples of 3 or 5 the pitch is an octave higher, and on multiples of 15 the pitch is two octaves higher, as the transformation is applied twice.

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

Like when, but works on continuous time values rather than cycle numbers. The following will apply # speed 2 only when the remainder of the current Time divided by 2 is less than 0.5:

d1 $ whenT ((< 0.5) . (flip Data.Fixed.mod' 2))
           (# speed 2)
   $ sound "hh(4,8) hc(3,8)"

_getP_ :: (Value -> Maybe a) -> Pattern Value -> Pattern a #

_getP :: a -> (Value -> Maybe a) -> Pattern Value -> Pattern a #

_cX :: a -> (Value -> Maybe a) -> String -> Pattern a #

_cX_ :: (Value -> Maybe a) -> String -> Pattern a #

s_patternify :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c #

s_patternify2 :: (a -> b -> c -> Pattern d) -> Pattern a -> Pattern b -> c -> Pattern d #

stepcat :: [Pattern a] -> Pattern a #

_take :: Time -> Pattern a -> Pattern a #

stepalt :: [[Pattern a]] -> Pattern a #

Successively plays a pattern from each group in turn

getScale :: Fractional a => [(String, [a])] -> Pattern String -> Pattern Int -> Pattern a #

Build a scale function, with additional scales if you wish. For example:

let myscale =
  getScale
    ( scaleTable ++
        [ ("techno", [0,2,3,5,7,8,10])
        , ("broken", [0,1,4,7,8,10])
        ]
    )

The above takes the standard scaleTable as a starting point and adds two custom scales to it. You’ll be able to use the new function in place of the normal one:

d1 $ n (myscale "techno" "0 1 2 3 4 5 6 7") # sound "superpiano"

scaleWith :: (Eq a, Fractional a) => Pattern String -> ([a] -> [a]) -> Pattern Int -> Pattern a #

scaleWithList :: (Eq a, Fractional a) => Pattern String -> [[a] -> [a]] -> Pattern Int -> Pattern a #

raiseDegree :: Fractional a => Int -> [a] -> [a] #

lowerDegree :: Fractional a => Int -> [a] -> [a] #

raiseDegrees :: Fractional a => Int -> Int -> [a] -> [a] #

lowerDegrees :: Fractional a => Int -> Int -> [a] -> [a] #

scaleList :: String #

Outputs this list of all the available scales:

minPent majPent ritusen egyptian kumai hirajoshi iwato chinese indian pelog
prometheus scriabin gong shang jiao zhi yu whole wholetone augmented augmented2
hexMajor7 hexDorian hexPhrygian hexSus hexMajor6 hexAeolian major ionian dorian
phrygian lydian mixolydian aeolian minor locrian harmonicMinor harmonicMajor
melodicMinor melodicMinorDesc melodicMajor bartok hindu todi purvi marva bhairav
ahirbhairav superLocrian romanianMinor hungarianMinor neapolitanMinor enigmatic
spanish leadingWhole lydianMinor neapolitanMajor locrianMajor diminished
octatonic diminished2 octatonic2 messiaen1 messiaen2 messiaen3 messiaen4
messiaen5 messiaen6 messiaen7 chromatic bayati hijaz sikah rast saba iraq

scaleTable :: Fractional a => [(String, [a])] #

Outputs a list of all available scales and their corresponding notes. For example, its first entry is ("minPent",[0,3,5,7,10]) which means that a minor pentatonic scale is formed by the root (0), the minor third (3 semitones above the root), the perfect fourth (5 semitones above the root), etc.

As the list is big, you can use the Haskell function lookup to look up a specific scale: lookup "phrygian" scaleTable. This will output Just [0.0,1.0,3.0,5.0,7.0,8.0,10.0].

You can also do a reverse lookup into the scale table. For example:

filter ( \(_, x) -> take 3 x == [0,2,4] ) scaleTable

The above example will output all scales of which the first three notes are the root, the major second (2 semitones above the fundamental), and the major third (4 semitones above the root).

grp :: [String -> ValueMap] -> Pattern String -> ControlPattern #

Group multiple params into one.

pStateF #

Arguments

:: String

A parameter, e.g. note; a String recognizable by a ValueMap.

-> String

Identifies the cycling state pattern. Can be anything the user wants.

-> (Maybe Double -> Double) 
-> ControlPattern 

pStateList #

Arguments

:: String

A parameter, e.g. note; a String recognizable by a ValueMap.

-> String

Identifies the cycling state pattern. Can be anything the user wants.

-> [Value]

The list to cycle through.

-> ControlPattern 

pStateList is made with cyclic lists in mind, but it can even "cycle" through infinite lists.

pStateListF :: String -> String -> [Double] -> ControlPattern #

A wrapper for pStateList that accepts a `[Double]` rather than a `[Value]`.

pStateListS :: String -> String -> [String] -> ControlPattern #

A wrapper for pStateList that accepts a `[String]` rather than a `[Value]`.

grain' :: Pattern String -> ControlPattern #

grain' is a shortcut to join a begin and end

These are equivalent:

d1 $ slow 2 $ s "bev" # grain' "0.2:0.3" # legato 1
d1 $ slow 2 $ s "bev" # begin 0.2 # end 0.3 # legato 1

drumN :: Num a => String -> a #

accelerate :: Pattern Double -> ControlPattern #

A pattern of numbers that speed up (or slow down) samples while they play.

In the following example, the sound starts at the original pitch and gets higher as it plays:

d1 $ s "arpy" # accelerate 2

You can use a negative number to make the sound get lower. In this example, a different acceleration is applied to each played note using state values:

d1 $ arp "up" $ note "c'maj'4" # s "arpy" # accelerateTake "susan" [0.2,1,-1]

amp :: Pattern Double -> ControlPattern #

Controls the amplitude (volume) of the sound. Like gain, but linear. Default value is 0.4.

d1 $ s "arpy" # amp "<0.4 0.8 0.2>"

attack :: Pattern Double -> ControlPattern #

a pattern of numbers to specify the attack time (in seconds) of an envelope applied to each sample.

bandf :: Pattern Double -> ControlPattern #

a pattern of numbers from 0 to 1. Sets the center frequency of the band-pass filter.

bandq :: Pattern Double -> ControlPattern #

a pattern of anumbers from 0 to 1. Sets the q-factor of the band-pass filter.

bank :: Pattern String -> ControlPattern #

A pattern of strings. When sent to SuperDirt, will be prepended to sample folder names, separated by an underscore. This allows sample sets to be organised into separate banks. See https://github.com/musikinformatik/SuperDirt/pull/312

begin :: Pattern Double -> ControlPattern #

begin receives a pattern of numbers from 0 to 1 and skips the beginning of each sample by the indicated proportion. I.e., 0 would play the sample from the start, 1 would skip the whole sample, and 0.25 would cut off the first quarter.

In this example, the first 3 ade samples are played on every cycle, but the start point from which they are played changes on each cycle:

d1 $ n "0 1 2" # s "ade" # begin "<0 0.25 0.5 0.75>" # legato 1

binshift :: Pattern Double -> ControlPattern #

Spectral binshift

channel :: Pattern Int -> ControlPattern #

choose the channel the pattern is sent to in superdirt

coarse :: Pattern Double -> ControlPattern #

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.

comb :: Pattern Double -> ControlPattern #

Spectral comb

cps :: Pattern Double -> ControlPattern #

A control pattern; setcps is the standalone function.

Patterns don’t (yet) have independent tempos though, if you change it on one pattern, it changes on all of them.

p "cpsfun" $ s "bd sd(3,8)" # cps (slow 8 $ 0.5 + saw)

crush :: Pattern Double -> ControlPattern #

bit crushing, a pattern of numbers from 1 (for drastic reduction in bit-depth) to 16 (for barely no reduction).

cut :: Pattern Int -> ControlPattern #

In the style of classic drum-machines, cut will stop a playing sample as soon as another samples with in same cutgroup is to be played. An example would be an open hi-hat followed by a closed one, essentially muting the open.

cutoff :: Pattern Double -> ControlPattern #

a pattern of numbers in Hz. Applies the cutoff frequency of the low-pass filter.

delay :: Pattern Double -> ControlPattern #

a pattern of numbers from 0 to 1. Sets the level of the delay signal.

delayfeedback :: Pattern Double -> ControlPattern #

a pattern of numbers from 0 to 1. Sets the amount of delay feedback.

delaytime :: Pattern Double -> ControlPattern #

a pattern of numbers from 0 to 1. Sets the length of the delay.

distort :: Pattern Double -> ControlPattern #

noisy fuzzy distortion

djf :: Pattern Double -> ControlPattern #

DJ filter, below 0.5 is low pass filter, above is high pass filter.

dry :: Pattern Double -> ControlPattern #

when set to `1` will disable all reverb for this pattern. See room and size for more information about reverb.

end :: Pattern Double -> ControlPattern #

Similar to begin, but cuts the end off samples, shortening them; e.g. 0.75 to cut off the last quarter of each sample.

d1 $ s "bev" >| begin 0.5 >| end "[0.65 0.55]"

The example above will play the sample two times for cycle, but the second time will play a shorter segment than the first time, creating a kind of canon effect.

enhance :: Pattern Double -> ControlPattern #

Spectral enhance

fadeInTime :: Pattern Double -> ControlPattern #

As with fadeTime, but controls the fade in time of the grain envelope. Not used if the grain begins at position 0 in the sample.

fadeTime :: Pattern Double -> ControlPattern #

Used when using beginend or chopstriate and friends, to change the fade out time of the grain envelope.

fshift :: Pattern Double -> ControlPattern #

frequency shifter

fshiftnote :: Pattern Double -> ControlPattern #

frequency shifter

fshiftphase :: Pattern Double -> ControlPattern #

frequency shifter

gain :: Pattern Double -> ControlPattern #

Used to control the amplitude (volume) of the sound. Values less than 1 make the sound quieter and values greater than 1 make the sound louder.

gain uses a power function, so the volume change around 1 is subtle, but it gets more noticeable as it increases or decreases. Typical values for gain are between 0 and 1.5.

For the linear equivalent, see amp.

d1 $ s "arpy" # gain 0.8

This plays the first arpy sample at a quieter level than the default.

d1 $ s "ab*16" # gain (range 0.8 1.3 $ sine)

This plays a hihat sound, 16 times per cycle, with a gain moving from 0.8 to 1.3 following a sine wave.

hbrick :: Pattern Double -> ControlPattern #

High pass sort of spectral filter

hcutoff :: Pattern Double -> ControlPattern #

a pattern of numbers from 0 to 1. Applies the cutoff frequency of the high-pass filter. Also has alias hpf

hold :: Pattern Double -> ControlPattern #

a pattern of numbers to specify the hold time (in seconds) of an envelope applied to each sample. Only takes effect if attack and release are also specified.

hresonance :: Pattern Double -> ControlPattern #

a pattern of numbers from 0 to 1. Applies the resonance of the high-pass filter. Has alias hpq

krush :: Pattern Double -> ControlPattern #

shape/bass enhancer

lbrick :: Pattern Double -> ControlPattern #

Low pass sort of spectral filter

legato :: Pattern Double -> ControlPattern #

controls the amount of overlap between two adjacent sounds

lock :: Pattern Double -> ControlPattern #

A pattern of numbers. Specifies whether delaytime is calculated relative to cps. When set to 1, delaytime is a direct multiple of a cycle.

metatune :: Pattern Double -> ControlPattern #

A pattern of numbers. Specifies whether the pitch of played samples should be tuned relative to their pitch metadata, if it exists. When set to 1, pitch metadata is applied. When set to 0, pitch metadata is ignored.

n :: Pattern Note -> ControlPattern #

The note or sample number to choose for a synth or sampleset

note :: Pattern Note -> ControlPattern #

The note or pitch to play a sound or synth with

nudge :: Pattern Double -> ControlPattern #

Nudges events into the future by the specified number of seconds. Negative numbers work up to a point as well (due to internal latency)

octer :: Pattern Double -> ControlPattern #

octaver effect

octersub :: Pattern Double -> ControlPattern #

octaver effect

orbit :: Pattern Int -> ControlPattern #

a pattern of numbers. An "orbit" 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.

pan :: Pattern Double -> ControlPattern #

a pattern of numbers between 0 and 1, from left to right (assuming stereo), once round a circle (assuming multichannel)

panorient :: Pattern Double -> ControlPattern #

a 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)

panspan :: Pattern Double -> ControlPattern #

a pattern of numbers between -inf and inf, which controls how much multichannel output is fanned out (negative is backwards ordering)

pansplay :: Pattern Double -> ControlPattern #

a pattern of numbers between 0.0 and 1.0, which controls the multichannel spread range (multichannel only)

panwidth :: Pattern Double -> ControlPattern #

a pattern of numbers between 0.0 and inf, which controls how much each channel is distributed over neighbours (multichannel only)

phaserdepth :: Pattern Double -> ControlPattern #

Phaser Audio DSP effect | params are phaserrate and phaserdepth

phaserrate :: Pattern Double -> ControlPattern #

Phaser Audio DSP effect | params are phaserrate and phaserdepth

rate :: Pattern Double -> ControlPattern #

used in SuperDirt softsynths as a control rate or "speed"

real :: Pattern Double -> ControlPattern #

Spectral conform

resonance :: Pattern Double -> ControlPattern #

a pattern of numbers from 0 to 1. Specifies the resonance of the low-pass filter.

ring :: Pattern Double -> ControlPattern #

ring modulation

ringdf :: Pattern Double -> ControlPattern #

ring modulation

ringf :: Pattern Double -> ControlPattern #

ring modulation

room :: Pattern Double -> ControlPattern #

a pattern of numbers from 0 to 1. Sets the level of reverb.

scram :: Pattern Double -> ControlPattern #

Spectral scramble

shape :: Pattern Double -> ControlPattern #

wave shaping distortion, a pattern of numbers from 0 for no distortion up to 1 for loads of distortion.

smear :: Pattern Double -> ControlPattern #

Spectral smear

speed :: Pattern Double -> ControlPattern #

A pattern of numbers which changes the speed of sample playback which also changes pitch. Negative values will play the sample backwards.

d1 $ slow 5 $ s "sax:5" # legato 1 # speed 0.5

This will play the sax:5 sample at half its rate. As a result, the sample will last twice the normal time, and will be pitched a whole octave lower. This is equivalent to d1 $ slow 5 $ s "sax:5" # legato 1 |- note 12.

d1 $ fast 2 $ s "breaks125:1" # cps (125/60/4) # speed (-2)

In the above example, the break (which lasts for exactly one bar at 125 BPM), will be played backwards, and at double speed (so, we use fast 2 to fill the whole cycle).

sustain :: Pattern Double -> ControlPattern #

A pattern of numbers that indicates the total duration of sample playback in seconds.

This sustain refers to the whole playback duration and is not to be confused with the sustain level of a typical ADSR envelope.

d1 $ fast 2 $ s "breaks125:1" # cps (120/60/4) # sustain 1

At 120 BPM, a cycle lasts for two seconds. In the above example, we cut the sample so it plays just for one second, and repeat this part two times, so we fill the whole cycle. Note that sample pitch isn’t modified.

d1 $ s "breaks125:2!3" # cps (120/60/4) # sustain "0.4 0.2 0.4" # begin "0 0 0.4"

Here, we take advantage that sustain receives a pattern to build a different break from the original sample.

timescale :: Pattern Double -> ControlPattern #

timescale is the main function used to activate time-stretching, and usually the only one you need. It receives a single parameter which is the stretching rate to apply.

You can use any positive number as the ratio, but the particular method used is designed for ratios greater than 1, and work reasonably well for values between 0.1 and 3.

d1 $ slow 2 $ s "breaks152" # legato 1 # timescale (152/130) # cps (130/60/4)

In the example above, we set tempo at 130 beats per minute. But we want to play one of the breaks152 samples, which are, as indicated, at 152 BPM. So, the ratio we want is 152 over 130. This will slow down the sample to fit in our 130 BPM tempo.

timescalewin :: Pattern Double -> ControlPattern #

Time stretch window size.

The algorithm used to time-stretch a sample divides a sample in many little parts, modifies them, and puts them all together again. It uses one particular parameter, called windowSize, which is the length of each sample part.

The windowSize value is automatically calculated, but can be changed with timescalewin. The windowSize value is multiplied by the number provided.

timescalewin can be used to improve the quality of time-stretching for some samples, or simply as an effect.

Consider the following two examples. In the first one, timescalewin 0.01 makes the window size a lot smaller, and the extreme chopping of the sample causes a rougher sound. In the second one, timescalewin 10 makes the chunks a lot bigger. The method used overlaps the treated chunks when recomposing the sample, and, with the bigger window size, this overlap is noticeable and causes a kind of delay effect.

d1 $ slow 2
   $ s "breaks152"
   # legato 1
   # timescale (152/130)
   # timescalewin 0.01
   # cps (130/60/4)
d1 $ slow 2
   $ s "breaks152"
   # legato 1
   # timescale (152/130)
   # timescalewin 10
   # cps (130/60/4)

toArg :: Pattern String -> ControlPattern #

for internal sound routing

tremolodepth :: Pattern Double -> ControlPattern #

Tremolo Audio DSP effect | params are tremolorate and tremolodepth

tremolorate :: Pattern Double -> ControlPattern #

Tremolo Audio DSP effect | params are tremolorate and tremolodepth

triode :: Pattern Double -> ControlPattern #

tube distortion

unit :: Pattern String -> ControlPattern #

Used in conjunction with speed. It accepts values of r (rate, default behavior), c (cycles), or s (seconds). Using unit "c" means speed 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 speed.

In the following example, speed 2 means that samples will be stretched to fill half a cycle:

d1 $ stack [
  s "sax:5" # legato 1 # speed 2 # unit "c",
  s "bd*2"
]

vowel :: Pattern String -> ControlPattern #

formant filter to make things sound like vowels, a pattern of either a, e, i, o or u. Use a rest (~) for no effect.

xorwise :: Int -> Int #

An implementation of the well-known xorshift random number generator. Given a seed number, generates a reasonably random number out of it. This is an efficient algorithm suitable for use in tight loops and used to implement the below functions, which are used to implement rand.

See George Marsaglia (2003). "Xorshift RNGs", in Journal of Statistical Software, pages 8–14.

timeToRand :: (RealFrac a, Fractional b) => a -> b #

timeToRands :: (RealFrac a, Fractional b) => a -> Int -> [b] #

timeToRands' :: Fractional a => Int -> Int -> [a] #

rand :: Fractional a => Pattern a #

rand is an oscillator that generates a continuous pattern of (pseudo-)random numbers between 0 and 1.

For example, to randomly pan around the stereo field:

d1 $ sound "bd*8" # pan rand

Or to enjoy a randomised speed from 0.5 to 1.5, add 0.5 to it:

d1 $ sound "arpy*4" # speed (rand + 0.5)

To make the snares randomly loud and quiet:

sound "sn sn ~ sn" # gain rand

Numbers coming from this pattern are 'seeded' by time. So if you reset time (using resetCycles, setCycle, or cps) 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

brand :: Pattern Bool #

Boolean rand - a continuous stream of true/false values, with a 50/50 chance.

brandBy :: Pattern Double -> Pattern Bool #

Boolean rand with probability as input, e.g. brandBy 0.25 produces trues 25% of the time.

irand :: Num a => Pattern Int -> Pattern a #

Just like rand 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"

_irand :: Num a => Int -> Pattern a #

perlinWith :: Fractional a => Pattern Double -> Pattern a #

1D Perlin (smooth) noise, works like rand but smoothly moves between random values each cycle. perlinWith takes a pattern as the random number generator's "input" instead of automatically using the cycle count.

d1 $ s "arpy*32" # cutoff (perlinWith (saw * 4) * 2000)

will generate a smooth random pattern for the cutoff frequency which will repeat every cycle (because the saw does).

The perlin function uses the cycle count as input and can be used much like rand.

perlin :: Fractional a => Pattern a #

As perlin with a suitable choice of input pattern (sig fromRational).

The perlin function produces a new random value to move to every cycle. If you want a new random value to be generated more or less frequently, you can use fast or slow, respectively:

d1 $ sound "bd*32" # speed (fast 4 $ perlin + 0.5)
d1 $ sound "bd*32" # speed (slow 4 $ perlin + 0.5)

perlin2With :: Pattern Double -> Pattern Double -> Pattern Double #

perlin2With is Perlin noise with a 2-dimensional input. This can be useful for more control over how the randomness repeats (or doesn't).

d1
 $ s "[supersaw:-12*32]"
 # lpf (rangex 60 5000 $ perlin2With (cosine*2) (sine*2))
 # lpq 0.3

The above will generate a smooth random cutoff pattern that repeats every cycle without any reversals or discontinuities (because the 2D path is a circle).

See also: perlin2, which only needs one input because it uses the cycle count as the second input.

perlin2 :: Pattern Double -> Pattern Double #

As perlin2 with a suitable choice of input pattern (sig fromRational).

normal :: (Floating a, Ord a) => Pattern a #

Generates values in [0,1] that follows a normal (bell-curve) distribution. One possible application is to "humanize" drums with a slight random delay: d1 $ s "bd sn bd sn" # nudge (segment 4 (0.01 * normal)) Implemented with the Box-Muller transform. * the max ensures we don't calculate log 0 * the rot in u2 ensures we don't just get the same value as u1 * clamp the Box-Muller generated values in a [-3,3] range

chooseBy :: Pattern Double -> [a] -> Pattern a #

Given a pattern of doubles, chooseBy normalizes them so that each corresponds to an index in the provided list. The returned pattern contains the corresponding elements in the list.

It is like choose, but instead of selecting elements of the list randomly, it uses the given pattern to select elements.

choose = chooseBy rand

The following results in the pattern "a b c":

chooseBy "0 0.25 0.5" ["a","b","c","d"]

wchoose :: [(a, Pattern Double)] -> Pattern a #

Like choose, but works on an a list of tuples of values and weights

sound "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.

wchoose = 'wchooseBy' 'rand'

wchooseBy :: Pattern Double -> [(a, Pattern Double)] -> Pattern a #

Given a pattern of probabilities and a list of (value, weight) pairs, wchooseBy creates a Pattern value by choosing values based on those probabilities and weighted appropriately by the weights in the list of pairs.

randcat :: [Pattern a] -> Pattern a #

randcat ps: does a slowcat on the list of patterns ps but randomises the order in which they are played.

d1 $ sound (randcat ["bd*2 sn", "jvbass*3", "drum*2", "ht mt"])

wrandcat :: [(Pattern a, Pattern Double)] -> Pattern a #

As randcat, but allowing weighted choice.

In the following, the first pattern is the most likely and will play about half the time, and the last pattern is the less likely, with only a 10% probability.

d1 $ sound
   $ wrandcat
       [ ("bd*2 sn", 5), ("jvbass*3", 2), ("drum*2", 2), ("ht mt", 1) ]

degrade :: Pattern a -> Pattern a #

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 sub-patterns:

d1 $ slow 2 $ sound "[[[feel:5*8,feel*3] feel:3*8]?, feel*4]"

degradeBy :: Pattern Double -> Pattern a -> Pattern a #

Similar to degrade, degradeBy allows you to control the percentage of events that are removed. For example, to remove events 90% of the time:

d1 $ slow 2 $ degradeBy 0.9 $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]"
   # accelerate "-6"
   # speed "2"

You can also invoke this behavior in the shorthand notation by specifying a percentage, as a number between 0 and 1, after the question mark:

d1 $ s "bd hh?0.8 bd hh?0.4"

unDegradeBy :: Pattern Double -> Pattern a -> Pattern a #

As degradeBy, but the pattern of probabilities represents the chances to retain rather than remove the corresponding element.

sometimesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

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

sometimesBy' :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

As sometimesBy, but applies the given transformation to the pattern in its entirety before filtering its actual appearances. Less efficient than sometimesBy but may be useful when the passed pattern transformation depends on properties of the pattern before probabilities are taken into account.

sometimes' = sometimesBy' 0.5
often' = sometimesBy' 0.75
rarely' = sometimesBy' 0.25
almostNever' = sometimesBy' 0.1
almostAlways' = sometimesBy' 0.9

sometimes :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

sometimes is an alias for sometimesBy 0.5.

sometimes' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

sometimes' is an alias for sometimesBy' 0.5.

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

often is an alias for sometimesBy 0.75.

often' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

often' is an alias for sometimesBy' 0.75.

rarely :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

rarely is an alias for sometimesBy 0.25.

rarely' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

rarely' is an alias for sometimesBy' 0.25.

almostNever :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

almostNever is an alias for sometimesBy 0.1.

almostNever' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

almostNever' is an alias for sometimesBy' 0.1.

almostAlways :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

almostAlways is an alias for sometimesBy 0.9.

almostAlways' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

almostAlways' is an alias for sometimesBy' 0.9.

never :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

Never apply a transformation, returning the pattern unmodified.

always :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

Apply the transformation to the pattern unconditionally.

always = id

someCyclesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

someCyclesBy is a cycle-by-cycle version of sometimesBy.

For example the following will either distort all of the events in a cycle, or none of them:

d1 $ someCyclesBy 0.5 (# crush 2) $ n "0 1 [~ 2] 3" # sound "arpy"

someCycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

someCycles = someCyclesBy 0.5

somecycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

Alias of someCycles.

brak :: Pattern a -> Pattern a #

brak makes a pattern sound a bit like a breakbeat. It does this by, every other cycle, squashing the pattern to fit half a cycle, and offsetting it by a quarter of a cycle.

d1 $ sound (brak "bd sn kurt")
d1 $ brak $ sound "[feel feel:3, hc:3 hc:2 hc:4 ho:1]"

_iter :: Int -> Pattern a -> Pattern a #

iter' :: Pattern Int -> Pattern c -> Pattern c #

iter' is the same as iter, but decrements the starting subdivision instead of incrementing it. For example,

d1 $ iter' 4 $ sound "bd hh sn cp"

produces

bd hh sn cp
cp bd hh sn
sn cp bd hh
hh sn cp bd

_iter' :: Int -> Pattern a -> Pattern a #

palindrome :: Pattern a -> Pattern a #

palindrome p applies rev to p every other cycle, so that the pattern alternates between forwards and backwards. For example, these are equivalent:

d1 $ palindrome $ sound "arpy:0 arpy:1 arpy:2 arpy:3"
d1 $ slow 2 $ sound "arpy:0 arpy:1 arpy:2 arpy:3 arpy:3 arpy:2 arpy:1 arpy:0"
d1 $ every 2 rev $ sound "arpy:0 arpy:1 arpy:2 arpy:3"

fadeOut :: Time -> Pattern a -> Pattern a #

Degrades a pattern over the given time.

fadeOutFrom :: Time -> Time -> Pattern a -> Pattern a #

Alternate version to fadeOut where you can provide the time from which the fade starts

fadeIn :: Time -> Pattern a -> Pattern a #

’Undegrades’ a pattern over the given time.

fadeInFrom :: Time -> Time -> Pattern a -> Pattern a #

Alternate version to fadeIn where you can provide the time from which the fade in starts

spread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b #

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"

Note that if you pass ($) as the function to spread values over, you can put functions as the list of values. (spreadf is an alias for spread ($).) For example:

d1 $ spread ($) [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.

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

An alias for spread consistent with fastspread.

fastspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b #

fastspread works the same as spread, but the result is squashed into a single cycle. If you gave four values to spread, then the result would seem to speed up by a factor of four. Compare these two:

d1 $ 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.

spread' :: Monad m => (a -> b -> m c) -> m a -> b -> m c #

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"

spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b #

spreadChoose f xs p is similar to slowspread but picks values from xs at random, rather than cycling through them in order.

d1 $ spreadChoose ($) [gap 4, striate 4] $ sound "ho ho:2 ho:3 hc"

spreadr :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b #

A shorter alias for spreadChoose.

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

Decide whether to apply one or another function depending on the result of a test function, which is passed the current cycle as a number.

d1 $ ifp ((== 0) . flip mod 2)
        (striate 4)
        (# coarse "24 48")
  $ sound "hh hc"

This will apply striate 4 for every even cycle and apply # coarse "24 48" for every odd.

Detail: 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 True or False. This is what the ifp signature's first part signifies: (Int -> Bool), a function that takes a whole number and returns either True or False.

wedge :: Pattern Time -> Pattern a -> Pattern a -> Pattern a #

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. > d1 $ wedge (1/4) (sound "bd*2 arpy*3 cp sn*2") (sound "odx [feel future]*2 hh hh")

_wedge :: Time -> Pattern a -> Pattern a -> Pattern a #

whenmod :: Pattern Time -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

whenmod has a similar form and behavior to every, but requires an additional number. It 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.

For example, the following makes every other block of four loops twice as dense:

d1 $ whenmod 8 4 (density 2) (sound "bd sn kurt")

_whenmod :: Time -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

superimpose :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

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. The following are equivalent:

d1 $ superimpose (fast 2) $ sound "bd sn [cp ht] hh"
d1 $ stack [sound "bd sn [cp ht] hh",
            fast 2 $ sound "bd sn [cp ht] hh"
           ]

More examples:

d1 $ superimpose (density 2) $ sound "bd sn [cp ht] hh"
d1 $ superimpose ((# speed "2") . (0.125 <~)) $ sound "bd sn cp hh"

trunc :: Pattern Time -> Pattern a -> Pattern a #

trunc 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"

You can also pattern the first parameter, for example to cycle through three values, one per cycle:

d1 $ trunc "<0.75 0.25 1>" $ sound "bd sn:2 [mt rs] hc"

_trunc :: Time -> Pattern a -> Pattern a #

linger :: Pattern Time -> Pattern a -> Pattern a #

linger is similar to trunc, in that it truncates a pattern so that only the first fraction of the pattern is played, but the truncated part of the pattern loops to fill the remainder of the cycle.

d1 $ linger 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"

For example this repeats the first quarter, so you only hear a single repeating note:

d1 $ linger 0.25 $ n "0 2 [3 4] 2" # sound "arpy"

or slightly more interesting, applied only every fourth cycle:

d1 $ every 4 (linger 0.25) $ n "0 2 [3 4] 2" # sound "arpy"

or to a chopped-up sample:

d1 $ every 2 (linger 0.25) $ loopAt 2 $ chop 8 $ sound "breaks125"

You can also pattern the first parameter, for example to cycle through three values, one per cycle:

d1 $ linger "<0.75 0.25 1>" $ sound "bd sn:2 [mt rs] hc"
d1 $ linger "<0.25 0.5 1>" $ loopAt 2 $ chop 8 $ sound "breaks125"

If you give it a negative number, it will linger on the last part of the pattern, instead of the start of it. E.g. to linger on the last quarter:

d1 $ linger (-0.25) $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"

within :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

Use within to apply a function to only a part of a pattern. It takes two arguments: a start time and an end time, specified as floats between 0 and 1, which are applied to the relevant pattern. Note that the second argument must be greater than the first for the function to have any effect.

For example, to apply fast 2 to only the first half of a pattern:

d1 $ within (0, 0.5) (fast 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"

withinArc :: Arc -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

within' :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

For 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 fast or <~. 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).

For example, whereas using the standard version of within

d1 $ 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'

d1 $ within' (0, 0.25) (fast 2) $ sound "bd hh cp sd"

sounds like:

d1 $ sound "[bd bd] hh cp sd"

revArc :: (Time, Time) -> Pattern a -> Pattern a #

Reverse the part of the pattern sliced out by the (start, end) pair.

revArc a = within a rev

euclid :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a #

You can use the euclid function to apply a Euclidean algorithm over a complex pattern, although the structure of that pattern will be lost:

d1 $ euclid 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 euclid 3 8. It ends up picking two bd sounds, a cp and missing the sn entirely.

A negative first argument provides the inverse of the euclidean pattern.

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 by Toussaint. Some examples from this paper are included below, including rotation as a third parameter in some cases (see euclidOff).

PatternExample
(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.

There was once a shorter alias e for this function. It has been removed, but you may see references to it in older Tidal code.

_euclid :: Int -> Int -> Pattern a -> Pattern a #

euclidFull :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a #

euclidFull n k pa pb stacks euclid n k pa with euclidInv n k pb. That is, it plays one pattern on the euclidean rhythm and a different pattern on the off-beat.

For example, to implement the traditional flamenco rhythm, you could use hard claps for the former and soft claps for the latter:

d1 $ euclidFull 3 7 "realclaps" ("realclaps" # gain 0.8)

_euclidBool :: Int -> Int -> Pattern Bool #

Less expressive than euclid due to its constrained types, but may be more efficient.

_euclid' :: Int -> Int -> Pattern a -> Pattern a #

euclidOff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a #

As euclid, but taking a third rotational parameter corresponding to the onset at which to start the rhythm.

eoff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a #

A shorter alias for euclidOff.

_euclidOff :: Int -> Int -> Int -> Pattern a -> Pattern a #

euclidOffBool :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern Bool -> Pattern Bool #

As euclidOff, but specialized to Bool. May be more efficient than euclidOff.

_distrib :: [Int] -> Pattern a -> Pattern a #

euclidInv :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a #

euclidInv fills in the blanks left by euclid, i.e., it inverts the pattern.

For example, whereas euclid 3 8 "x" produces

"x ~ ~ x ~ ~ x ~"

euclidInv 3 8 "x" produces

"~ x x ~ x x ~ x"

As another example, in

d1 $ stack [ euclid 5 8 $ s "bd"
           , euclidInv 5 8 $ s "hh27"
           ]

the hi-hat event fires on every one of the eight even beats that the bass drum does not.

_euclidInv :: Int -> Int -> Pattern a -> Pattern a #

rot :: Ord a => Pattern Int -> Pattern a -> Pattern a #

rot n p "rotates" the values in a pattern p by n beats to the left, preserving its structure. For example, in the following, each value will shift to its neighbour's position one step to the left, so that b takes the place of a, a of c, and c of b:

rot 1 "a ~ b c"

The result is equivalent of:

"b ~ c a"

The first parameter is the number of steps, and may be given as a pattern. For example, in

d1 $ rot "<0 0 1 3>" $ n "0 ~ 1 2 0 2 ~ 3*2" # sound "drum"

the pattern will not be rotated for the first two cycles, but will rotate it by one the third cycle, and by three the fourth cycle.

Additional example:

d1 $ every 4 (rot 2) $ slow 2 $ sound "bd hh hh hh"

_rot :: Ord a => Int -> Pattern a -> Pattern a #

Calculates a whole cycle, rotates it, then constrains events to the original query arc.

segment :: Pattern Time -> Pattern a -> Pattern a #

segment n p ’samples’ the pattern p at a rate of n events per cycle. Useful for turning a continuous pattern into a discrete one.

In the following example, the pattern originates from the shape of a sine wave, a continuous pattern. Without segment, the samples will get triggered at an undefined frequency which may be very high.

d1 $ n (slow 2 $ segment 16 $ range 0 32 $ sine) # sound "amencutup"

discretise :: Pattern Time -> Pattern a -> Pattern a #

discretise: the old (deprecated) name for segment

fit :: Pattern Int -> [a] -> Pattern Int -> Pattern a #

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

_fit :: Int -> [a] -> Pattern Int -> Pattern a #

permstep :: RealFrac b => Int -> [a] -> Pattern b -> Pattern a #

struct :: Pattern Bool -> Pattern a -> Pattern a #

struct a b structures pattern b in terms of the pattern of boolean values a. Only True values in the boolean pattern are used.

The following are equivalent:

d1 $ struct ("t ~ t*2 ~") $ sound "cp"
d1 $ sound "cp ~ cp*2 ~"

The structure comes from a boolean pattern, i.e. a binary pattern containing true or false values. Above we only used true values, denoted by t. It’s also possible to include false values with f, which struct will simply treat as silence. For example, this would have the same outcome as the above:

d1 $ struct ("t f t*2 f") $ sound "cp"

These true / false binary patterns become useful when you conditionally manipulate them, for example, ‘inverting’ the values using every and inv:

d1 $ struct (every 3 inv "t f t*2 f") $ sound "cp"

In the above, the boolean values will be ‘inverted’ every third cycle, so that the structure comes from the fs rather than t. Note that euclidean patterns also create true/false values, for example:

d1 $ struct (every 3 inv "t(3,8)") $ sound "cp"

In the above, the euclidean pattern creates "t f t f t f f t" which gets inverted to "f t f t f t t f" every third cycle. Note that if you prefer you can use 1 and 0 instead of t and f.

substruct :: Pattern Bool -> Pattern b -> Pattern b #

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.

stripe :: Pattern Int -> Pattern a -> Pattern a #

stripe n p: repeats pattern p n times per cycle, i.e., the first parameter gives the number of cycles to operate over. So, it is similar to fast, but with random durations. For example stripe 2 will repeat a pattern twice, over two cycles

In the following example, the start of every third repetition of the d1 pattern will match with the clap on the d2 pattern.

d1 $ stripe 3 $ sound "bd sd ~ [mt ht]"
d2 $ sound "cp"

The repetitions will be contiguous (touching, but not overlapping) and the durations will add up to a single cycle. n can be supplied as a pattern of integers.

_stripe :: Int -> Pattern a -> Pattern a #

slowstripe :: Pattern Int -> Pattern a -> Pattern a #

slowstripe n p is the same as stripe, but the result is also n times slower, so that the mean average duration of the stripes is exactly one cycle, and every nth stripe starts on a cycle boundary (in Indian classical terms, the sam).

lindenmayer :: Int -> String -> String -> String #

Returns the nth iteration of a Lindenmayer System with given start sequence.

It takes an integer b, a Lindenmayer system rule set, and an initiating string as input in order to generate an L-system tree string of b iterations. It can be used in conjunction with a step function to convert the generated string into a playable pattern. For example,

d1 $ slow 16
   $ sound
   $ step' ["feel:0", "sn:1", "bd:0"]
       ( take 512
       $ lindenmayer 5 "0:1~~~,1:0~~~2~~~~~0~~~2~,2:2~1~,~:~~1~" "0"
       )

generates an L-system with initiating string "0" and maps it onto a list of samples.

Complex L-system trees with many rules and iterations can sometimes result in unwieldy strings. Using take n to only use the first n elements of the string, along with a slow function, can make the generated values more manageable.

lindenmayerI :: Num b => Int -> String -> String -> [b] #

lindenmayerI converts the resulting string into a a list of integers with fromIntegral applied (so they can be used seamlessly where floats or rationals are required)

runMarkov :: Int -> [[Double]] -> Int -> Time -> [Int] #

runMarkov n tmat xi seed 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 will produce a two-state chain 8 steps long, from initial state 0, where the transition probability from state 0->0 is 25, 0->1 is 35, 1->0 is 1/4, and 1->1 is 3/4.

markovPat :: Pattern Int -> Pattern Int -> [[Double]] -> Pattern Int #

markovPat n xi tp generates a one-cycle pattern of n steps in a Markov chain starting from state xi with transition matrix tp. Each row of the transition matrix is automatically normalized. For example:

>>> markovPat 8 1 [[3,5,2], [4,4,2], [0,1,0]]
(0>⅛)|1
(⅛>¼)|2
(¼>⅜)|1
(⅜>½)|1
(½>⅝)|2
(⅝>¾)|1
(¾>⅞)|1
(⅞>1)|0

_markovPat :: Int -> Int -> [[Double]] -> Pattern Int #

beat :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a #

beat structures a pattern by picking subdivisions of a cycle. Takes in a pattern that tells it which parts to play (polyphony is recommeded here), and the number of parts by which to subdivide the cycle (also pattern-able). For example: > d1 $ beat "[3,4.2,9,11,14]" 16 $ s "sd"

__beat :: (Pattern (Pattern a) -> Pattern a) -> Time -> Time -> Pattern a -> Pattern a #

stretch :: Pattern a -> Pattern a #

stretch takes a pattern, and if there’s silences at the start or end of the current cycle, it will zoom in to avoid them. The following are equivalent:

d1 $ note (stretch "~ 0 1 5 8*4 ~") # s "superpiano"
d1 $ note "0 1 5 8*4" # s "superpiano"

You can pattern silences on the extremes of a cycle to make changes to the rhythm:

d1 $ note (stretch "~ <0 ~> 1 5 8*4 ~") # s "superpiano"

fit' :: Pattern Time -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a #

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.

_chunk :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b #

chunk' :: Integral a1 => Pattern a1 -> (Pattern a2 -> Pattern a2) -> Pattern a2 -> Pattern a2 #

DEPRECATED, use chunk with negative numbers instead

_chunk' :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b #

DEPRECATED, use _chunk with negative numbers instead

inside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a #

inside carries out an operation inside a cycle. For example, while rev "0 1 2 3 4 5 6 7" is the same as "7 6 5 4 3 2 1 0", inside 2 rev "0 1 2 3 4 5 6 7" gives "3 2 1 0 7 6 5 4".

What this function is really doing is ‘slowing down’ the pattern by a given factor, applying the given function to it, and then ‘speeding it up’ by the same factor. In other words, this:

inside 2 rev "0 1 2 3 4 5 6 7"

Is doing this:

fast 2 $ rev $ slow 2 "0 1 2 3 4 5 6 7"

so rather than whole cycles, each half of a cycle is reversed.

_inside :: Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a #

outside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a #

outside is the inverse of the inside function. outside applies its function outside the cycle. Say you have a pattern that takes 4 cycles to repeat and apply the rev function:

d1 $ rev $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]

The above generates:

d1 $ rev $ cat [s "sn bd bd",s "bd sn sn", s "sd lt lt", s "bd sd sd"]

However if you apply outside:

d1 $ outside 4 (rev) $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]

The result is:

d1 $ rev $ cat [s "bd sd sd", s "sd lt lt", s "sn sn bd", s "bd bd sn"]

Notice that the whole idea has been reversed. What this function is really doing is ‘speeding up’ the pattern by a given factor, applying the given function to it, and then ‘slowing it down’ by the same factor. In other words, this:

d1 $ slow 4 $ rev $ fast 4
   $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]

This compresses the idea into a single cycle before rev operates and then slows it back to the original speed.

_outside :: Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a #

loopFirst :: Pattern a -> Pattern a #

Takes a pattern and loops only the first cycle of the pattern. For example, the following code will only play the bass drum sample:

d1 $ loopFirst $ s "<<bd*4 ht*8> cp*4>"

This function combines with sometimes to insert events from the first cycle randomly into subsequent cycles of the pattern:

d1 $ sometimes loopFirst $ s "<<bd*4 ht*8> cp*4>"

seqPLoop :: [(Time, Time, Pattern a)] -> Pattern a #

seqPLoop will keep looping the sequence when it gets to the end:

d1 $ qtrigger $ seqPLoop
  [ (0, 12, sound "bd bd*2")
  , (4, 12, sound "hh*2 [sn cp] cp future*4")
  , (8, 12, sound (samples "arpy*8" (run 16)))
  ]

toScale :: Num a => [a] -> Pattern Int -> Pattern a #

toScale 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".

toScale is handy for quickly applying a scale without naming it:

d1 $ n (toScale [0,2,3,5,7,8,10] "0 1 2 3 4 5 6 7") # sound "superpiano"

This function assumes your scale fits within an octave; if that's not true, use toScale'.

toScale = toScale' 12

toScale' :: Num a => Int -> [a] -> Pattern Int -> Pattern a #

As toScale, though allowing scales of arbitrary size.

An example: toScale' 24 [0,4,7,10,14,17] (run 8) turns into "0 4 7 10 14 17 24 28".

swingBy :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a #

swingBy x n divides a cycle into n slices and delays the notes in the second half of each slice by x fraction of a slice. So if x is 0 it does nothing, 0.5 delays for half the note duration, and 1 will wrap around to doing nothing again. The end result is a shuffle or swing-like rhythm. For example, the following will delay every other "hh" 1/3 of the way to the next "hh":

d1 $ swingBy (1/3) 4 $ sound "hh*8"

swing :: Pattern Time -> Pattern a -> Pattern a #

As swingBy, with the cycle division set to ⅓.

cycleChoose :: [a] -> Pattern a #

cycleChoose is like choose but only picks a new item from the list once each cycle.

d1 $ sound "drum ~ drum drum" # n (cycleChoose [0,2,3])

_rearrangeWith :: Pattern Int -> Int -> Pattern a -> Pattern a #

Internal function used by shuffle and scramble

shuffle :: Pattern Int -> Pattern a -> Pattern a #

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.

This could also be called “sampling without replacement”.

scramble :: Pattern Int -> Pattern a -> Pattern a #

scramble n p is like shuffle 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.

This could also be called “sampling with replacement”.

randrun :: Int -> Pattern Int #

randrun n generates a pattern of random integers less than n.

The following plays random notes in an octave:

d1 $ s "superhammond!12" # n (fromIntegral $ randrun 13)

seqP :: [(Time, Time, Pattern a)] -> Pattern a #

The function seqP 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)))
]

ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a #

The ur function is designed for longer form composition, by allowing you to create ‘patterns of patterns’ in a repeating loop. It takes four parameters: how long the loop will take, a pattern giving the structure of the composition, a lookup table for named patterns to feed into that structure, and a second lookup table for named transformations/effects.

The ur- prefix comes from German and means proto- or original. For a mnemonic device, think of this function as assembling a set of original patterns (ur-patterns) into a larger, newer whole.

Lets say you had three patterns (called a, b and c), and that you wanted to play them four cycles each, over twelve cycles in total. Here is one way to do it:

let pats =
  [ ( "a", stack [ n "c4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7"
                 , n "[c3,g4,c4]" # s "superpiano"# gain "0.7"
                 ]
    )
  , ( "b", stack [ n "d4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7"
                 , n "[d3,a4,d4]" # s "superpiano"# gain "0.7"
                 ]
    )
  , ( "c", stack [ n "f4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7"
                 , n "[f4,c5,f4]" # s "superpiano"# gain "0.7"
                 ]
    )
  ]
in
d1 $ ur 12 "a b c" pats []

In the above, the fourth parameter is given as an empty list, but that is where you can put another lookup table, of functions rather than patterns this time. For example:

let
  pats = ...
  fx   = [ ("reverb", ( # (room 0.8 # sz 0.99 # orbit 1)))
         , ("faster", fast 2)
         ]
in
d1 $ ur 12 "a b:reverb c:faster" pats fx

In this example, b has the function applied that’s named as reverb, while c is made to go faster. It’s also possible to schedule multiple patterns at once, like in the following:

let pats = [ ("drums", s "drum cp*2")
           , ("melody", s "arpy:2 arpy:3 arpy:5")
           , ("craziness", s "cp:4*8" # speed ( sine + 0.5 ))
           ]
    fx = [("higher", ( # speed 2))]
in
d1 $ ur 8 "[drums, melody] [drums,craziness,melody] melody:higher" pats fx

inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a #

A simpler version of ur that just provides name-value bindings that are reflected in the provided pattern.

inhabit allows you to link patterns to some String, or in other words, to give patterns a name and then call them from within another pattern of Strings.

For example, we can make our own bassdrum, hi-hat and snaredrum kit:

do
  let drum = inhabit [ ("bd", s "sine" |- accelerate 1.5)
                     , ("hh", s "alphabet:7" # begin 0.7 # hpf 7000)
                     , ("sd", s "invaders:3" # speed 12)
                     ]
  d1 $ drum "[bd*8?, [~hh]*4, sd(6,16)]"

inhabit can be very useful when using MIDI controlled drum machines, since you can give understandable drum names to patterns of notes.

spaceOut :: [Time] -> Pattern a -> Pattern a #

spaceOut xs p repeats a Pattern p at different durations given by the list of time values in xs.

flatpat :: Pattern [a] -> Pattern a #

flatpat takes a Pattern of lists and pulls the list elements as separate Events. For example, the following code uses flatpat in combination with listToPat to create an alternating pattern of chords:

d1 $ n (flatpat $ listToPat [[0,4,7],[(-12),(-8),(-5)]])
   # s "superpiano" # sustain 2

This code is equivalent to:

d1 $ n ("[0,4,7] [-12,-8,-5]") # s "superpiano" # sustain 2

layer :: [a -> Pattern b] -> a -> Pattern b #

layer takes a list of Pattern-returning functions and a seed element, stacking the result of applying the seed element to each function in the list.

It allows you to layer up multiple functions on one pattern. For example, the following will play two versions of the pattern at the same time, one reversed and one at twice the speed:

d1 $ layer [rev, fast 2] $ sound "arpy [~ arpy:4]"

The original version of the pattern can be included by using the id function:

d1 $ layer [id, rev, fast 2] $ sound "arpy [~ arpy:4]"

arpeggiate :: Pattern a -> Pattern a #

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

arpg :: Pattern a -> Pattern a #

Shorthand alias for arpeggiate

arpWith :: ([EventF (ArcF Time) a] -> [EventF (ArcF Time) b]) -> Pattern a -> Pattern b #

arp :: Pattern String -> Pattern a -> Pattern a #

The arp function takes an additional pattern of arpeggiate modes. For example:

d1 $ sound "superpiano" # n (arp "down diverge" "e'7sus4'8")

The different arpeggiate modes are: up down updown downup up&down down&up converge diverge disconverge pinkyup pinkyupdown thumbup thumbupdown

_arp :: String -> Pattern a -> Pattern a #

rolled :: Pattern a -> Pattern a #

rolled plays each note of a chord quickly in order, as opposed to simultaneously; to give a chord a harp-like or strum effect.

Notes are played low to high, and are evenly distributed within (14) of the chord event length, as opposed to arparpeggiate that spread the notes over the whole event.

rolled $ n "cmaj4" # s "superpiano"
rolled = rolledBy (1/4)

ply :: Pattern Rational -> Pattern a -> Pattern a #

ply n repeats each event n times within its arc.

For example, the following are equivalent:

d1 $ ply 3 $ s "bd ~ sn cp"
d1 $ s "[bd bd bd] ~ [sn sn sn] [cp cp cp]"

The first parameter may be given as a pattern, so that the following are equivalent:

d1 $ ply "2 3" $ s "bd ~ sn cp"
d1 $ s "[bd bd] ~ [sn sn sn] [cp cp cp]"

Here is an example of it being used conditionally:

d1 $ every 3 (ply 4) $ s "bd ~ sn cp"

plyWith :: (Ord t, Num t) => Pattern t -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

As ply, but applies a function each time. The applications are compounded.

_plyWith :: (Ord t, Num t) => t -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

press :: Pattern a -> Pattern a #

Syncopates a rhythm, shifting (delaying) each event halfway into its arc (timespan).

In mini-notation terms, it basically turns every instance of a into [~ a], e.g., "a b [c d] e" becomes the equivalent of "[~ a] [~ b] [[~ c] [~ d]] [~ e]". Every beat then becomes an offbeat, and so the overall effect is to syncopate a pattern.

In the following example, you can hear that the piano chords play between the snare and the bass drum. In 4/4 time, they are playing in the 2 and a half, and 4 and a half beats:

do
  resetCycles
  d1 $ stack [
    press $ n "~ c'maj ~ c'maj" # s "superpiano" # gain 0.9 # pan 0.6,
    s "[bd,clap sd bd sd]" # pan 0.4
    ] # cps (90/60/4)

In the next example, the C major chord plays before the G major. As the slot that occupies the C chord is that of one eighth note, it is displaced by press only a sixteenth note:

do
  resetCycles
  d1 $ stack [
    press $ n "~ [c'maj ~] ~ ~" # s "superpiano" # gain 0.9 # pan 0.6,
    press $ n "~ g'maj ~ ~" # s "superpiano" # gain 0.9 # pan 0.4,
    s "[bd,clap sd bd sd]"
   ] # cps (90/60/4)

pressBy :: Pattern Time -> Pattern a -> Pattern a #

Like press, but allows you to specify the amount in which each event is shifted as a float from 0 to 1 (exclusive).

pressBy 0.5 is the same as press, while pressBy (1/3) shifts each event by a third of its arc.

You can pattern the displacement to create interesting rhythmic effects:

d1 $ stack [
  s "bd sd bd sd",
  pressBy "<0 0.5>" $ s "co:2*4"
]
d1 $ stack [
  s "[bd,co sd bd sd]",
  pressBy "<0 0.25 0.5 0.75>" $ s "cp"
]

sew :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a #

stitch :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a #

Uses the first (binary) pattern to switch between the following two patterns. The resulting structure comes from the binary pattern, not the source patterns. (In sew, by contrast, the resulting structure comes from the source patterns.)

The following uses a euclidean pattern to control CC0:

d1 $ ccv (stitch "t(7,16)" 127 0) # ccn 0  # "midi"

while :: Pattern Bool -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

A binary pattern is used to conditionally apply a function to a source pattern. The function is applied when a True value is active, and the pattern is let through unchanged when a False value is active. No events are let through where no binary values are active.

stutter :: Integral i => i -> Time -> Pattern a -> Pattern a #

stutter n t pat repeats each event in pat n times, separated by t time (in fractions of a cycle). It is like echo that doesn't reduce the volume, or ply if you controlled the timing.

d1 $ stutter 4 (1/16) $ s "bd cp"

is functionally equivalent to

d1 $ stut 4 1 (1/16) $ s "bd cp"

jux :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap #

The jux 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"

When passing pattern transforms to functions like jux and every, it's possible to chain multiple transforms together with . (function composition). For example this both reverses and halves the playback speed of the pattern in the righthand channel:

d1 $ slow 32 $ jux ((# speed "0.5") . rev) $ striateBy 32 (1/16) $ sound "bev"

jux' :: [t -> Pattern ValueMap] -> t -> Pattern ValueMap #

In addition to jux, jux' allows using a list of pattern transformations. Resulting patterns from each transformation will be spread via pan from left to right.

For example, the following will put iter 4 of the pattern to the far left and palindrome to the far right. In the center, the original pattern will play and the chopped and the reversed version will appear mid left and mid right respectively.

d1 $ jux' [iter 4, chop 16, id, rev, palindrome] $ sound "bd sn"

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"
     ]

jux4 :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap #

Multichannel variant of jux, not sure what it does

juxBy :: Pattern Double -> (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap #

With jux, 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 juxBy has an additional parameter, which brings the channel closer to the centre. For example:

d1 $ juxBy 0.5 (fast 2) $ sound "bd sn:1"

In the above, the two versions of the pattern would be panned at 0.25 and 0.75, rather than 0 and 1.

pick :: String -> Int -> String #

Given a sample's directory name and number, this generates a string suitable to pass to fromString to create a 'Pattern String'. samples is a Pattern-compatible interface to this function.

pick name n = name ++ ":" ++ show n

samples :: Applicative f => f String -> f Int -> f String #

Given a pattern of sample directory names and a of pattern indices create a pattern of strings corresponding to the sample at each name-index pair.

An example:

samples "jvbass [~ latibro] [jvbass [latibro jvbass]]"
        ((1%2) `rotL` slow 6 "[1 6 8 7 3]")

The type signature is more general here, but you can consider this to be a function of type Pattern String -> Pattern Int -> Pattern String.

samples = liftA2 pick

samples' :: Applicative f => f String -> f Int -> f String #

Equivalent to samples, though the sample specifier pattern (the f Int) will be evaluated first. Not a large difference in the majority of cases.

spreadf :: [a -> Pattern b] -> a -> Pattern b #

stackwith :: Unionable a => Pattern a -> [Pattern a] -> Pattern a #

_range :: (Functor f, Num b) => b -> b -> f b -> f b #

rangex :: (Functor f, Floating b) => b -> b -> f b -> f b #

rangex is an exponential version of range, good for using with frequencies. For example, range 20 2000 "0.5" will give 1010 - halfway between 20 and 2000. But rangex 20 2000 0.5 will give 200 - halfway between on a logarithmic scale. This usually sounds better if you’re using the numbers as pitch frequencies. Since rangex uses logarithms, don’t try to scale things to zero or less.

off :: Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

off is similar to superimpose, in that it applies a function to a pattern and layers up the results on top of the original pattern. The difference is that off takes an extra pattern being a time (in cycles) to shift the transformed version of the pattern by.

The following plays a pattern on top of itself, but offset by an eighth of a cycle, with a distorting bitcrush effect applied:

d1 $ off 0.125 (# crush 2) $ sound "bd [~ sn:2] mt lt*2"

The following makes arpeggios by adding offset patterns that are shifted up the scale:

d1 $ slow 2
   $ n (off 0.25 (+12)
   $ off 0.125 (+7)
   $ slow 2 "c(3,8) a(3,8,2) f(3,8) e(3,8,4)")
   # sound "superpiano"

_off :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

offadd :: Num a => Pattern Time -> Pattern a -> Pattern a -> Pattern a #

sseq :: String -> String -> Pattern String #

sseq acts as a kind of simple step-sequencer using strings. For example, sseq "sn" "x x 12" is equivalent to the pattern of strings given by "sn ~ sn ~ sn:1 sn:2 ~". sseq substitutes the given string for each x, for each number it substitutes the string followed by a colon and the number, and for everything else it puts in a rest.

In other words, sseq generates a pattern of strings in exactly the syntax you’d want for selecting samples and that can be fed directly into the s function.

d1 $ s (sseq "sn" "x x 12 ")

sseqs :: [(String, String)] -> Pattern String #

sseqs is like sseq but it takes a list of pairs, like sseq would, and it plays them all simultaneously.

d1 $ s (sseqs [("cp","x  x x  x x  x"),("bd", "xxxx")])

sseq' :: [String] -> String -> Pattern String #

like sseq, but allows you to specify an array of strings to use for 0,1,2... For example,

d1 $ s (sseq' ["superpiano","supermandolin"] "0 1 000 1")
   # sustain 4 # n 0

is equivalent to

d1 $ s "superpiano ~ supermandolin ~ superpiano!3 ~ supermandolin"
   # sustain 4 # n 0

ghost'' :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

Deprecated backwards-compatible alias for ghostWith.

ghostWith :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

Like ghost', but a user-supplied function describes how to alter the pattern.

In this example, ghost notes are applied to the snare hit, but these notes will be louder, not quieter, and the sample will have its beginning slightly cut:

d1 $ slow 2
   $ ghostWith (1/16) ((|*| gain 1.1) . (|> begin 0.05))
   $ sound "sn"

ghost :: Pattern ValueMap -> Pattern ValueMap #

As ghost', but with the copies set to appear one-eighth of a cycle afterwards.

ghost = ghost' 0.125

The following creates a kick snare pattern with ghost notes applied to the snare hit:

d1 $ stack [ ghost $ sound "~ sn", sound "bd*2 [~ bd]" ]

tabby :: Int -> Pattern a -> Pattern a -> Pattern a #

A more literal weaving than the weave function. Given tabby threads p1 p, parameters representing the threads per cycle and the patterns to weave, and this function will weave them together using a plain (aka ’tabby’) weave, with a simple over/under structure

_select :: Double -> [Pattern a] -> Pattern a #

selectF :: Pattern Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a #

Chooses from a list of functions, using a pattern of floats (from 0 to 1).

_selectF :: Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a #

pickF :: Pattern Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a #

Chooses from a list of functions, using a pattern of integers.

_pickF :: Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a #

contrast :: (ControlPattern -> ControlPattern) -> (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern #

contrast f f' p p' splits the control pattern p' in two, applying the function f to one and f' to the other. This depends on whether events in p' contain values matching with those in p. For example, in

contrast (# crush 3) (# vowel "a") (n "1") $ n "0 1" # s "bd sn" # speed 3

the first event will have the vowel effect applied and the second will have the crush applied.

contrast is like an if-else-statement over patterns. For contrast t f p you can think of t as the true branch, f as the false branch, and p as the test.

You can use any control pattern as a test of equality, e.g., n "1", speed "0.5", or things like that. This lets you choose specific properties of the pattern you’re transforming for testing, like in the following example,

d1 $ contrast (|+ n 12) (|- n 12) (n "c") $ n (run 4) # s "superpiano"

where every note that isn’t middle-c will be shifted down an octave but middle-c will be shifted up to c5.

Since the test given to contrast is also a pattern, you can do things like have it alternate between options:

d1 $ contrast (|+ n 12) (|- n 12) (s "<superpiano superchip>")
   $ s "superpiano superchip" # n 0

If you listen to this you’ll hear that which instrument is shifted up and which instrument is shifted down alternates between cycles.

contrastBy :: (a -> Value -> Bool) -> (ControlPattern -> Pattern b) -> (ControlPattern -> Pattern b) -> Pattern (Map String a) -> Pattern (Map String Value) -> Pattern b #

contrastBy is contrastBy is the general version of contrast, in which you can specify an abritrary boolean function that will be used to compare the control patterns.

d2 $ contrastBy (>=) (|+ n 12) (|- n 12) (n "2") $ n "0 1 2 [3 4]" # s "superpiano"

unfix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern #

Like contrast, but one function is given, and applied to events with controls which don't match. unfix is fix but only applies when the testing pattern is not a match.

fixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern #

The fixRange function isn’t very user-friendly at the moment, but you can create a fix variant with a range condition. Any value of a ControlPattern wich matches the values will apply the passed function.

d1 $ ( fixRange ( (# distort 1) . (# gain 0.8) )
                ( pure $ Map.singleton "note" ((VN 0, VN 7)) )
     )
   $ s "superpiano"
  <| note "1 12 7 11"

quantise :: (Functor f, RealFrac b) => b -> f b -> f b #

quantise limits values in a Pattern (or other Functor) to n equally spaced divisions of 1.

It is useful for rounding a collection of numbers to some particular base fraction. For example,

quantise 5 [0, 1.3 ,2.6,3.2,4.7,5]

It will round all the values to the nearest (1/5)=0.2 and thus will output the list [0.0,1.2,2.6,3.2,4.8,5.0]. You can use this function to force a continuous pattern like sine into specific values. In the following example:

d1 $ s "superchip*8" # n (quantise 1 $ range (-10) (10) $ slow 8 $ cosine)
                     # release (quantise 5 $ slow 8 $ sine + 0.1)

all the releases selected be rounded to the nearest 0.1 and the notes selected to the nearest 1.

quantise with fractional inputs does the consistent thing: quantise 0.5 rounds values to the nearest 2, quantise 0.25 rounds the nearest 4, etc.

qfloor :: (Functor f, RealFrac b) => b -> f b -> f b #

As quantise, but uses floor to calculate divisions.

qceiling :: (Functor f, RealFrac b) => b -> f b -> f b #

As quantise, but uses ceiling to calculate divisions.

qround :: (Functor f, RealFrac b) => b -> f b -> f b #

An alias for quantise.

inv :: Functor f => f Bool -> f Bool #

Inverts all the values in a boolean pattern

smooth :: Fractional a => Pattern a -> Pattern a #

smooth receives a pattern of numbers and linearly goes from one to the next, passing through all of them. As time is cycle-based, after reaching the last number in the pattern, it will smoothly go to the first one again.

d1 $ sound "bd*4" # pan (slow 4 $ smooth "0 1 0.5 1")

This sound will pan gradually from left to right, then to the center, then to the right again, and finally comes back to the left.

snowball :: Int -> (Pattern a -> Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

snowball takes a function that can combine patterns (like +), a function that transforms a pattern (like slow), a depth, and a starting pattern, it will then transform the pattern and combine it with the last transformation until the depth is reached. This is like putting an effect (like a filter) in the feedback of a delay line; each echo is more affected.

d1 $ note ( scale "hexDorian"
          $ snowball 8 (+) (slow 2 . rev) "0 ~ . -1 . 5 3 4 . ~ -2"
          )
   # s "gtr"

soak :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

Applies a function to a pattern and cats the resulting pattern, then continues applying the function until the depth is reached this can be used to create a pattern that wanders away from the original pattern by continually adding random numbers.

d1 $ note ( scale "hexDorian" mutateBy (+ (range -1 1 $ irand 2)) 8
          $ "0 1 . 2 3 4"
          )
   # s "gtr"

deconstruct :: Int -> Pattern String -> String #

construct n p breaks p into pieces and then reassembles them so that it fits into n steps.

bite :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a #

bite n ipat pat slices a pattern pat into n pieces, then uses the ipat pattern of integers to index into those slices. So bite 4 "0 2*2" (run 8) is the same as "[0 1] [4 5]*2".

I.e., it allows you to slice each cycle into a given number of equal sized bits, and then pattern those bits by number. It’s similar to slice, but is for slicing up patterns, rather than samples. The following slices the pattern into four bits, and then plays those bits in turn:

d1 $ bite 4 "0 1 2 3" $ n "0 .. 7" # sound "arpy"

Of course that doesn’t actually change anything, but then you can reorder those bits:

d1 $ bite 4 "2 0 1 3" $ n "0 .. 7" # sound "arpy"

The slices bits of pattern will be squeezed or contracted to fit:

d1 $ bite 4 "2 [0 3] 1*4 1" $ n "0 .. 7" # sound "arpy"

_bite :: Int -> Pattern Int -> Pattern a -> Pattern a #

chew :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern #

chew works the same as bite, but speeds up/slows down playback of sounds as well as squeezing/contracting the slices of the provided pattern. Compare:

d1 $ 'bite' 4 "0 1*2 2*2 [~ 3]" $ n "0 .. 7" # sound "drum"
d1 $ chew 4 "0 1*2 2*2 [~ 3]" $ n "0 .. 7" # sound "drum"

__binary :: Bits b => Int -> b -> [Bool] #

_binary :: Bits b => Int -> b -> Pattern Bool #

grain :: Pattern Double -> Pattern Double -> ControlPattern #

Given a start point and a duration (both specified in cycles), this generates a control pattern that makes a sound begin at the start point and last the duration.

The following are equivalent:

d1 $ slow 2 $ s "bev" # grain 0.2 0.1 # legato 1
d1 $ slow 2 $ s "bev" # begin 0.2 # end 0.3 # legato 1

grain is defined as:

grain s d = 'Sound.Tidal.Params.begin' s # 'Sound.Tidal.Params.end' (s+d)

necklace :: Rational -> [Int] -> Pattern Bool #

For specifying a boolean pattern according to a list of offsets (aka inter-onset intervals). For example necklace 12 [4,2] is the same as "t f f f t f t f f f t f". That is, 12 steps per cycle, with true values alternating between every 4 and every 2 steps.

chromaticiseBy :: (Num a, Enum a, Ord a) => Pattern a -> Pattern a -> Pattern a #

Inserts chromatic notes into a pattern.

The first argument indicates the (patternable) number of notes to insert, and the second argument is the base pattern of "anchor notes" that gets transformed.

The following are equivalent:

d1 $ up (chromaticiseBy "0 1 2 -1" "[0 2] [3 6] [5 6 8] [3 1 0]") # s "superpiano"
d1 $ up "[0 2] [[3 4] [6 7]] [[5 6 7] [6 7 8] [8 9 10] [[3 2] [1 0] [0 -1]]" # s "superpiano"

_chromaticiseBy :: (Num a, Enum a, Ord a) => a -> Pattern a -> Pattern a #

chromaticizeBy :: (Num a, Enum a, Ord a) => Pattern a -> Pattern a -> Pattern a #

Alias for chromaticiseBy

_ribbon :: Time -> Time -> Pattern a -> Pattern a #

ribbon :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a #

Loops a pattern inside an offset for cycles. If you think of the entire span of time in cycles as a ribbon, you can cut a single piece and loop it.

rib :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a #

Shorthand for ribbon.

unjoin :: Pattern Bool -> Pattern b -> Pattern (Pattern b) #

Turns a pattern into a pattern of patterns, according to the structure of another given pattern.

into :: Pattern Bool -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b #

Applies a function to subcycles of a pattern, as defined by the structure of another given pattern.

data Sign #

Constructors

Positive 
Negative 

class Enumerable a where #

Methods

fromTo :: a -> a -> Pattern a #

fromThenTo :: a -> a -> a -> Pattern a #

Instances

Instances details
Enumerable Rational 
Instance details

Defined in Sound.Tidal.ParseBP

Enumerable ColourD 
Instance details

Defined in Sound.Tidal.ParseBP

Enumerable Note 
Instance details

Defined in Sound.Tidal.ParseBP

Enumerable String 
Instance details

Defined in Sound.Tidal.ParseBP

Enumerable Integer 
Instance details

Defined in Sound.Tidal.ParseBP

Enumerable Bool 
Instance details

Defined in Sound.Tidal.ParseBP

Enumerable Char 
Instance details

Defined in Sound.Tidal.ParseBP

Enumerable Double 
Instance details

Defined in Sound.Tidal.ParseBP

Enumerable Int 
Instance details

Defined in Sound.Tidal.ParseBP

Methods

fromTo :: Int -> Int -> Pattern Int #

fromThenTo :: Int -> Int -> Int -> Pattern Int #

Enumerable [Modifier] 
Instance details

Defined in Sound.Tidal.ParseBP

class Parseable a where #

Minimal complete definition

tPatParser, doEuclid

Instances

Instances details
Parseable Rational 
Instance details

Defined in Sound.Tidal.ParseBP

Parseable ColourD 
Instance details

Defined in Sound.Tidal.ParseBP

Parseable Note 
Instance details

Defined in Sound.Tidal.ParseBP

Parseable String 
Instance details

Defined in Sound.Tidal.ParseBP

Parseable Integer 
Instance details

Defined in Sound.Tidal.ParseBP

Parseable Bool 
Instance details

Defined in Sound.Tidal.ParseBP

Parseable Char 
Instance details

Defined in Sound.Tidal.ParseBP

Parseable Double 
Instance details

Defined in Sound.Tidal.ParseBP

Parseable Int 
Instance details

Defined in Sound.Tidal.ParseBP

Parseable [Modifier] 
Instance details

Defined in Sound.Tidal.ParseBP

data TPat a where #

AST representation of patterns

Constructors

TPat_Atom :: forall a. Maybe ((Int, Int), (Int, Int)) -> a -> TPat a 
TPat_Fast :: forall a. TPat Time -> TPat a -> TPat a 
TPat_Slow :: forall a. TPat Time -> TPat a -> TPat a 
TPat_DegradeBy :: forall a. Int -> Double -> TPat a -> TPat a 
TPat_CycleChoose :: forall a. Int -> [TPat a] -> TPat a 
TPat_Euclid :: forall a. TPat Int -> TPat Int -> TPat Int -> TPat a -> TPat a 
TPat_Stack :: forall a. [TPat a] -> TPat a 
TPat_Polyrhythm :: forall a. Maybe (TPat Rational) -> [TPat a] -> TPat a 
TPat_Seq :: forall a. [TPat a] -> TPat a 
TPat_Silence :: forall a. TPat a 
TPat_Foot :: forall a. TPat a 
TPat_Elongate :: forall a. Rational -> TPat a -> TPat a 
TPat_Repeat :: forall a. Int -> TPat a -> TPat a 
TPat_EnumFromTo :: forall a. TPat a -> TPat a -> TPat a 
TPat_Var :: forall a. String -> TPat a 
TPat_Chord :: forall b a. (Num b, Enum b, Parseable b, Enumerable b) => (b -> a) -> TPat b -> TPat String -> [TPat [Modifier]] -> TPat a 

Instances

Instances details
Functor TPat 
Instance details

Defined in Sound.Tidal.ParseBP

Methods

fmap :: (a -> b) -> TPat a -> TPat b #

(<$) :: a -> TPat b -> TPat a #

Show a => Show (TPat a) 
Instance details

Defined in Sound.Tidal.ParseBP

Methods

showsPrec :: Int -> TPat a -> ShowS #

show :: TPat a -> String #

showList :: [TPat a] -> ShowS #

tShowList :: Show a => [TPat a] -> String #

tShow :: Show a => TPat a -> String #

toPat :: (Parseable a, Enumerable a) => TPat a -> Pattern a #

resolve_size :: [TPat a] -> [(Rational, TPat a)] #

steps_seq :: Show a => [TPat a] -> (Rational, String) #

steps_size :: Show a => [TPat a] -> [(Rational, String)] #

parseRest :: Parseable a => MyParser (TPat a) #

a - is a negative sign if followed anything but another dash otherwise, it's treated as rest

enumFromTo' :: (Ord a, Enum a) => a -> a -> Pattern a #

enumFromThenTo' :: (Ord a, Enum a, Num a) => a -> a -> a -> Pattern a #

applySign :: Num a => Sign -> a -> a #

pTidal :: Parseable a => MyParser (TPat a) -> MyParser (TPat a) #

parser starting point

pSequence :: Parseable a => MyParser (TPat a) -> MyParser (TPat a) #

Try different parsers on a sequence of Tidal patterns f is the sequence so far, a the next upcoming token/non-terminal

pRepeat :: TPat a -> MyParser (TPat a) #

parseChord :: (Enum a, Num a) => MyParser [a] #

pMult :: TPat a -> MyParser (TPat a) #

pRand :: TPat a -> MyParser (TPat a) #

pE :: TPat a -> MyParser (TPat a) #

parse Euclidean notation like 'bd(3,8)'

isInt :: RealFrac a => a -> Bool #

pChord :: (Enum a, Num a, Parseable a, Enumerable a) => TPat a -> MyParser (TPat a) #

spin :: Pattern Int -> ControlPattern -> ControlPattern #

spin will "spin" and 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. The result is a pattern that seems to spin around. This function work well on multichannel systems.

d1 $ slow 3
   $ spin 4
   $ sound "drum*3 tabla:4 [arpy:2 ~ arpy] [can:2 can:3]"

chop :: Pattern Int -> ControlPattern -> ControlPattern #

chop granularises every sample in place as it is played, turning a pattern of samples into a pattern of sample parts. Can be used to explore granular synthesis.

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 chop 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]"

You can also use chop (or striate) with very long samples to cut them into short chunks and pattern those chunks. The following cuts a sample into 32 parts, and plays it over 8 cycles:

d1 $ loopAt 8 $ chop 32 $ sound "bev"

The loopAt takes care of changing the speed of sample playback so that the sample fits in the given number of cycles perfectly. As a result, in the above the granules line up perfectly, so you can’t really hear that the sample has been cut into bits. Again, this becomes more apparent when you do further manipulations of the pattern, for example rev to reverse the order of the cut up bits:

d1 $ loopAt 8 $ rev $ chop 32 $ sound "bev"

chopArc :: Arc -> Int -> [Arc] #

striate :: Pattern Int -> ControlPattern -> ControlPattern #

Striate is a kind of granulator, cutting samples into bits in a similar to chop, but the resulting bits are organised differently. For example:

d1 $ striate 3 $ sound "ho ho:2 ho:3 hc"

This plays the loop the given number of times, but triggers 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, and lastly playing the last third of each sample. Replacing striate with chop above, one can hear that the 'chop version plays the bits from each chopped-up sample in turn, while striate "interlaces" the cut up bits of samples together.

You can also use striate with very long samples, to cut them 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"

striateBy :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern #

The striateBy function is a variant of striate with an extra parameter which specifies the length of each part. The striateBy 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:

d1 $ slow 32 $ striateBy 32 (1/16) $ sound "bev"

Note that striate and striateBy use the begin and end parameters internally. This means that you probably shouldn't also specify begin or end.

gap :: Pattern Int -> ControlPattern -> ControlPattern #

gap is similar to chop 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:

d1 $ gap 8 $ sound "jvbass"
d1 $ gap 16 $ sound "[jvbass drum:4]"

weave :: Time -> ControlPattern -> [ControlPattern] -> ControlPattern #

weave applies one control pattern to a list of other control patterns, with a successive time offset. It uses an OscPattern to apply the function at different levels to each pattern, creating a weaving effect. For example:

d1 $ weave 16 (pan sine)
     [ sound "bd sn cp"
     , sound "casio casio:1"
     , sound "[jvbass*2 jvbass:2]/2"
     , sound "hc*4"
     ]

In the above, the pan sine control pattern is slowed down by the given number of cycles, in particular 16, and applied to all of the given sound patterns. What makes this interesting is that the pan control pattern is successively offset for each of the given sound patterns; because the pan is closed down by 16 cycles, and there are four patterns, they are ‘spread out’, i.e. with a gap of four cycles. For this reason, the four patterns seem to chase after each other around the stereo field. Try listening on headphones to hear this more clearly.

You can even have it the other way round, and have the effect parameters chasing after each other around a sound parameter, like this:

d1 $ weave 16 (sound "arpy" >| n (run 8))
     [ vowel "a e i"
     , vowel "i [i o] o u"
     , vowel "[e o]/3 [i o u]/2"
     , speed "1 2 3"
     ]

weaveWith :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a #

weaveWith is similar to the above, but weaves with a list of functions, rather than a list of controls. For example:

d1 $ weaveWith 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]")
     [ fast 2
     , (# speed "0.5")
     , chop 16
     ]

weave' :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a #

An old alias for weaveWith.

interlace :: ControlPattern -> ControlPattern -> ControlPattern #

(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.)

Shifts between the two given patterns, using distortion.

Example:

d1 $ interlace (sound  "bd sn kurt") (every 3 rev $ sound  "bd sn:2")

slice :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern #

slice is similar to chop and striate, in that it’s used to slice samples up into bits. The difference is that it allows you to rearrange those bits as a pattern.

d1 $ slice 8 "7 6 5 4 3 2 1 0"
   $ sound "breaks165"
   # legato 1

The above slices the sample into eight bits, and then plays them backwards, equivalent of applying rev $ chop 8. Here’s a more complex example:

d1 $ slice 8 "[<0*8 0*2> 3*4 2 4] [4 .. 7]"
   $ sound "breaks165"
   # legato 1

randslice :: Pattern Int -> ControlPattern -> ControlPattern #

randslice chops the sample into the given number of pieces and then plays back a random one each cycle:

d1 $ randslice 32 $ sound "bev"

Use fast to get more than one per cycle:

d1 $ fast 4 $ randslice 32 $ sound "bev"

splice :: Pattern Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value) #

splice is similar to slice, but the slices are automatically pitched up or down to fit their ‘slot’.

d1 $ splice 8 "[<0*8 0*2> 3*4 2 4] [4 .. 7]" $ sound "breaks165"

loopAt :: Pattern Time -> ControlPattern -> ControlPattern #

loopAt makes a sample fit the given number of cycles. Internally, it works by setting the unit parameter to "c", changing the playback speed of the sample with the speed parameter, and setting setting the density of the pattern to match.

d1 $ loopAt 4 $ sound "breaks125"

It’s a good idea to use this in conjuction with chop, so the break is chopped into pieces and you don’t have to wait for the whole sample to start/stop.

d1 $ loopAt 4 $ chop 32 $ sound "breaks125"

Like all Tidal functions, you can mess about with this considerably. The below example shows how you can supply a pattern of cycle counts to loopAt:

d1 $ juxBy 0.6 (|* speed "2")
   $ slowspread (loopAt) [4,6,2,3]
   $ chop 12
   $ sound "fm:14"

hurry :: Pattern Rational -> ControlPattern -> ControlPattern #

hurry is similiar to fast in that it speeds up a pattern, but it also increases the speed control by the same factor. So, if you’re triggering samples, the sound gets higher in pitch. For example:

d1 $ every 2 (hurry 2) $ sound "bd sn:2 ~ cp"

smash :: Pattern Int -> [Pattern Time] -> ControlPattern -> Pattern ValueMap #

smash is a combination of spread and striate — 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:

d1 $ spread (slow) [2,3,4] $ striate 3 $ sound "ho ho:2 ho:3 hc"

This is quite dancehall:

d1 $ ( 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"

smash' :: Int -> [Pattern Time] -> ControlPattern -> ControlPattern #

An altenative form of smash, which uses chop instead of striate.

Compare the following variations:

d1 $ smash 6 [2,3,4] $ sound "ho ho:2 ho:3 hc"
d1 $ smash' 6 [2,3,4] $ sound "ho ho:2 ho:3 hc"
d1 $ smash 12 [2,3,4] $ s "bev*4"
d1 $ smash' 12 [2,3,4] $ s "bev*4"

echoWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

echoWith is similar to echo, but instead of just decreasing volume to produce echoes, echoWith applies a function each step and overlays the result delayed by the given time.

d1 $ echoWith 2 "1%3" (# vowel "{a e i o u}%2") $ sound "bd sn"

In this case there are two _overlays_ delayed by 1/3 of a cycle, where each has the vowel filter applied.

d1 $ echoWith 4 (1/6) (|* speed "1.5") $ sound "arpy arpy:2"

In the above, three versions are put on top, with each step getting higher in pitch as |* speed "1.5" is successively applied.

_echoWith :: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

stutWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

DEPRECATED, use echoWith instead

_stutWith :: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

stut' :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #

DEPRECATED, use echoWith instead

msec :: Fractional a => Pattern a -> Pattern a #

Turns a pattern of milliseconds into a pattern of (rational) cycle durations, according to the current cps.

trigger :: Pattern a -> Pattern a #

Align the start of a pattern with the time a pattern is evaluated, rather than the global start time. Because of this, the pattern will probably not be aligned to the pattern grid.

qtrigger :: Pattern a -> Pattern a #

(Alias qt) Quantise trigger. Aligns the start of the pattern with the next cycle boundary. For example, this pattern will fade in starting with the next cycle after the pattern is evaluated:

d1 $ qtrigger $ s "hh(5, 8)" # amp envL

Note that the pattern will start playing immediately. The start of the pattern aligns with the next cycle boundary, but events will play before if the pattern has events at negative timestamps (which most loops do). These events can be filtered out, for example:

d1 $ qtrigger $ filterWhen (>= 0) $ s "hh(5, 8)"

Alternatively, you can use wait to achieve the same result:

wait 1 1 $ s "bd hh hh hh"

qt :: Pattern a -> Pattern a #

Alias for qtrigger.

ctrigger :: Pattern a -> Pattern a #

Ceiling trigger. Aligns the start of a pattern to the next cycle boundary, just like qtrigger.

rtrigger :: Pattern a -> Pattern a #

Rounded trigger. Aligns the start of a pattern to the nearest cycle boundary, either next or previous.

ftrigger :: Pattern a -> Pattern a #

Floor trigger. Aligns the start of a pattern to the previous cycle boundary.

mtrigger :: Int -> Pattern a -> Pattern a #

(Alias mt) Mod trigger. Aligns the start of a pattern to the next cycle boundary where the cycle is evenly divisible by a given number. qtrigger is equivalent to mtrigger 1.

In the following example, when activating the d1 pattern, it will start at the same time as the next clap, even if it has to wait for 3 cycles. Once activated, the arpy sound will play on every cycle, just like any other pattern:

do
  resetCycles
  d2 $ every 4 (# s "clap") $ s "bd"
d1 $ mtrigger 4 $ filterWhen (>=0) $ s "arpy"

mt :: Int -> Pattern a -> Pattern a #

Alias for mtrigger.

triggerWith :: (Time -> Time) -> Pattern a -> Pattern a #

This aligns the start of a pattern to some value relative to the time the pattern is evaluated. The provided function maps the evaluation time (on the global cycle clock) to a new time, and then triggerWith aligns the pattern's start to the time that's returned.

This is a more flexible triggering function. In fact, all the other trigger functions are defined based on triggerWith. For example, trigger is just triggerWith id.

In the next example, use d1 as a metronome, and play with different values (from 0 to 1) on the const expression. You’ll notice how the clap is displaced from the beginning of each cycle to the end, as the number increases:

d1 $ s "bd hh!3"

d2 $ triggerWith (const 0.1) $ s "clap"

This last example is equivalent to this:

d2 $ rotR 0.1 $ s "clap"

data Target Source #

Instances

Instances details
Show Target Source # 
Instance details

Defined in Sound.Tidal.Stream.Types

doTick :: MVar ValueMap -> MVar PlayMap -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> (Time, Time) -> Double -> ClockConfig -> ClockRef -> (SessionState, SessionState) -> IO () Source #

Query the current pattern (contained in argument stream :: Stream) for the events in the current arc (contained in argument st :: T.State), translate them to OSC messages, and send these.

If an exception occurs during sending, this functions prints a warning and continues, because the likely reason is that the backend (supercollider) isn't running.

If any exception occurs before or outside sending (e.g., while querying the pattern, while computing a message), this function prints a warning and resets the current pattern to the previous one (or to silence if there isn't one) and continues, because the likely reason is that something is wrong with the current pattern.

getCXs :: Config -> [(Target, [OSC])] -> IO [Cx] Source #

data PlayState Source #

Instances

Instances details
Show PlayState Source # 
Instance details

Defined in Sound.Tidal.Stream.Types

data Cx Source #

Constructors

Cx 

data StampStyle Source #

Constructors

BundleStamp 
MessageStamp 

Instances

Instances details
Show StampStyle Source # 
Instance details

Defined in Sound.Tidal.Stream.Types

Eq StampStyle Source # 
Instance details

Defined in Sound.Tidal.Stream.Types

data Schedule Source #

Constructors

Pre StampStyle 
Live 

Instances

Instances details
Show Schedule Source # 
Instance details

Defined in Sound.Tidal.Stream.Types

Eq Schedule Source # 
Instance details

Defined in Sound.Tidal.Stream.Types

data Args Source #

Constructors

Named 

Fields

ArgList [(String, Maybe Value)] 

Instances

Instances details
Show Args Source # 
Instance details

Defined in Sound.Tidal.Stream.Types

Methods

showsPrec :: Int -> Args -> ShowS #

show :: Args -> String #

showList :: [Args] -> ShowS #

sendBndl :: Bool -> Cx -> Bundle -> IO () Source #

sendO :: Bool -> Cx -> Message -> IO () Source #

streamMutes :: Stream -> [ID] -> IO () Source #

_wash :: (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Time -> Time -> Time -> Time -> [Pattern a] -> Pattern a Source #

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

_washIn :: (Pattern a -> Pattern a) -> Time -> Time -> [Pattern a] -> Pattern a Source #

_histpan :: Int -> Time -> [ControlPattern] -> ControlPattern Source #

Pans the last n versions of the pattern across the field

_wait :: Time -> Time -> [ControlPattern] -> ControlPattern Source #

Just stop for a bit before playing new pattern

_waitT :: (Time -> [ControlPattern] -> ControlPattern) -> Time -> Time -> [ControlPattern] -> ControlPattern Source #

Just as wait, waitT stops for a bit and then applies the given transition to the playing pattern

d1 $ sound "bd"

t1 (waitT (xfadeIn 8) 4) $ sound "hh*8"

_jump :: Time -> [ControlPattern] -> ControlPattern Source #

Jumps directly into the given pattern, this is essentially the _no transition_-transition.

Variants of jump provide more useful capabilities, see jumpIn and jumpMod

_jumpIn :: Int -> Time -> [ControlPattern] -> ControlPattern Source #

Sharp jump transition after the specified number of cycles have passed.

t1 (jumpIn 2) $ sound "kick(3,8)"

_jumpIn' :: Int -> Time -> [ControlPattern] -> ControlPattern Source #

Unlike jumpIn the variant jumpIn' will only transition at cycle boundary (e.g. when the cycle count is an integer).

_jumpMod :: Int -> Time -> [ControlPattern] -> ControlPattern Source #

Sharp jump transition at next cycle boundary where cycle mod n == 0

_jumpMod' :: Int -> Int -> Time -> [ControlPattern] -> ControlPattern Source #

Sharp jump transition at next cycle boundary where cycle mod n == p

_mortal :: Time -> Time -> Time -> [ControlPattern] -> ControlPattern Source #

Degrade the new pattern over time until it ends in silence

_clutch :: Time -> [Pattern a] -> Pattern a Source #

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

_clutchIn :: Time -> Time -> [Pattern a] -> Pattern a Source #

Also degrades the current pattern and undegrades the next. To change the number of cycles the transition takes, you can use clutchIn like so:

d1 $ sound "bd(5,8)"

t1 (clutchIn 8) $ sound "[hh*4, odx(3,8)]"

will take 8 cycles for the transition.

_anticipateIn :: Time -> Time -> [ControlPattern] -> ControlPattern Source #

same as anticipate though it allows you to specify the number of cycles until dropping to the new pattern, e.g.:

d1 $ sound "jvbass(3,8)"

t1 (anticipateIn 4) $ sound "jvbass(5,8)"

_anticipate :: Time -> [ControlPattern] -> ControlPattern Source #

anticipate is an increasing comb filter.

Build up some tension, culminating in a _drop_ to the new pattern after 8 cycles.