Temporal.Media.Double

Special case of Temporal.Media. Time is Double

Time classes

type Dur = Double

none :: Temporal Dur a => Dur -> a

dur :: Temporal Dur a => a -> Dur

stretch :: Stretchable Dur a => Dur -> a -> a

class ToMaybe m where

Values covertible to Maybe

auxiliary class for conversion to EventList

Methods

toMaybe :: m a -> Maybe a

Instances

Dur t => ToMaybe (Unit t)

tmap :: TemporalFunctor Dur f => (Time -> a -> b) -> f a -> f b

dmap :: TemporalFunctor Dur f => (Dur -> a -> b) -> f a -> f b

tdmap :: TemporalFunctor Dur f => (Time -> Dur -> a -> b) -> f a -> f b

sustain :: Sustainable Dur f => Dur -> f a -> f a

sustainBy :: Sustainable Dur f => (Dur -> Dur -> a -> (b, Dur)) -> f a -> f b

tstretch :: TemporalStretchable Dur a => (Time -> Dur) -> a -> a

temporal stretch

Transformers

class Reversible a where

Methods

reverse :: a -> a

Instances

Dur t => Reversible (Unit t a)

Reversible a => Reversible (Media c a)

Dur t => Reversible (MediaUnit t c a)

slice :: Sliceable Dur a => Dur -> Dur -> a -> a

take :: Sliceable Dur a => Dur -> a -> a

drop :: Sliceable Dur a => Dur -> a -> a

cut :: (Reversible a, Sliceable Dur a) => Dur -> Dur -> a -> a

Structure

class Construct m where

constructor for generic structures

Methods

prim :: a -> m a

Instances

Dur t => Construct (Unit t)

Dur t => Construct (EventList t)

Construct (Media c)

Dur t => Construct (MediaUnit t c)

class Arrangeable a where

composing structures in sequent and parallel ways

Methods

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

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

Instances

Dur t => Arrangeable (EventList t a)

Arrangeable (Media c a)

Dur t => Arrangeable (MediaUnit t c a)

class Controlable c a where

modifer

Methods

control :: c -> a -> a

Instances

Dur t => Controlable () (EventList t a)

Controlable c (Media c a)

Dur t => Controlable c (MediaUnit t c a)

sequent :: Arrangeable a => [a] -> a

parallel :: Arrangeable a => [a] -> a

loop :: Arrangeable a => Int -> a -> a

delay :: (Temporal Dur a, Arrangeable a) => Dur -> a -> a

temp :: (Construct m, Temporal Dur (m a), Stretchable Dur (m a)) => Dur -> a -> m a

Media

data Media c a

Data type to represent temporal media

Constructors

Prim a

single value

(Media c a) :+: (Media c a)

sequential composition

(Media c a) :=: (Media c a)

parallel composition

Control c (Media c a)

specific environment modifier

Instances

Controlable c (Media c a)

Sliceable t a => Sliceable t (Media c a)

Stretchable t a => TemporalStretchable t (Media c a)

Stretchable t a => Stretchable t (Media c a)

Temporal t a => Temporal t (Media c a)

Monad (Media c)

Functor (Media c)

Applicative (Media c)

Construct (Media c)

(Eq c, Eq a) => Eq (Media c a)

(Show c, Show a) => Show (Media c a)

Arrangeable (Media c a)

Reversible a => Reversible (Media c a)

fold :: (a -> b) -> (b -> b -> b) -> (b -> b -> b) -> (c -> b -> b) -> Media c a -> b

Folding Media

 fold prim seq par mod x

• prim - responds to Prim
• seq - responds to :+:
• par - responds to :=:
• mod - responds to Control

fromMedia :: Arrangeable b => (a -> b) -> (c -> b -> b) -> Media c a -> b

Media interpretation

given two functions (to convert elementary value (a -> b), and to convert modifiers (c -> b -> b)) fromMedia interprets Media structure

Simple interperetation

Event list

type Event a = Event Dur a

type EventList a = EventList Dur a

mapEvent :: (a -> b) -> Event a -> Event b

toEvent :: (Temporal Dur (m a), ToMaybe m) => m a -> EventList a

toEventList :: (Temporal Dur (m a), ToMaybe m) => (c -> EventList a -> EventList a) -> Media c (m a) -> EventList a

Unit Media

type MediaUnit c a = MediaUnit Dur c a

unMediaUnit :: MediaUnit c a -> Media c (Unit a)

foldU :: (Dur -> a -> b) -> (b -> b -> b) -> (b -> b -> b) -> (c -> b -> b) -> MediaUnit c a -> Maybe b

fromMediaUnit :: (c -> EventList a -> EventList a) -> MediaUnit c a -> EventList a

type Unit a = Unit Dur a

Misc

tmapRel :: (Temporal Dur (f a), TemporalFunctor Dur f) => (Time -> a -> b) -> f a -> f b

dmapRel :: (Temporal Dur (f a), TemporalFunctor Dur f) => (Dur -> a -> b) -> f a -> f b

tdmapRel :: (Temporal Dur (f a), TemporalFunctor Dur f) => (Time -> Dur -> a -> b) -> f a -> f b

tstretchRel :: TemporalStretchable Dur a => (Time -> Dur) -> a -> a

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

linear interpolation

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

a, b, c ... - values

da, db, ... - duration of segments