ASL2

[trentgill]

A Slope Language v2

ASL is rebuilt to execute in C, allowing for audiorate cycles - specifically oscillation up to nyquist freq (24kHz).

The API has some breaking changes, but is generally the same as V1.

-- globals (same as prior)
to(voltage, time, shape)
loop(...)
held(...)
lock(...)
times(n, ...)

-- globals. newly added
dyn{k=v}
mutable(n)
mutable{k=v}

-- notable ASL namespace functions
asl._if(predicate, ...)
asl._while(predicate, ...)

Asllib is also updated but functionality is unchanged (The code is dramatically simplified though).

n2v, negate and clamp are removed (as they can be replaced with native math operations, or asl constructs. This may break some rare scripts (notably n2v was used frequently in non-asl code. It can be replaced with a divide-by-12).

output[n].done event callback is no longer available
is_running = output[n].running query is no longer available

---

dyn, short for Dynamic, is useful for naming ASL arguments so that they can be updated by a script, without restarting the ASL.

-- create an lfo with a dynamic height, starting at 3V
output[1]( loop{ to( dyn{height=3}, 1)
               , to( 0, 1)
               }
)

output[1].dyn.height = 1 -- update height of LFO to 1V
-- note: this will take effect at the next repetition

Dynamic vars can be used anywhere in the ASL, either in a to() call, or as a predicate value (eg. asl._if).

Additionally, all asllib functions may take dyn values as variables. Eg:

-- an lfo whose speed can be changed at runtime
output[2]( lfo( dyn{speed=0.1} ) )

---

Mutable values are typically literal values that can have a mutation applied at each usage.

Stepping back, both dyn and mutable values can have arithmetic applied to them. This is written as if the wrapped values were simple literals, eg dyn{num=3} * 11 - 2. The result will be computed at runtime, such that as the dyn is updated, the result will change as well.

Available operations are + - * / % where % is floating point 'wrap' from zero to the 2nd operand. - may be used as unary negation, or subtraction.

Returning to mutable values, these values will be updated by any arithmetic operations at each usage of the value. This can be used for simple iterators (the times construct is implemented with a mutable), or more complex things like animated waveforms. There is much space to explore with this feature.

Mutable values may be named or anonymous. Anonymous are as discussed above, eg: asl._if( mutable(10)-1, ...). Named mutables add named access like Dynamic vars:

-- lfo where the frequency increases cyclically
output[3]( lfo( (mutable{time=1}-0.01) % 1 + 0.01 ) )

output[3].mutable.time = 0.2 -- jump to a faster FM

---

Notably, ASL can no longer call arbitrary lua functions. The only 'verb' function is to(), meaning the sole purpose of ASL is for controlling voltage slopes. This will break some older scripts, but I would suggest they'd be far more cleanly articulated as a clock routine. Unfortunately there's no way to provide this feature now that the runtime is entirely in C.

More commentary soon!

Fixes #301

[tehn]

dang look at all of those commits!

dyn is fantastic, great design. looking forward to more documentation and examples generally.

(aha just found extra docs in casl.lua)

my feeling is that you should just merge this and we can/should test everything in parallel since THREE is basically a dev branch.