Built-ins

Plus.

Minus. Written spaced (3 − 1): a minus touching a number makes it negative.

Times, drawn as the times sign.

Power, spaced: x ^ n. An exponent written touching a value (x²) is a literal superscript instead; touching a function it is function power (see p_ower).

The larger of two numbers; 'm̲ax r̲/ is the largest item.

The smaller of two numbers.

Divide, drawn as the division sign; the result is a Float.

Whole-number division, in maths order: 7 d̲iv 2 is 3.

Remainder, in maths order: 7 m̲od 3 is 1 (the left argument is divided by the right).

Negate.

Absolute value.

Round down to an Int.

Round up to an Int.

e to a power.

Natural logarithm.

An Int as a Float.

Sine.

Cosine.

Arctangent, the angle whose tangent is the argument.

The constant pi. It is niladic, so it is applied to @.

Equal (any scalar type).

Not equal.

Less than (numbers and characters).

Greater than.

At most.

At least.

Equal within a small tolerance, for Floats.

And.

Or.

Not.

Print a value and give it back (the ! marks an effect).

A random whole number from 1 to n for every n (seeded here, so the example repeats).

The value itself. As the left function of a fork it gives the argument unchanged: [i̲d F G] x is (i̲d x) F (G x), that is x F (G x) (a hook); [i̲d − n̲eg] 5 is 5 − (n̲eg 5).

The left argument. In a dyadic train, x [l̲eft F r̲ight] y is x F y, so the tacks pick an argument for each side of a fork.

The right argument.

The alphabet, the uppercase letters: a system value, written without an underline and read where it is used.

The digits, as characters.

The atomic vector: every character, ASCII 0 to 127 (source is ASCII), so a character's code is its place in it, less one.

The index origin: always 1 (there is no setting).

The local time stamp: year, month, day, hour, minute, second and millisecond, read each time it is used (a host without a clock reports error[no−clock]). Shown here by its shape, since it changes.

Wait the given seconds (an Int or a Float); the result is the seconds actually waited, at least those asked for. A negative delay is an error.

The code of each character, keeping the shape. Codes go back to characters with ⎕U̲CHAR.

The character of each code, 0 to 127; another code is an error.

Write the text on the left to the file on the right (made, with its directories, if missing); how many characters it wrote.

A file's text.

A line typed at the keyboard (here, the line "a typed line").

Write a line to standard error (red in the live demo), and give the text back.

Stop the program with error[panic] and the text as its message (what @ p̲anic< "..." writes). Its result has any type, so it stands where any value may.

Stop with an error of your own: the code on the left names the error class, as xetal's own codes do (lowercase letters, digits and hyphens), and the text on the right is its message. Uncaught, it ends the program with exit status 1, like any error. Its result has any type.

An error the program can go on from (a warning): the left argument is the value to go on with, of the type of the place the warning stands in, and the right is the code and the message, a strand of two strings. Uncaught, a warning is an error like a signal. A handler that answers ⎕C̲ONTINUE makes the program go on from the warning with that value; the other answers unwind as they do for any error.

Run the body; on any error, call the handler with it. The trap's value is the body's, or what the handler recovers with.

Run the body, then the cleanup (a function of @), whether the body gave a value or stopped with an error; the body's value, or its error going on. The f̲inally< macro writes it.

The handler's answer: the trap's value is this one, of the body's type.

The handler's answer: run the body again. After 1000 runs the trap gives up with error[retry-limit].

The handler's answer: the error goes on as it was, from where it was raised. A handler for one kind of error halts on the others.

The handler's answer to a warning: go on from it, with its value. The handler runs where the warning was raised, before any cleanup between it and the trap, so nothing has been undone. Halting a warning passes it outward still a warning; continuing an error raised by ⎕S̲IGNAL is error[not-resumable], since it has no value to go on with.

The code of a caught error (mine of error[mine]).

The message of a caught error.

Where a caught error was raised, as errors print it: the span of source text, start..end.

The terminal's facts: rows, columns, 1 when output is a terminal, 1 when it does screen control (here, output to a file).

One key, without Enter, as a Key (here, the key a): the terminal reads it raw; in the live demo the program waits in the terminal pane. Keys are named in the Terminal library (ᵗ⁼u̲se< "Terminal", then ᵗUP, ᵗENTER, ...) and compare with =.

