lidl

# Base interactions Some interactions are built in right into the language itself, they will be used to implement all the other features, using libraries. ## Literals Any literal of all base type is a built in interaction. ### Activation These comply to the interface `activation out` `(active)` and `(inactive)` ### Boolean These comply to the interface `boolean out` `(true)`, `(false)`, and `(inactive)` ### Number These comply to the interface `number out` `(0)`, `(1)`, `(2)`, ... , `(infinity)`,`(-infinity)`,...,`(-1)`,`(3.14159)`,`(12e3)`,`(6.626e-34)`,`(pi)`,`(e)`, and of course, `(inactive)` ### Text These comply to the interface `text out` `("")`,`("A text")`,`("A multi-line\ntext")`,`("Anything between double quotes")`, and of course, `(inactive)` ### Function These comply to the interface ` <domain> -> <codomain> out` They are basically any piece of native code between backticks. So far domain and codomain must be tuple types. The code must use function arguments called arg0, arg1, ..., and return result called res0, res1, ... ``` (` var temp = in.0 * in.0 + in.1 * in.1; out = math.sqrt(temp); `) ``` ## Composition Interactions that compose or decompose data into smaller bits, using compound types. ### Records This one for example complies to the interface `{x:number,y:number} out` `({x:(1),y:(2)})` `((a).x)` ## Identification Identification interactions are the **only** interactions that break referential transparency. They are useful mostly to keep referential transparency simple in the language. The question whether a specific interaction is referentially transparent is hence easy to answer: if it has one of these functions in it, then it is not, otherwise, it is. ### Time step `(time step identifier):number out` is a number which is different on every time step, but has the same value in every interaction at the same time. It is not necessarily a counter, but it is unique, two time steps cannot have two similar time step identifiers... at least, normally... If we take 64 bits integer sequentially, then we can step at 1 GHz for 584 years, so that should be okay... It is useful to keep referential transparency, while using random numbers for example. ### Class `(class identifier):number out` is a number which is constant in time, but different every time it appears in the **folded** source code, i.e. the code as written by the coder. It could be generated by a simple find/replace in a text editor. ### Instance `(instance identifier):number out` is a number which is constant in time, but different every time it appears in the **unfolded** source code, i.e. once the whole code is inlined in one massive composition of basic interactions during the compilation process. ### Intermediates between Class and instance Class identifier is **before all** unfolding, while Instance identifier is **after all** unfolding. It should be good to add a notion of unfolding step, and add an identifier for when this is unfolded... ## The most useful stuff ### Previous The only way to make a piece of data travel between two different time steps. `(previous(x:<type> in)) : <type> out` Example of use : `((x)=(previous(x)))` will have the effect that `x` will always be the same. ### Function application Is equivalent to its `result` argument, and at the same time, evaluate a given `function` on a given `element` and put the result in `image`. ``` ( (result:<interface>) in (function:<domain> -> <codomain> in) applied to (element:<domain> in) returns (image:<codomain> out) ): co-<interface> ``` Example of use : ``` interaction (Square root of (a:number in) plus (b:number in)):number out is ( (res) in (f) applied to ({a:(a)b:(b)}) returns (res) ) with interaction (res):number ref interaction (f):{a:number,b:number} -> number out is ( js ` out = Math.sqrt(in.a + in.b); ` c ` out = sqrt(in->a + in->b); ` ) ``` ### Local `(local of (a))` Block the scoping mecanism. This is to define a local variable, it can be a in or a out. Assign a value or get a value from an identifier, but do not execute its content. # Non base interactions ## Behaviors ### Behavior Is equivalent to its first argument, while always activating its second argument. `((a:<interface>)with behavior(b:activation out)):co-<interface>` Example of use: `((x)with behavior((x)=(5)))` is equivalent to `(5)` ### All ``` interaction (all (a:<type> out) (b:<type> out)):<type> in is ((x) in (`out.a=in;out.b=in;`) applied to (x) returns ({a:(a),b:(b)})) with interaction (x):<type> ref ``` ### Affectation Simple affectation ``` interaction ((a:<type> out)=(b:<type> in)):activation in is ((x) in (`out = (in.x.active === true)?in.b:{active:false,value:0}`) applied to ({x:(x),b:(b)}) returns (a)) with interaction (x):<type> ref ``` Example of use: `((x)=(3))` means that x will get 3. ### When ``` interaction (when (cond:activation in) then (effect:activation out)):activation in is ((x) in (`out.active = in.x.active && in.y.active;`)applied to ({x:(x),y:(cond)}) returns (effect)) with interaction (x) : activation ref ``` ### Reception This is the result of a templating macro ``` interaction (reception of (x:{a:<t1> in,b:<t2> out})):<t1> out is ((res) in (identity) applied to ({x:a}) returns (res) ) with import iii/identity interaction (res):<t1> ref ``` ``` interaction set ` function implementationOf(construct){ if(construct.operator) } ` ```