Safe Haskell	Safe-Inferred

Derive.Score

Contents

Event

Description

This has Score.Event, which is the main output of the deriver.

The events here are generated from UI Events, and will eventually be transformed into Perform Events, which are specific to the performance backend.

Synopsis

data Event = Event {
- event_start :: !RealTime
- event_duration :: !RealTime
- event_text :: !Text
- event_integrate :: !Text
- event_pitch :: !DeriveT.PSignal
- event_stack :: !Stack.Stack
- event_highlight :: !Color.Highlight
- event_instrument :: !ScoreT.Instrument
- event_environ :: !DeriveT.Environ
- event_flags :: !Flags.Flags
- event_delayed_args :: !(Map Text Dynamic.Dynamic)
- event_logs :: ![Log.Msg]
}
short_event :: Event -> Text
short_events :: [Event] -> Text
empty_event :: Event
event_end :: Event -> RealTime
event_min :: Event -> RealTime
event_max :: Event -> RealTime
events_overlap :: Event -> Event -> Bool
event_scale_id :: Event -> Pitch.ScaleId
copy :: Event -> Event
normalize :: Event -> Event
has_flags :: Flags.Flags -> Event -> Bool
add_flags :: Flags.Flags -> Event -> Event
remove_flags :: Flags.Flags -> Event -> Event
add_log :: CallStack.Stack => Text -> Event -> Event
add_log_msg :: Log.Msg -> Event -> Event
modify_environ :: (DeriveT.Environ -> DeriveT.Environ) -> Event -> Event
modify_val :: EnvKey.Key -> (Maybe DeriveT.Val -> DeriveT.Val) -> Event -> Event
event_attributes :: Event -> Attrs.Attributes
has_attribute :: Attrs.Attributes -> Event -> Bool
intersecting_attributes :: Attrs.Attributes -> Event -> Bool
modify_attributes :: (Attrs.Attributes -> Attrs.Attributes) -> Event -> Event
add_attributes :: Attrs.Attributes -> Event -> Event
remove_attributes :: Attrs.Attributes -> Event -> Event
put_arg :: Typeable.Typeable a => Text -> a -> Event -> Event
take_arg :: Typeable.Typeable a => Text -> Event -> Either Text (Event, Maybe a)
move :: (RealTime -> RealTime) -> Event -> Event
place :: RealTime -> RealTime -> Event -> Event
move_start :: RealTime -> RealTime -> Event -> Event
duration :: (RealTime -> RealTime) -> Event -> Event
set_duration :: RealTime -> Event -> Event
set_instrument :: ScoreT.Instrument -> DeriveT.Environ -> Event -> Event
event_controls :: Event -> ScoreT.ControlMap
control_at :: RealTime -> ScoreT.Control -> Event -> Maybe (ScoreT.Typed Signal.Y)
event_control :: ScoreT.Control -> Event -> Maybe (ScoreT.Typed Signal.Control)
initial_dynamic :: Event -> Signal.Y
modify_dynamic :: (Signal.Y -> Signal.Y) -> Event -> Event
set_dynamic :: Signal.Y -> Event -> Event
modify_control_vals :: ScoreT.Control -> (Signal.Y -> Signal.Y) -> Event -> Event
modify_control :: ScoreT.Control -> (Maybe ScoreT.TypedSignal -> ScoreT.TypedSignal) -> Event -> Event
modify_signal :: ScoreT.Control -> (Signal.Control -> Signal.Control) -> Event -> Event
set_control :: ScoreT.Control -> ScoreT.Typed Signal.Control -> Event -> Event
event_controls_at :: RealTime -> Event -> ScoreT.ControlValMap
set_pitch :: DeriveT.PSignal -> Event -> Event
set_named_pitch :: ScoreT.PControl -> DeriveT.PSignal -> Event -> Event
event_named_pitch :: ScoreT.PControl -> Event -> Maybe DeriveT.PSignal
transposed_at :: RealTime -> Event -> Maybe DeriveT.Transposed
pitch_at :: RealTime -> Event -> Maybe DeriveT.Pitch
apply_controls :: Event -> RealTime -> DeriveT.Pitch -> DeriveT.Transposed
initial_pitch :: Event -> Maybe DeriveT.Transposed
nn_at :: RealTime -> Event -> Maybe Pitch.NoteNumber
initial_nn :: Event -> Maybe Pitch.NoteNumber
note_at :: RealTime -> Event -> Maybe Pitch.Note
initial_note :: Event -> Maybe Pitch.Note
nn_signal :: Event -> (Signal.NoteNumber, [(RealTime, Text)])