A printing key's character, or nothing for a named key such as Up.

Named key n (1 to 11: Up, Down, Left, Right, Enter, Escape, Backspace, Tab, Delete, Home, End), for the Terminal library, which names them.

Source text as the editor and the HTML export see it: a matrix of boxed texts, a row per run of one class, two columns: the decorated text (underlines drawn, as xetal render shows it) and the class (builtin, userfunc, libfunc, variable, lambdaarg, number, exponent, string, symbol, quote, punct, unit, comment, space, macro, error). A program colors code in a picture or a page from it, so the coloring never drifts from the language.

A top-level list of strings in a TOML file, as boxed texts: "file" ⎕L̲IST "name". Strings only, and nothing in the file is run; a missing list, a value that is not a list of strings, or a file that is not TOML is error[bad-table], naming the file and the key.

A table of tables in a TOML file as a matrix of texts whose rows and columns follow two top-level lists: ("file" "name") ⎕T̲ABLE ("rows" "cols"); a cell the file does not have is the empty text. The Rosetta stone reads its idioms this way: ("data.toml" "source") ⎕T̲ABLE ("idioms" "languages").

The next event from the host, as an Event: a tick of the clock, a pointer down, move, up or click, a key, or end when there are no more. The command line reads them one per line from standard input or −−events FILE (tick 0.016, down 120 80, key Up); in the live demo the page gives ticks on each frame and the keys pressed. A program that draws loops on them: e ← ⎕E̲VENT @, update, ⎕S̲HOW, again, until ⎕E̲KIND e is end. Here the next event is down 120 80.

