Sound.SC3.Lang.Control.Event

An Event is a (Key,Field) map.

Field

data Field

Event field.

Fields are Num.

5 :: Field
4 + 5 :: Field
negate 5 :: Field
f_array [2,3] + f_array [4,5] == f_array [6,8]
f_array [1,2,3] + f_array [4,5] == f_array [5,7,7]
4 + f_array [5,6] == f_array [9,10]

Constructors

F_Double

Fields

f_double :: Double

F_Vector

Fields

f_vector :: [Field]

F_String

Fields

f_string :: String

F_Instr

Fields

f_instr :: Instr

Instances

Enum Field

Eq Field

Floating Field

Fractional Field

Num Field

Ord Field

Real Field

RealFloat Field

RealFrac Field

Show Field

IsString Field

Random Field

EqE Field

OrdE Field

RealFracE Field

UnaryOp Field

BinaryOp Field

F_Num Field

F_Value Field

class F_Value a where

Set of types that can be lifted to Field.

Methods

toF :: a -> Field

Instances

F_Value Bool

F_Value Double

F_Value Int

F_Value Instr

F_Value Field

class F_Value a => F_Num a

Numeric F_Value types.

Instances

F_Num Double

F_Num Int

F_Num Field

f_double_m :: Field -> Maybe Double

Maybe variant of f_double.

f_reader_err :: String -> String -> (Field -> Maybe a) -> Field -> a

Variant of reader with specified error message.

f_double_err :: String -> Field -> Double

Variant of f_double with specified error message.

f_bool_err :: String -> Field -> Bool

Run > 0 at f_double.

f_int_err :: String -> Field -> Int

Run round at f_double.

f_ref :: Field -> Field

Single element F_Vector constructor.

f_ref 1 == f_array [1]

f_array :: [Double] -> Field

Uniform vector constructor.

f_array [1,2] == F_Vector [F_Double 1,F_Double 2]

f_vector_m :: Field -> Maybe [Field]

Maybe variant of f_vector.

f_vector_length :: Field -> Maybe Int

length of f_vector_m.

f_vector_length (f_array [1..5]) == Just 5

f_double_err_ix :: String -> Maybe Int -> Field -> Double

Indexed variant of f_double_err.

f_double_err_ix "" Nothing 1 == 1
f_double_err_ix "" (Just 1) (f_array [0,1]) == 1

f_instr_m :: Field -> Maybe Instr

Maybe variant of f_instr.

f_instr_err :: String -> Field -> Instr

Variant of f_instr with specified error message.

f_map :: (Field -> Field) -> Field -> Field

Map fn over vector elements at f.

f_map negate (f_array [0,1]) == f_array [0,-1]

f_uop :: (Double -> Double) -> Field -> Field

Numerical unary operator.

f_uop negate (F_Double 1) == F_Double (-1)
f_uop negate (F_Vector [F_Double 0,F_Double 1]) == f_array [0,-1]

f_binop :: (Double -> Double -> Double) -> Field -> Field -> Field

Numerical binary operator.

f_binop (+) (F_Double 1) (F_Double 2) == F_Double 3
f_binop (*) (f_array [1,2,3]) (f_array [3,4,5]) == f_array [3,8,15]
f_binop (/) (F_Double 9) (F_Double 3) == F_Double 3

f_atf :: (Double -> a) -> Field -> a

At floating branch of Field.

f_atf2 :: (Double -> Double -> a) -> Field -> Field -> a

At floating branches of Fields.

f_atf3 :: (Double -> Double -> Double -> a) -> Field -> Field -> Field -> a

At floating branches of Fields.

f_mce_extend :: Int -> Field -> Field

Extend to Field to n.

f_mce_extend 3 (f_array [1,2]) == f_array [1,2,1]
f_mce_extend 3 1 == f_array [1,1,1]

Key

data Key

The type of the key at an Event.

:set -XOverloadedStrings
[K_dur,"pan"] == [K_dur,K_param "pan"]

Constructors

K_degree

K_mtranspose

K_scale

K_stepsPerOctave

K_gtranspose

K_note

K_octave

K_root

K_ctranspose

K_harmonic

K_midinote

K_detune

K_freq

K_delta

K_dur

K_lag

K_legato

K_fwd'

K_stretch

K_sustain

K_tempo

K_db

K_amp

K_rest

K_instr

K_id

K_type

K_latency

K_param String

Instances

Eq Key

Ord Key

Show Key

IsString Key

k_name :: Key -> String

SC3 name of Key.

map k_name [K_freq,K_dur,K_param "pan"] == ["freq","dur","pan"]

k_reserved :: [Key]

List of reserved Keys used in pitch, duration and amplitude models. These are keys that may be provided explicitly, but if not will be calculated implicitly.

