class `Op`

Persistent expression Operator.

index

Op(out, state) – if type is passed, an output stream is instantiated.
op:setup(inputs) – setup previous inputs, if any, with the new inputs, and write them to inputs.
op:unwrap_all() – \unwrap all Inputs in @inputs and return a table with the same shape.

op:all_inputs() – yield all Inputs from the (potentially nested) inputs table
returns:
1. (iterator): iterator over inputs
op:fork() – create a mutable copy of this Op.
Used to wrap insulate eval-cycles from each other. The copy does not have inputs set, since it is expected that this is (re)set in setup.
returns:
1. (Op)
op.state – internal state of this Op.
This may be any simple Lua value, including Lua tables, as long as it has no metatables, multiple references/loops, userdata etc.
- state (table)
op.out – Stream instance representing this Op’s computed output value.
Must be set to a Stream instance once setup finishes. Must not change type, be removed or replaced outside of new and setup. If it is a ValueStream, it should have a value assigned via set or the constructor once tick is called the first time. If out’s value is not initialized in new or setup, the implementation must make sure tick(true) is called at least on the first eval-cycle the Op goes through, e.g. by using an Input.hot with a ValueStream.
- out (Stream)
op.inputs – table containing Inputs to this Op.
The inputs table can be nested with string or integer keys, but all leaf-entries must be Input instances. It must not contain loops or instances of other classes.
- inputs ({Input,...})

Op(out, state) – construct a new instance.
The optional parameters out and state are used by fork to duplicate an instance. If the constructor is overriden, these parameters must be forwarded to the superconstructor unchanged.
parameters:
- out (optional Stream): out
- state (optional table): state
op:setup(inputs, scope) – parse arguments and patch self.
Called once every eval-cycle. inputs is a list of Results that are the argument to this op. The inputs have to be wrapped in Input instances to define update behaviour. Use base.match to parse them, then delegate to super:setup to patch the Input instances.
parameters:
- inputs ({Result,...}): a sequence of Results
- scope (Scope): the active scope
op:tick(setup) – handle incoming events and update out (optional).
Called once per frame if any Inputs are dirty. Some Inputs may have special behaviour immediately after setup that can cause them to become dirty at eval-time. In this case, an eval-time tick is executed. You can detect this using the setup parameter.

tick is called after setup. tick is not called immediately after setup if no inputs are dirty. Update out here.
parameters:
- setup (bool): whether this is an eval-time tick
op:destroy() – called when the Op is destroyed (optional).

Op(out, state) – if type is passed, an output stream is instantiated.
if init is passed, the stream is initialized to that Lua value. it is okay not to use this and create the output stream in :setup() if the type is not known at this time.
parameters:
- out (optional Stream): out
- state (optional table): state
op:setup(inputs) – setup previous inputs, if any, with the new inputs, and write them to inputs.
The inputs table can be nested with string or integer keys, but all leaf-entries must be Input instances. It must not contain loops or instances of other classes.
parameters:
- inputs (table): table of Inputs
op:unwrap_all() – \unwrap all Inputs in @inputs and return a table with the same shape.
returns:
1. (table): the values of all Inputs