builtins

builtins module reference

builtin operators and constants.

index

• ! (opdef):  – Cast to !-stream.
• -> (builtin):  – Thread first macro.
• ->> (builtin):  – Thread last macro.
• = (opdef):  – Assert expression is constant.
• bang (bang):  – A `bang` value-constant.
• def (builtin):  – Declare symbols in current scope.
• defn (builtin):  – Define a function.
• do (builtin):  – Evaluate multiple expressions in a new scope.
• doc (builtin):  – Print documentation in console.
• export (builtin):  – Evaluate definitions in a new scope and return it.
• export* (builtin):  – Export specific symbol definitions as a module/scope.
• false (bool):  – The boolean constant `false`.
• fn (builtin):  – Declare a function.
• if (builtin):  – Make an evaltime const choice.
• import (builtin):  – Require and define modules.
• import* (builtin):  – Require and use modules.
• loop (builtin):  – Loop on arbitrary data via recursion.
• merge! (opdef):  – Merge !-streams.
• mkarray (opdef):  – Construct an array.
• mkstruct (opdef):  – Construct an struct.
• print (opdef):  – Print string values.
• recur (builtin):  – Reenter the innermost loop.
• require (builtin):  – Load a module.
• switch (opdef):  – Switch between multiple inputs.
• switch-1 (opdef):  – Switch between multiple inputs based on normalized i.
• trace (builtin):  – Trace an expression's values at runtime.
• trace= (builtin):  – Trace an expression's value at evaltime.
• true (bool):  – The boolean constant `true`.
• use (builtin):  – Merge scopes into current scope.
• when (builtin):  – Make an evaltime const choice with side effects
• ~ (opdef):  – Cast to ~-stream.

details

• ! (opdef):  – Cast to !-stream.

  (! val) (! sig trig)

  Casts anything to a !-stream depending on arguments:

  • if val is a ~-stream, emits events on changes.
  • if val is a !-stream, emits a bang for each incoming event.
  • if trig is given, samples sig as a new event when trig arrives.
• -> (builtin):  – Thread first macro.

  (-> initial [expr1 expr2…])

  Evaluate expressions expr1, expr2, … while passing the result of the previous expression to the following one, starting with initial. The value is always inserted as the first argument.

• ->> (builtin):  – Thread last macro.

  (->> initial [expr1 expr2…])

  Evaluate expressions expr1, expr2, … while passing the result of the previous expression to the following one, starting with initial. The value is always inserted as the last argument.

• = (opdef):  – Assert expression is constant.

  (= val)

  Asserts that val is a constant expression and returns it.

• bang (bang):  – A `bang` value-constant.
• def (builtin):  – Declare symbols in current scope.

  (def sym1 val-expr1 [sym2 val-expr2…])

  Define the symbols sym1, sym2, … to resolve to the values of val-expr1, val-expr2, ….

• defn (builtin):  – Define a function.

  (defn name-sym (p1 [p2…]) body-expr)

  Declare a function and define it as name-sym in the current scope. The symbols p1, p2, … will resolve to the arguments passed when the function is invoked.

• do (builtin):  – Evaluate multiple expressions in a new scope.

  (do expr1 [expr2…])

  Evaluate expr1, expr2, … and return the value of the last expression.

• doc (builtin):  – Print documentation in console.

  (doc sym)

  Print the documentation for sym to the console

• export (builtin):  – Evaluate definitions in a new scope and return it.

  (export expr1 [expr2…])

  Evaluate expr1, expr2, … in a new Scope and return scope.

• export* (builtin):  – Export specific symbol definitions as a module/scope.

  (export* sym1 [sym2…]) (export*)

  Creates a scope containing the symbols sym1, sym2, … and returns it.

  Copies the containing scope if no symbols are given.

• false (bool):  – The boolean constant `false`.
• fn (builtin):  – Declare a function.

  (fn (p1 [p2…]) body-expr)

  The symbols p1, p2, … will resolve to the arguments passed when the function is invoked.

• if (builtin):  – Make an evaltime const choice.

  (if bool then-expr [else-expr])

  bool has to be an evaltime constant. If it is truthy, this expression is equivalent to then-expr, otherwise it is equivalent to else-xpr if given, or nil otherwise.

• import (builtin):  – Require and define modules.

  (import sym1 [sym2…])

  Requires modules sym1, sym2, … and define them as sym1, sym2, … in the current scope.

• import* (builtin):  – Require and use modules.

  (import* sym1 [sym2…])

  Requires modules sym1, sym2, … and merges them into the current scope.

• loop (builtin):  – Loop on arbitrary data via recursion.

  (loop (k1 v1 [k2 v2…]) body)

  Defines a recursive loop function *recur* with parameters k1, k2, … and function body body, then invokes it immediately with arguments v1, v2, …

  Inside the body, (recur) is used to recursively restart loop evaluation with a different set of arguments, e.g. to sum the first 5 integers:

  (loop (n 5)
    (if (= n 0)
      0
      (+ n (recur (n - 1)))))
  

• merge! (opdef):  – Merge !-streams.

  (merge! evt1 evt2 [evt3…])

  Merges two or more !-streams of the same type. Whenever any of the input events fires, the output fires the same value.

  In case of collisions, the event that comes first in the argument list wins.

• mkarray (opdef):  – Construct an array.

  [a b c…] (mkarray a b c…)

  Produces an array of values.

  a, b, c… have to be values of the same type. This is a pure op, so at most one !-stream input is allowed.

• mkstruct (opdef):  – Construct an struct.

  {key1 val1 [key2 val2…]} (mkstruct key1 val1 [key2 val2…])

  Produces a struct of values.

  key1, key2, … have to be constant expressions. This is a pure op, so at most one !-stream input is allowed.

• print (opdef):  – Print string values.

  (print str)

• recur (builtin):  – Reenter the innermost loop.

  (recur nv1 [nv2…])

  Reenters the innermost (loop) from the top, with k1 bound to nv1, k2 bound to nv2…

  (recur nv1 [nv2…]) is equivalent to (*recur* nv1 [nv2…]).

• require (builtin):  – Load a module.

  (require name)

  Load a module and return its scope.

• switch (opdef):  – Switch between multiple inputs.

  (switch i v1 v2…) (switch i arr)

  • When fed a num~ or num! stream, reproduces the matching value (indexed starting from 0).
  • When fed a bang! trigger, steps forward to the next step on each trigger.
  • When fed a bool~ or bool! stream, outputs the first or second value for true and false respectively. This version takes at most two values.

  When only a single value is provided, it must be an array and is indexed as above.

• switch-1 (opdef):  – Switch between multiple inputs based on normalized i.

  (switch-1 i v1 v2…) (switch i arr)

  Like switch, but numeric indexes are in the range [0, 1[.

• trace (builtin):  – Trace an expression's values at runtime.

  (trace expr)

• trace= (builtin):  – Trace an expression's value at evaltime.

  (trace= expr)

• true (bool):  – The boolean constant `true`.
• use (builtin):  – Merge scopes into current scope.

  (use scope1 [scope2…])

  Copy all symbol definitions from scope1, scope2, … to the current scope. All arguments have to be evaltime constant.

• when (builtin):  – Make an evaltime const choice with side effects

  (when bool then-exprs…)

  bool has to be an evaltime constant. If it is truthy, this expression is equivalent to (do then-exprs…), otherwise it results in nil.

• ~ (opdef):  – Cast to ~-stream.

  (~ event initial)

  Casts !-stream to ~-stream by always reproducing the last received value. Since ~-streams cannot be emtpy, specifying an initial value is necessary.