(K_freq `elem` k_reserved) == True

k_vector :: [Key]

k_is_parameter :: (Key, a) -> Bool

Is Key not k_reserved, and not k_vector.

k_is_parameter (K_param "pan",0) == True

Event

type Event = Map Key Field

An Event is a (Key,Field) map.

e_insert :: Key -> Field -> Event -> Event

Insert (k,v) into e.

e_get K_id (e_insert K_id 1 mempty) == Just 1

e_from_list :: [(Key, Field)] -> Event

Event from association list.

e_get K_id (e_from_list [(K_id,1)]) == Just 1

e_to_list :: Event -> [(Key, Field)]

Event from association list.

let a = [(K_id,1)] in e_to_list (e_from_list a) == a

e_get :: Key -> Event -> Maybe Field

Lookup k in e.

e_get K_id mempty == Nothing

e_get_ix :: Maybe Int -> Key -> Event -> Maybe Field

Immediate or vector element lookup.

e_get_ix Nothing K_id (e_from_list [(K_id,1)]) == Just 1

let n = f_array [0,1,2]
in e_get_ix Nothing K_id (e_from_list [(K_id,n)]) == Just n

let n = f_array [0..9]
in e_get_ix (Just 5) K_id (e_from_list [(K_id,n)]) == Just 5

e_get_double :: Key -> Event -> Maybe Double

Type specialised e_get.

e_get_double_ix :: Maybe Int -> Key -> Event -> Maybe Double

Type specialised e_get_ix.

e_get_bool :: Key -> Event -> Maybe Bool

Type specialised e_get.

e_get_int :: Key -> Event -> Maybe Int

Type specialised e_get.

e_get_int_ix :: Maybe Int -> Key -> Event -> Maybe Int

Type specialised e_get_ix.

e_get_instr :: Key -> Event -> Maybe Instr

Type specialised e_get.

e_get_instr_ix :: Maybe Int -> Key -> Event -> Maybe Instr

Type specialised e_get_ix.

e_get_array :: Key -> Event -> Maybe [Double]

Type specialised e_get.

e_get_array_ix :: Maybe Int -> Key -> Event -> Maybe [Double]

Type specialised e_get_ix.

let e = e_from_list [(K_scale,f_array [0,2])]
in e_get_array_ix Nothing K_scale e == Just [0,2]

let e = e_from_list [(K_scale,f_ref (f_array [0,2]))]
in e_get_array_ix (Just 0) K_scale e == Just [0,2]

e_type :: Event -> String

Event type.

e_type mempty == "s_new"

e_type_match :: Event -> T3 (Event -> t) -> t

Match on event types, in sequence: s_new, n_set, rest.

e_type_match' :: Event -> T3 t -> t

const variant of e_type_match.

e_dur :: Maybe Int -> Event -> Dur

Generate Dur from Event.

D.delta (e_dur Nothing mempty) == 1
D.fwd (e_dur Nothing (e_from_list [(K_dur,1),(K_stretch,2)])) == 2

let e = e_from_list [(K_dur,1),(K_legato,0.5)]
in D.occ (e_dur Nothing e) == 0.5

e_pitch :: Maybe Int -> Event -> Pitch

Generate Pitch from Event.

P.midinote (e_pitch Nothing mempty) == 60
P.freq (e_pitch Nothing (e_from_list [(K_degree,5)])) == 440

let e = e_from_list [(K_degree,5),(K_scale,f_array [0,2,3,5,7,8,10])]
in P.midinote (e_pitch Nothing e) == 68

let e = e_from_list [(K_degree,5),(K_scale,f_ref (f_array [0,2,3,5,7,8,10]))]
in P.midinote (e_pitch (Just 0) (e_mce_expand e)) == 68

P.freq (e_pitch Nothing (e_from_list [(K_midinote,69)])) == 440

e_id :: Maybe Int -> Event -> Maybe Int

Event identifier.

e_db :: Maybe Int -> Event -> Double

Lookup db field of Event.

e_db Nothing mempty == (-20)

e_amp :: Maybe Int -> Event -> Double

The linear amplitude of the amplitude model at e.

e_amp Nothing (e_from_list [(K_db,-60)]) == 0.001
e_amp Nothing (e_from_list [(K_amp,0.01)]) == 0.01
e_amp Nothing mempty == 0.1

e_latency :: Event -> Double

Message latency of event.

e_latency mempty == 0.1

e_parameters :: Maybe Int -> Event -> [(String, Double)]

Extract non-reserved Keys from Event.

let e = e_from_list [(K_freq,1),(K_param "p",1),(K_scale,f_ref (f_array [0,3,7]))]
in e_parameters Nothing e == [("p",1)]

e_edit :: Key -> Field -> (Field -> Field) -> Event -> Event

