lang Module

'str ⇒ str quotesym

See quotesym.

' ⇒ quotesym

See quotesym.

:str ⇒ str define

See define.

: ⇒ define

See define.

:: ⇒ operator

See operator.

?str ⇒ str help

See help.

? ⇒ help

See help.

*str ⇒ str invoke

See invoke.

@str ⇒ str bind

See bind.

@ ⇒ bind

See bind.

>str ⇒ str save-symbol

See save-symbol.

<str ⇒ str load-symbol

See load-symbol.

-> ⇒ dequote

See dequote.

>> ⇒ prefix-dequote

See prefix-dequote.

>< ⇒ infix-dequote

See infix-dequote.

=> ⇒ apply

See apply.

∅ ⇒ ∅

Symbol used to separate input and output values in operator signatures.

=-= ⇒ expect-empty-stack

See expect-empty-stack.

^str ⇒ str lambda

See lambda.

^ ⇒ lambda

See lambda.

quot ⇒ (a_*)

Returns a new quotation obtained by evaluating each element of quot in a separate stack.

∅ ⇒ quot

Returns a list of all arguments passed to the current program.

a 'sym ⇒ ∅

Binds the specified value (auto-quoted) to an existing symbol 'sym.

a ⇒ bool

Converts a to a boolean value based on the following rules:

• If a is a boolean value, no conversion is performed.
• If a is null, it is converted to false.
• If a is a numeric value, zero is converted to false, otherwise it is converted to true.
• If a is a quotation or a dictionary, the empty quotation or dictionary is converted to false, otherwise it is converted to true.
• If a is a string, the empty string, and "false" are converted to false, otherwise it is converted to true.

((quot₁ quot₂)_*) ⇒ a_*

This operator takes a quotation containing n different conditional branches.

Each branch must be a quotation containing two quotations, and it is processed as follows:

• if quot₁ evaluates to true, then the quot₂ is executed.
• if quot₁ evaluates to false, then the following branch is processed (if any).

2 (
   ((> 3) ("Greater than 3" put!))
   ((< 3) ("Smaller than 3" put!))
   ((true) ("Exactly 3" put!))
) case

∅ ⇒ bool

Returns true if the current program has been compiled.

a 'sym ⇒ ∅

Defines a new symbol 'sym, containing the specified value.

a 'sym ⇒ ∅

Defines a new sigil 'sym, containing the specified value (auto-quoted if not already a quotation).

'sym ⇒ bool

Returns true if the symbol 'sym is defined, false otherwise.

'sym ⇒ bool

Returns true if the symbol 'sym is defined, false otherwise.

'sym ⇒ ∅

Deletes the specified symbol 'sym.

'sym ⇒ ∅

Deletes the specified user-defined sigil 'sym.

quot ⇒ a_*

Pushes the contents of quotation quot on the stack.

Each element is pushed on the stack one by one. If any error occurs, quot is restored on the stack.

∅ ⇒ bool

Returns true if the current program is being executed in development mode.

str ⇒ a_*

Parses and interprets str.

int ⇒ ∅

Exits the program or shell with int as return code.

quot₁ ⇒ quot₂

If the -d (--dev) flag is specified when running the program, validates the first n elements of the stack against the type descriptions specified in quot₁ (n is quot₁’s length) and if all the elements are valid returns them wrapped in quot₂ (in reverse order). If the -d (--dev) flag is not specified when running the program, no validation is performed and all elements are just returned in a quotation in reverse order.

∅ ⇒ ∅

Raises an error if the stack is not empty.

a ⇒ flt

Converts a to a float value based on the following rules:

• If a is true, it is converted to 1.0.
• If a is false, it is converted to 0.0.
• If a is null, it is converted to 0.0.
• If a is a integer, it is converted to float value.
• If a is a float, no conversion is performed.
• If a is a string, it is parsed as a float value.

quot₁ quot₂ ⇒ a_*

Applies the quotation quot₂ to each element of quot₁.

dict:error ⇒ str

Formats the error dict:error as a string.

 (
   (
      {"MyError" :error "This is a test error" :message} raise
   ) 
   (format-error)
 ) try

str ⇒ a

Converts a JSON string into min data.

str ⇒ a

Converts a YAML string into min data.

∅ ⇒ str

Reads a line from STDIN and places it on top of the stack as a string.

'sym ⇒ ∅

Prints the help text for 'sym, if available.

quot₁ quot₂ quot₃ ⇒ a_*

