Package up the results of a derivation.

Kick off a derivation.

If the deriver throws, log the error and return Nothing.

Merge calls from the given module into scope.

Import only the given symbols from the module.

Run the derivation with a modified scope.

Lookup a scale_id or throw.

Like lookup_val, but throw if the value isn't present.

Set the given val dynamically within the given computation. This is analogous to a dynamic let.

Remove on VNotGiven, which is what any Nothing will become. There's no use for a VNotGiven in the environ. The main way this is used is the val=_ c_equal syntax.

There is intentionally no way to modify the environment via assignment. It would introduce an order of execution dependency that would complicate caching as well as have a confusing non-local effect.

This dispatches to with_scale or with_instrument if it's setting the scale or instrument, so scale or instrument scopes are always set when scale and instrument are.

Like with_val, but should be slightly more efficient for setting multiple values at once.

Merge the given environ into the environ in effect. Unlike with_val or with_vals, this won't set scopes for EnvKey.scale and EnvKey.instrument.

Like with_val, but don't set scopes for instrument and scale. Also don't check for types, so you can replace a val with one of a different type. Due to this it's also more efficient.

Replace the scale's calls.

Previously this used add_priority instead of replace_priority, which meant you could overlay scales and use both at the same time. Maybe that's actually a useful feature? In any case, I don't need it at the moment, so it seems more likely to be confusing than useful.

Run the a deriver with the given instrument in scope. In addition to assigning the instrument to the EnvKey.instrument field where note calls can inherit it, this also brings the Instrument fields into scope, which is the per-instrument calls and per-instrument environ.

Look up the instrument. Also return the instrument name after resolving any alias. This is what goes in Score.event_instrument, since it's what the performer understands.

Like get_function, but get them all.

Get the control value at the given time.

Get a ControlValMap at the given time.

Modify all VSignal and VPSignal types in environ.

Remove both controls and control functions. Use this when a control has already been applied, and you don't want it to affect further derivation.

Modify the given control according to the Merger.

If both signals are typed, the existing type wins over the relative signal's type. If one is untyped, the typed one wins.

As documented in merge, this acts like a Set if there is no existing control.

Like with_controls, but merge them with their respective default Mergers.

Get the default merger for this control, or merge_mul if there is none.

Emit a ControlMod.

Apply the collected control mods to the given deriver and clear them out.

The pitch at the given time. The transposition controls have not been applied since that is supposed to be done once only when the event is generated.

The scenario is a call that generates a note based on the current pitch. If pitch_at applied the transposition, the new note would have to remove the transposition signals so they don't get applied again at performance conversion.

Like pitch_at, this is a raw pitch.

Resolve the raw pitch returned from pitch_at to the final transposed pitch.

Unlike pitch_at, the transposition has already been applied, because you can't transpose any further once you have a NoteNumber.

Re-export Typecheck.lookup_pitch_signal, defined there to avoid circular import.

Version of DeriveT.pitch_nn that logs errors.

Embed a LogId into Deriver. This is for computations that need logging but not a full Deriver.

Get the CallDuration of the given deriver.

A combination of catch and with_event_stack.

Replace the state_stack with the one from the event. This is useful for transformers, so they can show a stack trace to the event they are processing.

Shift the controls of a deriver. You're supposed to apply the warp before deriving the controls, but I don't have a good solution for how to do this yet, so I can leave these here for the moment.

Wrap make_val_call with a Typecheck.to_val to automatically convert to a DeriveT.Val. This is not in Derive.Deriver.Monad to avoid a circular import with Derive.DeriveT.