Event

data Event Source #

Constructors

Event

Fields

event_start :: !RealTime
event_duration :: !RealTime
event_text :: !Text
This is the text of the call that created the event. It's basically just for debugging.
event_integrate :: !Text
If the event is integrated back to a Ui.Event, use this text. This is so calls can explicitly set how they would like their events to be integrated. Otherwise, Integrate.Convert will try to infer something.
event_pitch :: !DeriveT.PSignal
event_stack :: !Stack.Stack
Keep track of where this event originally came from. That way, if an error or warning is emitted concerning this event, its position on the UI can be highlighted.
event_highlight :: !Color.Highlight
event_instrument :: !ScoreT.Instrument
event_environ :: !DeriveT.Environ
event_flags :: !Flags.Flags
Flags have their own field rather than being in event_environ, this emphasizes that they're meant to be used by calls and not from the score.
event_delayed_args :: !(Map Text Dynamic.Dynamic)
This has arguments passed from a call that applies an attribute to one which is meant to later realize the attribute. This happens when a call needs to be configured at the track level, but also needs some information only available later, such as the real start time or pitch of the next note. They are indexed by attribute because there may be multiple delayed calls on a single note, and the realize postproc may want to ignore some, e.g. if they are overidden by another attribute.
I couldn't think of a type safe way to do this, but Dynamic should be safe enough if you use a shared type declaration in both writer and reader.
event_logs :: ![Log.Msg]
Keep track of interesting things that have happened to this event. Postproc transforms that alter it should prefix a note.

Instances

Instances details