Value editor for Key at Event, with default value in case Key is not present.

e_edit' :: Key -> (Field -> Field) -> Event -> Event

Variant of edit_v with no default value.

Event temporal

e_merge' :: (Time, [Event]) -> (Time, [Event]) -> [(Time, Event)]

Merge two time-stamped Event sequences. Note that this uses fwd to calculate start times.

e_add_fwd :: [(Time, Event)] -> [Event]

Insert fwd Keys into a time-stamped Event sequence.

e_merge :: (Time, [Event]) -> (Time, [Event]) -> [Event]

Composition of add_fwd and merge'.

e_par :: [(Time, [Event])] -> [Event]

N-ary variant of e_merge.

e_par [(0,repeat (e_from_list [(K_id,1)]))
      ,(0,repeat (e_from_list [(K_param "b",2)]))
      ,(0,repeat (e_from_list [(K_param "c",3)]))]

e_rest :: Event

mempty with rest.

e_is_rest :: Event -> Bool

Does Event have a True rest key.

e_is_rest mempty == False
e_is_rest (e_from_list [(K_rest,1)]) == True

MCE

e_mce_depth :: Event -> Maybe Int

Maximum vector length at Event.

e_mce_depth (e_from_list [(K_id,1)]) == Nothing
e_mce_depth (e_from_list [(K_id,1),(K_param "b",f_array [2,3])]) == Just 2

e_mce_extend :: Event -> Maybe (Int, Event)

Extend vectors at Event if required, returning e_mce_depth.

let {e = e_from_list [(K_id,f_array [1,2]),(K_param "b",f_array [2,3,4])]
    ;r = e_from_list [(K_id,f_array [1,2,1]),(K_param "b",f_array [2,3,4])]}
in e_mce_extend e == Just (3,r)

let e = e_from_list [(K_id,1)]
in e_mce_extend e == Nothing

e_mce_expand :: Event -> Event

e_mce_extend variant.

e_un_mce :: Event -> Maybe [Event]

Parallel Events, if required.

let {e = e_from_list [(K_id,1),(K_param "b",f_array [2,3])]
    ;r = [e_from_list [(K_id,1),(K_param "b",2)],e_from_list [(K_id,1),(K_param "b",3)]]}
in e_un_mce e == Just r

let {e = e_from_list [(K_id,f_array [1,2]),(K_param "b",f_array [3,4,5])]
    ;r = e_from_list [(K_id,1),(K_param "b",5)]}
in fmap (!! 2) (e_un_mce e) == Just r

e_un_mce (e_from_list [(K_id,1)]) == Nothing

e_un_mce' :: Event -> [Event]

e_un_mce variant.

SC3

e_messages :: Dur -> Event -> Int -> Maybe Int -> Maybe (T2 [Message])

Generate SC3 (on,off) Message sets describing Event.

e_messages_mce :: Dur -> Event -> Int -> (Maybe (T2 [Message]), Int)

MCE variant of e_messages.

e_bundles :: Time -> Int -> Dur -> Event -> (Maybe (T2 Bundle), Int)

Generate SC3 (on,off) Bundles describing Event.

newtype Event_Seq

Ordered sequence of Event.

Constructors

Event_Seq

Fields

e_seq_events :: [Event]

Instances

Audible Event_Seq

e_bundle_seq :: Time -> Event_Seq -> [T2 Bundle]

Transform Event_Seq into a sequence of SC3 (on,off) Bundles.

e_bundle_seq 0 (Event_Seq (replicate 5 mempty))

e_nrt :: Event_Seq -> NRT

Transform (productively) an Event_Seq into an NRT score.

let {n1 = nrt_bundles (e_nrt (Event_Seq (replicate 5 mempty)))
    ;n2 = take 11 (nrt_bundles (e_nrt (Event_Seq (repeat mempty))))}
in n1 == n2

e_play :: Transport m => Event_Seq -> m ()

Audition Event_Seq.

Aliases

e_empty :: Event

Type-specialised mempty.

e_union :: Event -> Event -> Event

Type-specialised mappend.

let {l = [(K_id,0)];r = [(K_degree,1)]}
in e_from_list l <> e_from_list r == e_from_list (l <> r)

Temporal

t_merge :: Ord t => [(t, a)] -> [(t, a)] -> [(t, a)]

Left-biased merge of two sorted sequence of temporal values.

let m = t_merge (zip [0,2,4,6] ['a'..]) (zip [0,3,6] ['A'..])
in m == [(0,'a'),(0,'A'),(2,'b'),(3,'B'),(4,'c'),(6,'d'),(6,'C')]

Tuple

type T2 n = (n, n)

Two tuple of n.

type T3 n = (n, n, n)

Three tuple of n.

List

mcons :: Maybe a -> [a] -> [a]

Maybe variant of :.