Temporal.Music.Notation.Score

Functions for score composition.

Types

type Time = Double

time

type Dur = Double

duration

type Score a = Media Dur a

In Score a values of type a can be wrapped in time events as if they present or abscent for some time Dur and combined together in parrallel or sequent ways.

Score is instance of

• Functor Score

Functor instance means that you can map over score values with some function (a -> b), rests are mapped to rests and values transformed with given function.

Constructors

rest :: Dur -> Score a

pause for some Dur time

note :: Dur -> a -> Score a

Constructor of score. Constructs note out of given value that lasts for some time.

Duration querry

dur :: Score a -> Dur

querry score's duration

Composition

(+:+) :: Score a -> Score a -> Score a

binary sequential composition, a +:+ b means play a and then play b.

(=:=) :: Score a -> Score a -> Score a

binary parallel composition, a =:= b means play a and b simultoneously.

(=:/) :: Score a -> Score a -> Score a

turncating parallel composition

for a =:/ b composes two scores together and turncates biggest one by duration of smallest one.

line :: [Score a] -> Score a

sequential composition for list of scores

chord :: [Score a] -> Score a

parallel composition for list of scores

chordT :: [Score a] -> Score a

turncating parallel composition for lists of scores

loop :: Int -> Score a -> Score a

Arranges n copies of score in line.

trill :: Int -> Score a -> Score a -> Score a

loop for two groups of notes. Repeats n times line of two scores.

Transformers

In time domain

delay :: Dur -> Score a -> Score a

Delay scores by given duration.

stretch :: Dur -> Score a -> Score a

stretch in time domain. Duration of every note segemnt is multiplied by given factor.

bpm :: Double -> Score a -> Score a

set tempo in beats per minute, if 1 Dur is equal to 1 second before transformation.

dot :: Score a -> Score a

stretch with 1.5

ddot :: Score a -> Score a

double dot, stretch with 1.75

tri :: Score a -> Score a

stretch with 2/3

slice :: Dur -> Dur -> Score a -> Score a

extracting score parts in some time interval. it reverses output if t1 < t0.

takeS :: Dur -> Score a -> Score a

take sub-score from begining

dropS :: Dur -> Score a -> Score a

drop sub-score

reverseS :: Score a -> Score a

reverse score

pedal :: Dur -> Score a -> Score a

adds sustain, but total duration of score elements remains unchaged

notes are sustained within total duration interval. adds given amount of time to all notes.

pedalBy :: (Time -> Dur -> a -> (Dur, b)) -> Score a -> Score b

general "pedal"

Total duration of score element remains unchanged. notes are sustained within total duration interval

sustain :: Dur -> Score a -> Score a

adds given amount of duration to all notes

sustainBy :: (Time -> Dur -> a -> (Dur, b)) -> Score a -> Score b

general sustain

Mappings

tmap :: (Time -> a -> b) -> Score a -> Score b

temporal functor tmap method for scores

map with time

dmap :: (Dur -> a -> b) -> Score a -> Score b

temporal functor dmap method for scores

map with duration

tdmap :: (Time -> Dur -> a -> b) -> Score a -> Score b

temporal functor tdmap method for scores

map with time and duration

Rendering

data Event t a

Constant time events. Value a starts at some time and lasts for some time.

Constructors

Event

Fields

eventStart :: t

eventDur :: t

eventContent :: a

Instances

Functor (Event t)

(Eq t, Eq a) => Eq (Event t a)

(Show t, Show a) => Show (Event t a)

data EventList t a

List of Event s. First argument stands for total duration of EventList.

Constructors

EventList t [Event t a]

Instances

Functor (EventList t)

(Eq t, Eq a) => Eq (EventList t a)

(Show t, Show a) => Show (EventList t a)

renderScore :: Score a -> EventList Dur a

Transform Score to EventList

Miscellaneous

tmapRel :: (Time -> a -> b) -> Score a -> Score b

relative tmap

map with time normalized by total duration value

dmapRel :: (Dur -> a -> b) -> Score a -> Score b

relative dmap

map with duration normalized by total duration value

tdmapRel :: (Time -> Dur -> a -> b) -> Score a -> Score b

relative tdmap

map with time and duration normalized by total duration value

linseg :: (Ord t, Fractional t) => [t] -> t -> t

Linear interpolation. Can be useful with eventMap for envelope changes.

linseg [a, da, b, db, c, ... ]

a, b, c ... - values

da, db, ... - duration of segments