What kind an event is, as text: tick, down, move, up, click, key, choose (a choice in the host's controls, ⎕E̲AT giving which list and which item) or end.

An event's numbers: x y for a pointer, the seconds since the last tick for a tick, the list and the item for a choice, none for a key or the end.

A key event's key (⎕K̲CHAR reads its character); an error for the other kinds. Here the events are down 120 80 then key a.

Color n (1 to 8: black, red, green, yellow, blue, magenta, cyan, white), for the Terminal library, which names them (ᵗRED).

Text in a foreground color: the text wrapped in the codes a terminal (or the live demo's grid) colors it with; print it to see it. Here, its length: five characters on each side of the text.

Text on a background color, as []F_G does the foreground.

Text in bold (wrapped in its codes, as []F_G).

Text placed at a row and a column (1-origin), for a program that draws a screen: the code moving the cursor there, then the text.

The text that clears the screen and moves the cursor home; print it.

A value as the text it prints as.

The numbers in a text, as Floats.

Fail the macro call being expanded: the left text is a code and where to report it (call, left or right), the right text the message.

Whether the call being expanded stands as a statement of its own.

The file the call being expanded is written in (@ f̲ile< @).

The line the call being expanded is written on (@ l̲ine< @).

The text of a file, by a path relative to the file the call being expanded is written in (@ i̲nclude< "data.txt").

Whether a configuration fact holds: the platform (cli or web) or a flag set with xetal −−cfg NAME (@ c̲fg< "web").

An array as a picture, returned as SVG text: a vector as one row of cells, a matrix as a grid, a rank-3 array as frames shown in turn. Numbers that are all 0 or 1 draw their 1s dark; other numbers are colored from the least (dark purple) to the greatest (yellow); characters are drawn in their cells. A frame of more than 64 by 64 numbers is drawn as an image, a pixel per cell.

Points as a picture, returned as SVG text: 2 rows, x over y, joined in order and fitted into a 400-pixel picture with y pointing up; a rank-3 array is frames of paths shown in turn.

Show a picture, and return it: the command line writes it to a numbered file (−−draw DIR, else XETAL̲DRAW, else the current directory), the browser shows it beside the program.

The length of each axis.

How many items along the first axis: the rows of a matrix. With a subscript it counts along that axis only when the result keeps a rank the rule allows: t̲ally₂ would drop two ranks, an error.

The numbers 1 to n.

The numbers 0 to n - 1.

The first item along the first axis: the first row. With a subscript, along that axis: f̲irst₂ is the first column.

Every item as one vector, row after row. With axis 2, column after column.

The items of the right argument, taken in order and repeated as needed, into the shape on the left.

The first n items (the last n for a negative n) along the first axis, or along the subscript's axis.

All but the first n items (the last n for a negative n), along the first axis or the subscript's.

The items at the given positions (from 1) along the first axis, or along the subscript's axis.

Replicate: each item (each row of a matrix) repeated as many times as its count on the left, so a 0 drops it and a mask of 1s and 0s keeps the items where it is 1; one count extends to every item, and with a subscript the counts go along that axis. A negative count is an error.

Join along the first axis, or with a subscript along that axis of both arguments: c̲at₂ puts matrices side by side. The other axes must match; a single value extends, and an argument of one rank less is one row (or, along axis 2, one column).

Reduce: combine the items along the first axis with the function, from the right ('− r̲/ 1 2 3 is 1 - (2 - 3)). On a matrix that combines the rows. A subscript picks the axis; two digits reduce both axes.

Scan: every running reduce, the last being the whole reduce. On a matrix down the rows; with a subscript along that axis.

Apply a function to every item. Given a dyadic function it pairs items of two arrays.

Map: the function on each item, every result boxed, so the function may give an array (e_ach wants one value per item).

Every pairing of an item on the left with one on the right (APL's outer product): the result has both shapes.

Inner product: A '+ '× i̲nner B is matrix multiplication (the last axis of A with the first of B).

'f 'g c̲ompose x is f applied to g applied to x; the atop train [f g] x is the same.

x 'f s̲wap y is y f x: the arguments swapped.

n 'f p̲ower x applies f to x n times; f̲^n is the same with a literal count.

Where each item of the right argument is first found among the items of the left, from 1; one past the end when it is not there.

Whether each item of the left is among the items of the right.

Whether both sides have the same shape and equal items (APL's match): one result for the whole arrays, where = compares item by item. The same items in another shape do not match.

The items without repeats, in first-seen order.

The items in ascending order (the rows of a matrix, compared in order); with a subscript, sorted along that axis.

The positions that would sort the items: (g̲rade v) s̲elect v is s̲ort v.

The positions of the 1s in a vector.

Enclose: the whole value as one item, a box, so arrays can be items of other arrays; a strand of strings encloses each string. A nested array prints in frames, as APL2's DISPLAY draws them (shown here as xetal −−ascii draws them; a terminal gets box characters): an arrow along the top, a down arrow for each leading axis, and a mark at the bottom for what it holds (~ numbers, e boxes).

Disclose: what a box holds. It opens one box (select one item first).

Display: any value as APL2's DISPLAY draws it, as a character matrix, flat arrays framed too: an arrow along the top, a down arrow for each leading axis, and a mark at the bottom for what it holds (~ numbers, a plain line characters, e boxes); a simple scalar is itself. xetal −−box prints every array result this way (shown here as xetal −−ascii draws them).

Partition: the items (rows of a matrix) cut into pieces by the keys on the left, one per item: a new piece starts where the key goes up, and an item with key 0 is left out, so a mask of 1s and 0s cuts out the runs of 1s. Each piece is a box; one key extends to every item.

Encode: the digits of a number in the radix on the left, most significant first (APL's encode). Radixes may differ from digit to digit (hours, minutes, seconds), a radix of 0 takes all that is left, and digits beyond the radix are dropped. A vector gives one column of digits per item.

Decode: the number whose digits, in the radix on the left, are on the right (APL's decode), the inverse of e̲ncode. One radix extends to every digit; a matrix gives one number per column. It is Horner's rule on any numbers, radix and digits of one type, so on Floats x d̲ecode r̲ev c is the polynomial with coefficients c (lowest first) at x.

Reverse the order of the items along the first axis (the rows of a matrix), or along the subscript's axis.

Rotate: shift the items round by n (APL's rotate); positive n moves items toward the front. Along the first axis by default, so a matrix's rows move; with a subscript along that axis. A list of amounts gives one result per amount.

Transpose: reverse the order of the axes, so a matrix's rows become its columns; a vector or a single value is unchanged. A subscript of two axes swaps just those two.

Permute the axes: the left argument lists each axis once, and axis i of the right argument becomes the axis that item i of the list names (APL's dyadic transpose), so 3 1 2 moves axis 1 to the end. Listing the axes in reverse is o̲\.