Monoid NoteDeriver Source #
Instance details Defined in Derive.Deriver.Monad Methods mempty :: NoteDeriver # mappend :: NoteDeriver -> NoteDeriver -> NoteDeriver # mconcat :: [NoteDeriver] -> NoteDeriver #
Semigroup NoteDeriver Source #
Instance details Defined in Derive.Deriver.Monad Methods (<>) :: NoteDeriver -> NoteDeriver -> NoteDeriver # sconcat :: NonEmpty NoteDeriver -> NoteDeriver # stimes :: Integral b => b -> NoteDeriver -> NoteDeriver #
Show Builtins Source #
Instance details Defined in Derive.Deriver.Monad Methods showsPrec :: Int -> Builtins -> ShowS # show :: Builtins -> String # showList :: [Builtins] -> ShowS #
Show InstrumentCalls Source #
Instance details Defined in Derive.Deriver.Monad Methods showsPrec :: Int -> InstrumentCalls -> ShowS # show :: InstrumentCalls -> String # showList :: [InstrumentCalls] -> ShowS #
Show Library Source #
Instance details Defined in Derive.Library Methods showsPrec :: Int -> Library -> ShowS # show :: Library -> String # showList :: [Library] -> ShowS #
Show Event Source #
Instance details Defined in Derive.Score Methods showsPrec :: Int -> Event -> ShowS # show :: Event -> String # showList :: [Event] -> ShowS #
DeepSeq.NFData Event Source #
Instance details Defined in Derive.Score Methods rnf :: Event -> () #
Cacheable Event Source #
Instance details Defined in Derive.Cache Methods from_cache_entry :: CacheEntry -> Maybe (CallType Event) Source # to_cache_entry :: CallType Event -> CacheEntry Source #
Taggable Note Source #
Instance details Defined in Derive.Deriver.Monad Methods to_tagged :: Note -> Tagged Source # from_tagged :: Tagged -> Maybe Note Source #
ShowVal NoteDeriver Source #	This is an invalid instance, because a deriver has no literal syntax. But this lets me put a deriver in a defaulted argument, and get documentation for it.
Instance details Defined in Derive.Deriver.Monad Methods show_val :: NoteDeriver -> Text Source #
Typecheck NoteDeriver Source #
Instance details Defined in Derive.Sig Methods from_val :: DeriveT.Val -> Checked NoteDeriver Source # to_type :: Proxy NoteDeriver -> Type Source # from_subtrack :: Track -> Maybe NoteDeriver Source #
Pretty.Pretty Event Source #
Instance details Defined in Derive.Score Methods pretty :: Event -> Text Source # format :: Event -> Doc Source # formatList :: [Event] -> Doc Source #
Monoid (Stream Event) Source #
Instance details Defined in Derive.Stream Methods mempty :: Stream Event # mappend :: Stream Event -> Stream Event -> Stream Event # mconcat :: [Stream Event] -> Stream Event #
Semigroup (Stream Event) Source #
Instance details Defined in Derive.Stream Methods (<>) :: Stream Event -> Stream Event -> Stream Event # sconcat :: NonEmpty (Stream Event) -> Stream Event # stimes :: Integral b => b -> Stream Event -> Stream Event #
Callable (Generator Note) Source #
Instance details Defined in Derive.Deriver.Monad Methods get_builtins_scope :: Builtins -> ModuleMap (Generator Note) get_scopes_scope :: Scopes -> ScopePriority (Generator Note) callable_name :: Proxy (Generator Note) -> Text Source #
Callable (TrackCall Note) Source #
Instance details Defined in Derive.Deriver.Monad Methods get_builtins_scope :: Builtins -> ModuleMap (TrackCall Note) get_scopes_scope :: Scopes -> ScopePriority (TrackCall Note) callable_name :: Proxy (TrackCall Note) -> Text Source #
Callable (Transformer Note) Source #
Instance details Defined in Derive.Deriver.Monad Methods get_builtins_scope :: Builtins -> ModuleMap (Transformer Note) get_scopes_scope :: Scopes -> ScopePriority (Transformer Note) callable_name :: Proxy (Transformer Note) -> Text Source #
ToLibrary (Generator Note) Source #
Instance details Defined in Derive.Library Methods to_library :: [Entry (Generator Note)] -> Library -> Library
ToLibrary (TrackCall Note) Source #
Instance details Defined in Derive.Library Methods to_library :: [Entry (TrackCall Note)] -> Library -> Library
ToLibrary (Transformer Note) Source #
Instance details Defined in Derive.Library Methods to_library :: [Entry (Transformer Note)] -> Library -> Library

short_event :: Event -> Text Source #

Format an event in a way suitable for including inline in log messages. It's short, but hopefully enough information to identify the event in question.

This is the derive equivalent to log_event.

short_events :: [Event] -> Text Source #

empty_event :: Event Source #

event_end :: Event -> RealTime Source #

event_min :: Event -> RealTime Source #

Get minimum and maximum edges of the event. event_start isn't necessarily the minimum because of negative durations.

event_max :: Event -> RealTime Source #

Get minimum and maximum edges of the event. event_start isn't necessarily the minimum because of negative durations.

events_overlap :: Event -> Event -> Bool Source #

event_scale_id :: Event -> Pitch.ScaleId Source #

copy :: Event -> Event Source #

If you use an event to create another event, call this to clear out data that shouldn't go with the copy.

normalize :: Event -> Event Source #

Apply environ and controls to pitches.

Normally this is done by Convert, but if you want to see an event for debugging it can be nicer to see the normalized version.

Unlike Perform.Midi.Convert, this doesn't trim the controls, so it applies out-of-range transpositions.

flags

has_flags :: Flags.Flags -> Event -> Bool Source #

add_flags :: Flags.Flags -> Event -> Event Source #

remove_flags :: Flags.Flags -> Event -> Event Source #

logs

add_log :: CallStack.Stack => Text -> Event -> Event Source #

add_log_msg :: Log.Msg -> Event -> Event Source #

environ

modify_environ :: (DeriveT.Environ -> DeriveT.Environ) -> Event -> Event Source #

modify_val :: EnvKey.Key -> (Maybe DeriveT.Val -> DeriveT.Val) -> Event -> Event Source #

Modify the value at the given key.

attributes