If quot₁ evaluates to true then evaluates quot₂, otherwise evaluates quot₃.

'sym ⇒ ∅

Imports the a previously-loaded module 'sym, defining all its symbols in the current scope.

quot ⇒ a

Dequotes quot using infix notation.

Note that no special operator preference is defined, symbols precedence is always left-to-right. However, you can use parentheses (quotes) to evaluate expressions before others.

 (2 + (3 * 5)) infix-dequote

 (2 + 3 * 5) infix-dequote

a ⇒ int

Converts a to an integer value based on the following rules:

• If a is true, it is converted to 1.
• If a is false, it is converted to 0.
• If a is null, it is converted to 0.
• If a is an integer, no conversion is performed.
• If a is a float, it is converted to an integer value by truncating its decimal part.
• If a is a string, it is parsed as an integer value.

'sym ⇒ a_*

Assuming that 'sym is a formatted like dictionary/symbol, calls symbol defined in dictionary (note that this also works for nested dictionaries.

{{100 :b} :a} :test *test/a/b

quot 'sym ⇒ ∅

Defines a new symbol 'sym, containing the specified quotation quot. Unlike with define, in this case quot will not be quoted, so its values will be pushed on the stack when the symbol 'sym is pushed on the stack.

quot 'sym ⇒ ∅

Binds the specified quotation to an existing symbol 'sym which was previously-set via lambda.

∅ ⇒ dict

Returns a dictionary dict containing a filename, line, and column properties identifying the filename, line and column of the current symbol.

quot₁ quot₂ quot₃ quot₄ ⇒ a_*

Implements linear recursions as follows:

1. Evaluates quot₁.
   • If quot₁ evaluates to true, then it evaluates quot₂.
   • Otherwises it executes quot₃ and recurses using the same four quotations.
2. Finally, it executes quot₄.

 5 (dup 0 ==) 'succ (dup pred) '* linrec

'sym ⇒ a_*

Parses and interprets the specified min file 'sym, adding .min if not specified.

'sym ⇒ a_*

Loads the contents of symbol 'sym from the .min_symbols file.

'sym ⇒ ∅

Sets the current logging level to 'sym. 'sym must be one of the following strings or quoted symbols:

• debug
• info
• notice
• warn
• error
• fatal

∅ ⇒ str

Returns the current log level (debug, info, notice, warn, error or fatal).

quot ⇒ a_*

Provides a way to define a new operator (symbol, sigil, or typeclass) on the current scope performing additional checks (compared to define and define-sigil), and automatically mapping inputs and outputs.

quot is a quotation containing:

• A symbol identifying the type of operator to define (symbol, sigil, or typeclass).
• A symbol identifying the name of the operator.
• A quotation defining the signature of the operator, containing input and output values identified by their type and a capturing symbol, separated by the ==> symbol.
• A quotation identifying the body of the operator.

The main additional features offered by this way of defining operators are the following:

• If in development mode (-d or --dev flag specified at run time), both input and output values are checked against a type (like when using the expect operator and automatically captured in a symbol that can be referenced in the operator body quotation.
• The full signature of the operator is declared, making the resulting code easier to understand at quick glance.
• An exception is automatically raised if the operator body pollutes the stack by adding or removing elements from the stack (besides adding the declared output values).
• It is possible to use the return symbol within the body quotation to immediately stop the evaluation of the body quotation and automatically push the output values on the stack.

 (
   symbol pow
   (num :base int :exp ==> num :result)
   ( 
     (base 0 == exp 0 == and)
       (nan @result return)
     when
     (base 1 == exp inf == and)
       (nan @result return)
     when
     (base inf == exp 0 == and)
       (nan @result return)
     when
     exp 1 - :n
     base  (dup) n times (*) n times @result
   )
 ) ::

∅ ⇒ dict

Returns a dictionary of all options passed to the current program, with their respective values.

dict₁ ⇒ dict₂

Returns a dictionary dict₂ holding a reference to the parent scope of dict₁ or null if dict₁ is ROOT.

str ⇒ quot

Parses str and returns a quoted program quot.

quot ⇒ a

Dequotes quot using prefix notation (essentially it reverses quot and dequotes it).

(* 8 4) prefix-dequote

∅ ⇒ str

This symbol is used to configure the prompt of the min shell. By default, it is set to the following quotation:

("[$1]$$ " (.) => %)

Unlike other predefined symbols, this symbol is unsealed, which means it can be modified.

'sym dict ⇒ ∅

Publishes symbol 'sym to the scope of dict.

a ⇒ a

Prints a and a new line to STDOUT.

∅ ⇒ ∅

Exits the program or shell with 0 as return code.

a ⇒ (a)

Wraps a in a quotation.

str ⇒ (sym)

Creates a symbol with the value of str and wraps it in a quotation.

dict:error ⇒ ∅

Raises the error specified via the dictionary dict:error.

∅ ⇒ quot

Returns a list of all arguments and (non-parsed) options passed to the current program.

'sym ⇒ ∅

Removes the symbol 'sym from the .min_symbols file.

'sym ⇒ dict

Parses and interprets (in a separater interpreter) the specified min file 'sym, adding .min if not specified, and returns a module dictionary dict containing all the symbols defined in 'sym.

∅ ⇒ ∅

If used within the body quotation of an operator definition, causes the interpreter to stop pushing further body elements on the stack and start pushing tbe operator output values on the stack.

∅ ⇒ dict

Returns a module holding a reference to the ROOT scope.

'sym ⇒ ∅

Saves the contents of symbol 'sym to the .min_symbols file.

∅ ⇒ dict

Returns a dictionary dict holding a reference to the current scope.

This can be useful to save a reference to a given execution scope to access later on.

{} :myscope (2 :two scope @myscope) ->

∅ ⇒ (str_*)

Returns a quotation containing all symbols saved in the .min_symbols file.

dict ⇒ (str_*)

Returns a list of all sigils defined in dictionary dict.

dict ⇒ (str_*)

Returns a list of all symbols defined in dictionary dict.

'sym ⇒ ∅

Seals symbol 'sym, so that it cannot be re-assigned.

'sym ⇒ ∅

Seals the user-defined sigil 'sym, so that it cannot be re-defined.

'sym ⇒ bool

Returns true if the symbol 'sym is sealed, false otherwise.

'sym ⇒ bool

Returns true if the sigil 'sym is sealed, false otherwise.

'sym ⇒ dict:help|null

Returns the help dictionary for the sigil 'sym, if available, null otherwise.

∅ ⇒ (str_*)

Returns a list of all sigils defined in the ROOT scope.

'sym ⇒ quot

Display the source code of symbol 'sym (if it has been implemented a min quotation).

a ⇒ str

Converts a to its string representation.

∅ ⇒ (str_*)

Returns a list of all symbols defined in the ROOT scope.

'sym ⇒ dict:help|null

Returns the help dictionary for the symbol 'sym, if available, null otherwise.

a quot ⇒ a

Performs the following operations:

1. Removes a from the stack.
2. For each quotation defined in quot (which is a quotation of quotations each requiring one argument and returning one argument):
   1. Pushes a back to the stack.
   2. Dequotes the quotation and saves the result as a.
3. Push the resulting a back on the stack.

{1 :a 2 :b 3 :c} (
  (dup /a  succ succ %a)
  (dup /b  succ %b)
) tap

quot int ⇒ a_*

Applies the quotation quot int times.

a ⇒ str

Converts a into a JSON string.

a ⇒ str

Converts a into a YAML string.

(quot₁ quot_2? quot_3?) ⇒ a_*

Evaluates a quotation as a try/catch/finally block.

The must contain the following elements:

1. A quotation quot₁ containing the code to be evaluated (try block).
2. (optional) A quotation quot₂ containing the code to execute in case of error (catch block).
3. (optional) A quotation quot₃ containing the code to execute after the code has been evaluated, whether an error occurred or not (finally block).

  (
    (pop)
    (format-error puts)
    (0)
  ) try

a ⇒ str

Returns the type of a.

'sym₁ 'sym₂ ⇒ ∅

Creates a type alias 'sym₁ for type expression 'sym₂.

quot₁ quot₂ ⇒ a_*

If ₁ evaluates to false then evaluates ₂.

'sym ⇒ ∅

Unseals the user-defined symbol 'sym, so that it can be re-assigned.

'sym ⇒ ∅

Unseals sigil 'sym, so that it can be re-defined (system sigils cannot be unsealed).

∅ ⇒ str

Returns the current min version number.

quot₁ quot₂ ⇒ a_*

If quot₁ evaluates to true then evaluates quot₂.

quot₁ quot₂ ⇒ a_*

Executes quot₂ while quot₁ evaluates to true.

0 :count 
(count 10 <=) 
(count puts succ @count) while

quot₁ quot₂ ⇒ a_*

Pushes each item of quot₁ on the stack using the scope of quot₂ as scope.