system macrosstd/System.xtlm

Import a library under an alias of your choice: the alias on the left (lowercase letters and digits, then a colon), the library's name or path on the right. A name Name finds Name.xtl and Name.xtlm together, beside the importing file, then in userlibs/, then in each directory of XETAL_PATH, then among the standard libraries built into xetal; the first place holding either gives both. Their exports are then written with the alias (s:m_ean). Built into xetal: it makes names exist under the alias, which no macro's text can do (a macro gives source, and source can only use names that exist), so it has a signature here and no definition.

      ˢ⁼u̲se< "Stats"

      ˢm̲ean 1 2 3
2.0

The value of the first expression on the right when the condition on the left holds, else of the second. The condition is tested when the program runs, and only the expression chosen is evaluated (MC14).

      "2 > 0" i̲f< "1; -1"
1

Run the statements on the right unless the condition on the left holds; the value is @ either way (MC15).

      "1 = 0" u̲nless< "p_rint! 7"
7
@

One statement per word on the left, each a copy of the template on the right with $w replaced by the word; it stands as a statement of its own (MC16).

      "m_ax m_in" e̲ach< "u:$w/ := { '$w r_/ _r }"

      ᵘm̲ax/ 3 1 4
4

The line the call is written on, as a number (inside another macro's expansion, the line of that macro's call).

      @ l̲ine< @
1

The file the call is written in, as a string (-e for text given on the command line).

      @ f̲ile< @
-e

The text of a file, as a string, by a path relative to the file the call is written in; from the disk at the command line, from the store in the browser (Rust's include_str!). For example, t := @ i_nclude< "data.txt" binds the text of data.txt.

1 when a configuration fact holds, else 0: the platform (cli, or web in the browser) or a flag set with xetal --cfg NAME.

      @ c̲fg< "cli"
1

Stop with a compile error at the call, with the code on the left and the message on the right (Rust's compile_error!); a macro writes it into its text to refuse a call.

      "too-big" e̲rror< "the grid must be at most 9 wide"
error[too-big]

The value of the expression on the right, after writing [file:line] expr = value to standard error (Rust's dbg!).

      1 + @ d̲bg< "2 * 3"
7

When the condition on the left does not hold, write assertion failed: cond (message) [file:line] to standard error, the condition as written, and go on; the message on the right may be @ for none. The value is @ either way. Unlike Rust's assert!, it never stops the program (p_anic< does).

      "1 > 2" a̲ssert< "one is not more than two"
@

The text on the right with each {expr} replaced by the value of expr, as the function f_ormat writes it; {{ and }} are braces. An unclosed {, an empty {} or a lone } fails before the program runs (Rust's format!).

      @ f̲ormat< "two and two: {2 + 2} {{four}}"
two and two: 4 {four}

Stop the program with error[panic] and the message on the right, formatted as f_ormat< does, at the call; it stands where any value may (Rust's panic!).

      1 + @ p̲anic< "no {1 + 1}"
error[panic]

Stop the program with error[panic] and the message "not yet implemented: " followed by the text on the right (formatted as f_ormat< does); a placeholder for code still to write, standing where any value may (Rust's todo!).

      1 + @ t̲odo< "the size check"
error[panic]

Run the statements on the left under a trap: when they stop with an error, the handler on the right runs with the error as e and answers an outcome (r_ecover<, r_etry<, h_alt<, c_ontinue<, or a c_atch< choosing among them); the value is the body's or the recovery. Both sides are written as lambda bodies ([]T_RAP).

      "1 d_iv 0" t̲ry< "@ r_ecover< \"-1\""
-1

In a handler: the outcome on the right for an error whose code is one of the words on the left, and h_alt< for any other error.

      "\"io\" []S_IGNAL \"gone\"" t̲ry< "\"io empty\" c_atch< \"@ r_ecover< \\\"0\\\"\""
0

Run the statements on the left, then the cleanup on the right, whether the body gave a value or an error; the value is the body's, or its error going on ([]E_NSURE).

      "p_rint! 1; 2" f̲inally< "p_rint! \"cleaned\""
1
cleaned
2

In a handler: recover with the value on the right, of the body's type; the try's value is this one ([]R_ECOVER). The right side is code, like every macro argument: to recover with a string, write a string literal there, its quotes escaped once more inside t_ry<.

      "1 d_iv 0" t̲ry< "@ r_ecover< \"2 + 2\""
4

      "\"io\" []S_IGNAL \"gone\"" t̲ry< "@ r_ecover< \"\\\"none\\\"\""
none

In a handler: run the body again (at most 1000 times; []R_ETRY).

      n! ← 0

      "n! := n! + 1; n! < 3 ? \"again\" []S_IGNAL \"not yet\"; n!" t̲ry< "@ r_etry< @"
3

In a handler: let the error go on as it was ([]H_ALT).

      "1 d_iv 0" t̲ry< "@ h_alt< @"
error[division-by-zero]

In a handler: go on from a warning ([]W_ARN) with its value ([]C_ONTINUE).

      "10 + (0 []W_ARN \"empty\" \"nothing\")" t̲ry< "@ c_ontinue< @"
10