event_attributes :: Event -> Attrs.Attributes Source #

has_attribute :: Attrs.Attributes -> Event -> Bool Source #

intersecting_attributes :: Attrs.Attributes -> Event -> Bool Source #

modify_attributes :: (Attrs.Attributes -> Attrs.Attributes) -> Event -> Event Source #

add_attributes :: Attrs.Attributes -> Event -> Event Source #

remove_attributes :: Attrs.Attributes -> Event -> Event Source #

delayed args

put_arg :: Typeable.Typeable a => Text -> a -> Event -> Event Source #

take_arg :: Typeable.Typeable a => Text -> Event -> Either Text (Event, Maybe a) Source #

Find an arg in event_delayed_args, and remove it from the event if it existed. Throw an error if it existed but had an unexpected type.

modify events

move :: (RealTime -> RealTime) -> Event -> Event Source #

Change the start time of an event and move its controls along with it.

place :: RealTime -> RealTime -> Event -> Event Source #

move_start :: RealTime -> RealTime -> Event -> Event Source #

duration :: (RealTime -> RealTime) -> Event -> Event Source #

set_duration :: RealTime -> Event -> Event Source #

set_instrument :: ScoreT.Instrument -> DeriveT.Environ -> Event -> Event Source #

Set the instrument on an event, and also update its environ from the instrument. You should really rederive with the new instrument, but this way can be more convenient, if somewhat sketchy.

control

event_controls :: Event -> ScoreT.ControlMap Source #

control_at :: RealTime -> ScoreT.Control -> Event -> Maybe (ScoreT.Typed Signal.Y) Source #

Get a control value from the event, or Nothing if that control isn't present.

event_control :: ScoreT.Control -> Event -> Maybe (ScoreT.Typed Signal.Control) Source #

initial_dynamic :: Event -> Signal.Y Source #

modify_dynamic :: (Signal.Y -> Signal.Y) -> Event -> Event Source #

Use this instead of modify_control_vals because it also sets EnvKey.dynamic_val. This is only valid for linear functions like (+) or (*).

set_dynamic :: Signal.Y -> Event -> Event Source #

Use this instead of set_control because it also sets EnvKey.dynamic_val.

modify_control_vals :: ScoreT.Control -> (Signal.Y -> Signal.Y) -> Event -> Event Source #

modify_control :: ScoreT.Control -> (Maybe ScoreT.TypedSignal -> ScoreT.TypedSignal) -> Event -> Event Source #

modify_signal :: ScoreT.Control -> (Signal.Control -> Signal.Control) -> Event -> Event Source #

Like modify_control, but default to an empty control and retain any type the original had.

set_control :: ScoreT.Control -> ScoreT.Typed Signal.Control -> Event -> Event Source #

event_controls_at :: RealTime -> Event -> ScoreT.ControlValMap Source #

pitch

set_pitch :: DeriveT.PSignal -> Event -> Event Source #

set_named_pitch :: ScoreT.PControl -> DeriveT.PSignal -> Event -> Event Source #

event_named_pitch :: ScoreT.PControl -> Event -> Maybe DeriveT.PSignal Source #

transposed_at :: RealTime -> Event -> Maybe DeriveT.Transposed Source #

Unlike pitch_at, the transposition has already been applied. This is because callers expect to get the actual pitch, not the pitch plus some homework to do on the pitch. If you use this pitch to emit another pitch you proabbly need the raw pitch, but so far everyone doing that is at the Derive level, not postproc, so they use Derive.pitch_at.

pitch_at :: RealTime -> Event -> Maybe DeriveT.Pitch Source #

apply_controls :: Event -> RealTime -> DeriveT.Pitch -> DeriveT.Transposed Source #

initial_pitch :: Event -> Maybe DeriveT.Transposed Source #

nn_at :: RealTime -> Event -> Maybe Pitch.NoteNumber Source #

initial_nn :: Event -> Maybe Pitch.NoteNumber Source #

note_at :: RealTime -> Event -> Maybe Pitch.Note Source #

initial_note :: Event -> Maybe Pitch.Note Source #

nn_signal :: Event -> (Signal.NoteNumber, [(RealTime, Text)]) Source #