Lava’s parser supports a range of unary and binary operators. Below is a summary, grouped by category. Expressions can use parentheses `(...)` to override normal precedence.

1) **Arithmetic Operators**

- `+` (addition): e.g. `a + b`.

- `-` (subtraction or unary negation): e.g. `a - b`, or `-x` for negative.

- `*` (multiplication): e.g. `a * b`.

- `/` (division): e.g. `a / b`. (Typically yields float results, but bridging can vary.)

- `%` (modulo): e.g. `a % b` for remainder.

2) **Comparison Operators** (result in boolean `true`/`false`)

- `==` (equality check).

- `!=` (inequality).

- `<` (less than).

- `<=` (less or equal).

- `>` (greater than).

- `>=` (greater or equal).

3) **Logical (Boolean) Operators**

- `&&` (logical AND): short-circuits if left side is false.

- `||` (logical OR): short-circuits if left side is true.

- `!` (logical NOT): unary operator, e.g. `!x`.

4) **Bitwise Operators** (operate on integer operands)

- `&` (bitwise AND).

- `|` (bitwise OR).

- `^` (bitwise XOR).

- `~` (bitwise NOT / complement).

- `<<` (left shift).

- `>>` (right shift).

5) **Precedence Overview** (from highest to lowest)

- Parentheses `( ... )` override everything.

- Unary operators `-` (negation), `!`, `~` (applied to a single operand).

- Multiplicative `*`, `/`, `%`.

- Additive `+`, `-` (binary subtraction).

- Shifts `<<`, `>>`.

- Relational / comparison `<`, `>`, `<=`, `>=`, `==`, `!=`.

- Bitwise AND `&`, then XOR `^`, then OR `|`.

- Logical AND `&&`, then logical OR `||`.

Notes: Lava’s parser2 internally defines a parsing order for these operations. You can also chain operations, respecting precedence, or use parentheses for clarity. Placeholders `_` can still appear in expressions but are not themselves an operator—they enable partial application.

Accepts exactly 1 numeric argument (int, float, or something coercible).

Returns the absolute value as an int or float, depending on your environment’s bridging.

If called with non-numeric or multiple arguments, it raises an error.

Takes exactly 1 argument in the domain [-1, 1]. Returns the angle in radians.

If called with an out-of-range value, it may return NaN or raise an error (implementation-dependent).

Accepts exactly 1 argument >= 1. If you pass a smaller number, it may raise an error or return NaN (depending on bridging).

Returns a float representing acosh(value).

Takes exactly two 2D tensors of the same shape. The result is elementwise A[i] + B[i].

Partial usage is supported (gpu:add(A) => function expecting B).

If dimension mismatch or bridging detects an invalid shape, an error is raised. If GPU is not available, logs fallback usage and calculates on CPU.

Accepts up to two arguments (A, B). If both are given, it returns A+B only one is given, it returns a partial function waiting for the missing array.

Each argument must be either int2d_array or float2d_array of matching dimensions. If they differ in shape or if either is not 2D, an error is raised.

If one array is float2d and the other is int2d, both get upcast to float2d internally (depending on bridging).

Raises an error if dimension mismatch or if either argument is not recognized as int2d or float2d.

Takes exactly 1 argument: a callback function that receives pass/fail status after each test file completes or a final outcome (environment-dependent).

Internally calls `test:list()` to discover .mu files, then calls `test:run(file, cb)` for each, sorting the results so failing tests might appear last or in a certain order.

Use this as a single entry point to run all your test files from a script or CI environment. If you prefer to run them individually, call `test:run(...)` for each file.

Accepts up to two arguments: (item, arrayOrString).

If array is int[], item must be an int. If array is str[], item must be a single string, etc.

If the 'array' is actually a single string, then item must also be a single string, and the result is a concatenation of those two strings.

Missing arguments or placeholders create a partial usage scenario.

Expects up to two arguments: (function, array). If both are provided, it calls function(...arrElements).

If the array has `n` elements, they become `n` arguments to the function. If it’s empty, the function is called with zero arguments.

Partial usage: If you only supply one argument or placeholders, it returns a partial function waiting for the missing piece. Example: `array:apply((a,b))` => returns a partial needing an array.

If the second argument is not recognized as an array (int[], str[], bool[], float[]), it raises an error.

Similar to Ramda’s `apply(fn, arr) => fn(...arr)` pattern.

gpu:apply_activation expects 2 arguments: (Str activationName, Tensor).

Supported strings might be 'relu', 'sigmoid', 'tanh', or others depending on bridging. If unknown, raises an error.

Returns a new tensor of the same shape, with each element replaced by the activation function result.

math:arb(...) parses the given string expression (like "0.1 + 0.2") and calculates the result using a custom decimal approach for exact arithmetic, avoiding floating-point rounding issues.

Supported operators include +, -, *, and /, along with parentheses. Division uses a fixed internal precision (e.g. 20 digits).

Accepts exactly one argument: a single string representing the expression. If you pass something else (like multiple strings or an array), it raises an error.

Returns the final decimal result as a single string, e.g. "0.3" or "121932631112635269".

One argument only, must be in the domain [-1,1].

Returns a float in the range [-π/2, π/2].

Accepts 1 numeric argument of any real value.

Returns a float representing asinh(x).

Expects (key, value, object). The object must be a KeyedArray. The key must be a single string. If the key already exists, its value is replaced.

If you only supply (key, value), it returns a partial function waiting for the object. If you skip any of them with `_`, it returns a partial needing more calls.

Raises an error if the object is not keyed or if the key is invalid.

One argument only, any real number.

Returns the angle in radians in range (-π/2, π/2).

Takes two arguments: (y, x). If only one is provided (or placeholders used), partial usage applies.

atan2 returns a float angle in radians, range (-π, π).

Accepts 1 numeric argument strictly between -1 and 1 for finite real results.

If out of range or exactly ±1, might produce error or Infinity/NaN (depending on bridging).

Takes 1 numeric argument, which can be negative or positive.

Returns the real cube root as a float.

One numeric argument only. Returns the smallest integer ≥ value (some bridging may store it as float).

Takes 1 numeric argument, converts it to a 32-bit unsigned integer, then counts the leading zero bits in its binary form.

If the argument is 0 or not numeric, the result might be 32 or bridging error for invalid input.

sys:command(...) spawns a background thread to run the given command string in your system shell/environment.

The second argument is a callback function that receives a keyed array when the command finishes. That array typically has these fields:

- `command`: the original command string

- `stdout`: a single string of the command's stdout output

- `stderr`: a single string of the command's stderr output

- `exit`: an integer exit code (0 means success, non-zero means error)

- `success`: a boolean true if exit=0, false otherwise

You do not have to return anything from your callback function. The `sys:command` call returns `Bool(true)` immediately, while the command runs in the background.

If you need to actively poll for how many sys:command tasks remain, call `sys:check_tasks()` repeatedly. In some Lava builds, a built-in event loop runs that automatically waits for tasks to finish before exiting.

compose(...) processes arguments from the rightmost function to the leftmost, similar to how nested function calls work: f(g(h(x))).

If you need left-to-right ordering, see pipe(...).

You can partially apply compose by providing fewer arguments, using underscore placeholders for the missing function slots. Once all slots are known, it yields a single function that you can invoke with your data.

flow:compose(...) can take any number of function arguments. Each must be either a bridging or user function returning an InkTransform if you want to chain them. However, it does not strictly require them to be transforms; it composes the calls from right to left.

If all arguments are real functions, it returns a final function. If placeholders or partial usage is detected, it returns a partial function waiting for the missing pieces.

Once fully formed, calling the final composition with a single data value (like an InkIterator) passes that data through each function from right to left. The rightmost function is called first, then its result is fed into the next, etc.

Accepts up to two arguments => (array1, array2). If both are provided, returns a single array containing all elements of array1 followed by all elements of array2.

If either argument is missing or a placeholder (_), partial usage is returned, waiting for the missing piece.

Typically both arrays must be of the same element type. Some builds might attempt to unify or raise an error if types differ.

Only accepts two string parameters in total.

Allows partial application if one argument is omitted or uses underscore (_).

Once both strings are known, it returns a single concatenated string.

One argument only. Interpreted as radians. Returns a float cos(x).

Single numeric argument. Returns cosh(x) as a float.

The function takes a single keyed array with window options:

- `title`: Window title (string)

- `width`, `height`: Dimensions in pixels (int)

- `borderless`, `resize`, `topmost`, `transparency`: Boolean flags

- `scale`: String, controls upscaling ('X1', 'X2', etc.)

- `scaleMode`: Placement/scaling style ('UpperLeft', 'Stretch', etc.)

Returns a window handle to be used in later Kanvas calls.

Partial usage may be available if not all options are supplied (implementation-dependent).

Takes exactly 1 argument if fully applied, which can be: - A single string (like '{"key":"value"}'), - A StrArray of length 1 (treated as a single JSON string), - An InkIterator or InkTransform producing ASCII characters or string chunks. If you call `json:decode()` with no arguments, it returns a partial function waiting for that argument.

On success, returns a Lava `Value` that matches the JSON structure (bool, int, float, KeyedArray, etc.). Null is converted to a placeholder `_` by default (or whichever bridging logic you configured).

If the JSON is invalid, an error is raised. If reading from an InkIterator or Transform, we gather characters until EOF or an error occurs.

The first argument is a descriptive string name for the test suite.

The second argument is a callback function that contains one or more 'it(...)' calls defining actual tests.

If any assertions fail within that callback, an error is raised and the current test or suite may halt.

Takes a window handle returned by kanvas:create.

Shows the window. Must be called before drawing functions take effect.

Typically returns a boolean or success indicator.

Expects up to 2 arguments => (numerator, denominator). If either is missing or _, partial usage is returned until both are known.

All operations produce float or float[] results. For integer arrays, bridging typically converts them to float arrays before division.

Division by zero raises an error or returns Infinity, depending on your bridging logic.

If the arrays differ in length (for array/array division), bridging raises an error in most builds.

Similar to array:map but calls the function for the purpose of side effects, then returns the original array as-is.

Usage: `json:encode( optionsKeyedArray, dataValue ) => SingleString(jsonText)`. - The first argument is a KeyedArray (or `_` placeholder) of options. It must at least exist, even if empty: `[ ]`. - The second argument is the Lava data to encode (int, float, array, keyed array, etc.).

Supported options: - `pretty`: bool => if true, uses pretty-printed JSON. - `indent`: SingleString => if `pretty=true`, replaces the default 4-space indentation with a custom string (e.g. "\t" or " ").

If you partially apply, you can pass the options now and the data later, or placeholders for either argument.

Any function or InkTransform encountered in the data is turned into `null` (or bridging default). Mixed numeric arrays unify if possible (int => float, etc.).

One numeric argument only. Returns e^(value).

If the actual value differs from the expected value, expect_equal throws an error that stops execution of the current test (and possibly the entire script).

This is useful for verifying behavior in small 'it(...)' test blocks.

There is no partial usage for expect_equal—it always takes exactly two arguments: (actual, expected).

Takes 1 or 2 arguments:

- First argument: a function with no parameters, which we call expecting it to fail.

- Second argument (optional): a string. If present, we check that the error message contains this substring.

If the user function does NOT raise an error, the current test fails immediately. If it raises an error but does not contain the optional substring, the test fails too.

If an error occurs and matches the optional substring (or no substring was provided), the test is considered passed for that scenario.

expect_not_equal throws an error if the actual value matches the expected value, causing the current test to fail immediately.

Use this to confirm that two values differ, ensuring your code doesn't produce an unwanted correct match.

Single numeric argument. This is typically more accurate for small x than (exp(x) - 1).

Calling `extend(...)` attempts to load and initialize the specified component’s library. On success, any bridging functions it provides become available in the current interpreter context.

If the library fails to load or does not export a Cargo.lock function, an error is raised immediately.

For details on usage of each loaded component’s functions, consult that component’s individual documentation entries.

The first argument must be a single string representing the URL.

The second argument must be a function (callback) that takes one argument (the response body as a single string).

net:fetch runs asynchronously, returning immediately with a boolean (true). The actual network request occurs in the background.

When the fetch completes, your callback is called with the raw response body. If the request fails, the callback receives a string describing the error.

Expects exactly 2 arguments: (filename, expectedString).

If the file contents differ or the file can't be read, it immediately fails the test (e.g., 'file_contents_equal fail').

Part of the 'file_asserts' bridging in the test plugin, primarily used in test code.

Expects exactly 2 arguments: (filename, lengthInt).

Reads the file as text, measures its length in characters. If it doesn't match lengthInt, fails the test with an error message.

If the file cannot be opened, the test also fails.

Expects exactly 2 arguments: (filename, compareString).

If the file contents match the given string or the file can't be read, the test fails immediately with an error message.

Useful for asserting that a file does NOT contain certain output or contents.

Accepts 1 or 2 arguments: (predicateFn[, data]).

If called with 1 argument (predicate), it returns a partial function waiting for the data array.

If called with 2 arguments, it immediately filters the array.

The data must be int[], str[], or float[]. For each element, the predicate is called. If it returns true, the element is included in the result. If it returns false, it is excluded.

Expects up to 2 arguments => (predicateFn, source). If fewer or placeholders, returns partial usage until both are known.

source can be an InkIterator or an InkTransform. The resulting transform only yields items for which predicate returns a truthy result: bool(true) or a non-zero number.

If the predicate returns bool(false), 0, or an error, that item is skipped or iteration stops. Mixed or invalid predicate results raise an error.

Combine with flow:to_array(...) or another transform for final consumption or chaining.

One numeric argument. Returns the greatest integer ≤ x.

Single numeric argument. Converts to the closest 32-bit float representation, then returns it as a 64-bit float (depending on bridging).

gpu:hadamard => A[i] * B[i] for each element. Both tensors must share the same shape.

If dimension mismatch, bridging raises an error. If GPU is unavailable, CPU fallback occurs.

Partial usage => pass just A or B first. E.g. hadX = gpu:hadamard(A), then hadX(B).

The first argument must be a keyed array, e.g. `[someKey:"value", anotherKey: 123]`.

The second argument must be a single string representing the key name.

If the key is absent, has_key(...) immediately fails the test, appending a 'missing key' message.

If the subject is not a keyed array, it also fails the test with an appropriate error.

Any number of numeric arguments. Summation of squares => sqrt(...) is computed and returned as float.

If called with fewer arguments, partial usage accumulates them until all are known, then calculates the final result on call.

Takes exactly two arguments, both coerced to 32-bit signed integers, returning the 32-bit product with overflow wrap behavior.

Partial usage: supply just one argument or use `_` to skip the first or second parameter.

Accepts exactly one argument: a callback function. The callback is invoked asynchronously.

The callback receives a KeyedArray containing process-related details, such as:

- pid: an integer process ID

- uid (on Unix) or 0 on other systems

- username: current user name

- binary_name: name of the current executable

- cwd: current working directory path as a string

- platform & architecture: e.g. "linux" / "x86_64"

The test harness or main loop typically calls process:check_tasks to wait for any tasks spawned by process:info to complete.

Usage: array:ink(start, end) => returns an InkIterator that yields each integer from start (inclusive) to end (exclusive).

Unlike array:range, ink does not build the entire array in memory. Instead, it produces values lazily, on demand. This is beneficial for very large ranges or streaming scenarios.

The returned type is InkIterator, which you can pass to array:map, array:reduce, or other bridging functions that support iteration over InkIterator.

Both arguments must be integers. If non-integer values are passed, or if you pass fewer/more arguments, an error is raised.

Arguments: (delayMS, callback).

- `delayMS`: integer or single-element IntArray specifying the repeat interval in milliseconds.

- `callback`: a function with no parameters, called each time the interval elapses.

Returns an integer handle. Pass that handle to `event:stop(handle)` to cancel the interval so it no longer fires.

If you omit or partial-apply an argument, it returns a partial function needing the missing argument(s).

Intervals never stop on their own; you must call `event:stop(handle)` or exit the script.

gpu:inverse => only supports 2×2. If shape is not [2,2], bridging raises an error. If the matrix is nearly singular, it errors with 'cannot invert'.

Often used as a minimal demonstration. For bigger NxN, see advanced GPU solvers or third-party libraries.

No partial usage by default; expects exactly 1 argument.

The first argument is a descriptive string for the test name or scenario.

The second argument is a callback function that typically contains one or more assertions, such as expect_equal(...).

When 'it(...)' is executed, the callback runs immediately. If any assertions fail, it raises an error that halts the test.

Takes exactly one argument, typically a KeyedArray (e.g. [someKey:"value", anotherKey:123]).

Returns a str-array of all the keys in that keyed array, in insertion order.

If you pass a normal int[], str[], or anything else, the result may be an empty array or an error (implementation-dependent).

Accepts exactly one argument which must be an array or keyed array.

Returns an integer: the size of that array or the number of entries in a keyed array.

If the input is not recognized as an array or keyed array, it raises an error.

Requires exactly one string argument, e.g., "Hello, world!"

Returns an integer value representing the character length of the string.

If you pass something else (like multiple strings or arrays), it raises an error.

Arguments:

- Window handle

- Two points: [[x0, y0], [x1, y1]]

- Color string (hex)

Draws a straight line. Use kanvas:refresh to show changes.

Takes zero arguments, returns a str-array of test file names (like ["someTest.mu", "otherTest.mu"]).

Primarily for internal use in the 'test' runner bridging but can be called in your scripts to discover test files if desired.

If the 'tests/' directory or .mu files aren’t found, it might return an empty array or raise an error, depending on your environment.

Accepts 1 argument > 0. If <= 0, may produce error or NaN (bridge-dependent).

One argument, must be positive. Returns log base 10 of value.

Accepts a single numeric argument > -1. This function is typically more precise than log(1+x) for small x.

One argument > 0, returning log base 2 of that value.

Accepts exactly one argument: an integer specifying how many characters of Lorem Ipsum to write.

Creates a file in your project’s ./tmp subdirectory named 'lorem_<4-hex-hash>'. Returns that path as a single string.

Fails if the file cannot be created or written. Use this for setting up test files of a certain size or content for file-based tests.

Accepts exactly one argument, which must be a str-array (e.g. ["Hello","WORLD"]).

Returns a new array of strings, each converted to lowercase.

If you pass anything else (a single string, int array, bool array, etc.), it raises an error.

The function takes exactly one string argument and returns its lowercase equivalent.

It will fail if given something that is not a single string (like an array or keyed array).

If called with two arguments (function, array), it applies the function to each element of the array and returns a new array.

If only one argument is supplied, returns a partial function waiting for the other argument (function or data).

The array can be int[], str[], float[] (depending on environment). The function’s return type determines the type of the new array.

If no arguments are eventually provided, result may be -Infinity or an error, depending on bridging.

If any argument is non-numeric, an error may occur or result is NaN. Implementation detail depends on bridging.

Any number of numeric arguments. If bridging sees no final arguments, the result might be +Infinity or an error.

Partial usage: supply arguments in stages until final invocation.

gpu:multiply(A,B) multiplies two 2D tensors A (m×k) and B (k×n). The result is (m×n).

If shapes mismatch, bridging raises an error. If GPU is unavailable or not implemented for multiply, it may fallback to CPU with a console message.

Partial usage: you can call gpu:multiply(A) => returns a function expecting B, or placeholders (gpu:multiply(_, B)) => expects A next.

If both arguments are single integers, it returns their product.

If one argument is an integer array, it returns an integer array of element-wise products.

You can partially apply `multiply` by providing only one argument, returning a function waiting for the other argument.

Use the underscore placeholder `_` if you need to skip the first parameter while providing the second (or vice versa).

Takes (A, B). If shapes are compatible => result is M×P if A is M×N and B is N×P.

If dimension mismatch (A’s columns != B’s rows), it raises an error. If one arg is missing, partial usage awaits the second array.

Supports both int2d_array and float2d_array. If mixing, you might get a float2d_array result.

The first argument is an integer index. Negative indices count from the end, e.g. -1 => last element.

The second argument is the array. Must be int[], str[], or bool[].

If the index is out of range, returns '_'. If any argument is missing, you get a partial function requiring the missing parameter.

The first argument can be a single string (e.g., "127.0.0.1") or a keyed array with fields like dest, count, or interval.

The second argument must be a callback function that processes each ping reply.

Returns an integer task ID. Use net:stop(taskId) to cancel an ongoing ping.

If run with proper privileges on Unix, raw ICMP is used; otherwise, the system ping command is used.

You can specify a count to limit the number of pings and an interval (in milliseconds) to adjust the delay between pings.

pipe(...) works similarly to compose, but the functions are executed from left to right: pipe(f, g, h)(x) => h(g(f(x))).

If you prefer right-to-left ordering, see compose(...).

You can partially apply pipe by providing fewer function arguments. Missing spots can use underscore placeholders. Once all functions are known, you get a single function to call with your data.

Arguments:

- Window handle

- Coordinates as an [x, y] array (integers)

- Color as a string (e.g. '#RRGGBB' or '#AARRGGBB')

Colors support hex formats. Coordinates are zero-based. No return value.

Call kanvas:refresh(win) to display updates.

When both arguments are single integers, the result is a single integer (e.g. 3 + 4 = 7).

If one argument is an integer array, the result is an integer array of element-wise sums (e.g. plus(5, [10,20,30]) -> [15,25,35]).

You can partially apply `plus` by supplying only one argument. For example, `plus(10)` returns a new function expecting the second argument.

Use the underscore placeholder (`_`) if you need to omit the first parameter instead of the second (e.g. `plus(_, 2)`).

If called with two integers, pow(base, exponent) returns base^exponent, failing on negative exponents.

If only one argument is given, returns a partial function that expects the missing argument.

Placeholders allow skipping the first parameter instead of the last.

Because it is registered as 'math:pow', you must call it as math:pow(...) unless you rebind it.

If both a key (string) and a keyed array are provided, the value for that key is returned immediately.

If only one of them is provided, returns a partial function that expects the missing argument.

Raises an error if the object is not a keyed array or if the key is not a valid single string.

The first argument must be a keyed array, e.g. `[ city:"London" ]`.

The second argument is a single string (key name). If that key is missing, the test fails.

The third argument is the expected value. If the actual value differs, the test fails with a 'mismatch' message.

Use prop_equals(...) for quick checks of a keyed array's property.

Accepts two integer arguments: start, end. Generates an array of integers [start..end).

If only one is provided, it returns a partial function expecting the other. If both are missing or `_`, partial usage continues until both are known.

Negative or reversed ranges result in an empty array. This is akin to many functional libraries’ range semantics.

Argument patterns: - If called with 1 argument (path:string), the entire file is read at once and returned as a single string. - If called with 2 arguments (path:string, chunkCallback:function), the function processes the file in streaming mode. It returns immediately (e.g. true), then repeatedly calls your callback with each chunk of data until EOF.

In streaming mode, the callback takes exactly one argument: the chunk (as a string or bytes). If an error occurs, file:read typically raises an exception or passes an error string to the callback (implementation‐dependent).

You can use partial usage. For example, `file:read(path, _)` returns a function that waits for the callback. Or `_` for the path, if you want to fix the callback first.

If your environment does not support streaming, these second-argument references may be ignored or raise an error.

Arguments:

- Window handle

- Two-element array: [[x0, y0], [x1, y1]] (top-left and bottom-right corners)

- Color string (e.g. '#FF0000' for red)

Draws a filled rectangle. Coordinates must be within window bounds.

Expects up to three arguments: (function, initialValue, data). Missing arguments become placeholders or partial usage.

The user-supplied function is invoked for each element. Typically, the reduce-lambda uses a curried approach: first call with (acc), then call with (item).

Raises an error if the data is not an int[], str[], or recognized array type.

gpu:reduce_sum => expects exactly one 2D float32 tensor. Returns a single float result (like 21.0).

If bridging is incomplete, logs fallback CPU. For large shapes, a real GPU kernel can speed up summation significantly, if available.

No partial usage is typically provided for reduce_sum; it requires exactly 1 argument.

Arguments:

- Window handle (returned by kanvas:create).

Call kanvas:refresh after one or more drawing operations (like kanvas:pixel, kanvas:rectangle, etc.) to display changes on the screen.

If you do not call refresh, the window may not visibly update, depending on platform or bridging implementation.

Does not return a value.

Arguments: (x, y, rad)

- x: X coordinate (int or float)

- y: Y coordinate (int or float)

- rad: Angle in radians (float/int). Positive is counterclockwise.

Returns: FloatArray [rotatedX, rotatedY].

Example: Rotating (1,0) by π/2 radians yields (0,1).

Raises an error if arguments are missing or not numeric.

One numeric argument. Behavior for .5 depends on your environment's bridging (it might round half up or to even).

Accepts exactly 2 arguments: (filename, callback).

filename is a test file in the tests/ folder

Takes exactly 2 arguments => (scalar, tensor). The scalar can be int or float. The second must be a 2D float32 tensor.

gpu:scale => elementwise multiplication by the scalar. Returns a new tensor with identical shape.

If GPU is missing or not implemented for scale, logs fallback CPU. Partial usage => e.g. scale(10) => a function expecting the matrix next.

-1 if negative, +1 if positive, 0 if zero

One argument in radians. Returns float sin(x).

One numeric argument => returns float for sinh(x). hyperbolic functions are similar to standard trigonometric functions but instead use a hyperbolic curve not a circle as a reference.

Accepts up to three arguments => (skip, count, source). If some are placeholders, returns partial usage. If all are resolved, yields an InkTransform that reads from the given source (an InkIterator or InkTransform).

skip is how many items to discard first, count is how many items to produce next, ignoring the rest. Once count items are produced, iteration returns 'NO_MORE_DATA'.

If skip or count is negative, it’s treated as 0 in some bridging logic, or yields an error in others, depending on your environment.

Like `sput`, requires exactly one argument of any Value type.

Prepends 'LOG: ' to the printed output, then returns the argument unchanged.

Useful for verbose logging, leaving behind 'LOG:' markers in your console output.

Requires exactly one argument (of any Value type).

Prints a bracketed or typed representation of that argument to stdout, then returns it unchanged.

Use `sput` for debugging or quick prints. If your environment logs to console, you’ll see the output immediately.

Takes exactly one numeric argument >= 0. If negative, bridging may raise an error or produce NaN (implementation-dependent).

Returns a float. If the input was an integer, you still get a float result (e.g., 25 => 5.0).

Does not support partial usage in most builds; if you pass fewer or more than one argument, it raises an error.

Pass an integer seed to srand, which returns a new generator function.

Each call to the generator produces a next pseudo-random integer based on that seed.

The sequence is deterministic, so the same seed yields the same sequence every time.

Takes exactly one argument: the integer handle returned by event:interval(...).

Marks that interval as canceled. On the next poll cycle, it is removed from the event loop.

If the handle does not match any active intervals, nothing happens (no error).

Partial usage is generally not used for event:stop; it expects a single handle argument.

After calling net:ping(...), you get back an integer task ID. Pass that same ID to net:stop to cancel the ongoing ping.

If no ping with that ID is found, net:stop does nothing (silently).

This function only affects tasks launched by net:ping in the net plugin.

gpu:subtract(A, B) => A[i][j] - B[i][j], shapes must match exactly.

Partial usage => pass one argument now, the second later. E.g. gpu:subtract(A) => function expecting B.

If bridging is incomplete or GPU is unavailable, logs fallback CPU path but still returns the correct result.

math:subtract(a, b) returns a - b. If called with only one argument, it returns a partial function waiting for the second number.

Using '_' lets you skip the first parameter, while providing the second immediately. Then the returned partial function expects just the first parameter.

If an array is used for either argument, each element of that array is subtracted by the single integer from the other argument (if supported by your bridging logic).

Takes two arguments (A, B). If only one is provided, returns a function needing the missing array.

Subtracts elementwise => (A[i][j] - B[i][j]). If shape mismatch, an error is raised.

Supports int2d_array and float2d_array. If mixing int2d + float2d, upcast to float2d occurs (depending on bridging).

Accepts exactly one argument: an int[], str[], or bool[].

Returns a new array missing the first element. If the array is empty or length=1, it returns an empty array.

Does not currently support partial usage. Passing multiple arguments triggers an error.

Accepts exactly 1 numeric argument in radians. If out of normal range, bridging might produce Infinity or error.

One numeric argument => returns float tanh(x).

Takes (ms, source). If ms or source is missing or placeholder, partial usage is returned. If both are known, returns an InkTransform that sleeps ms milliseconds between yields.

source can be an InkIterator or another InkTransform. Once you pull items (e.g. with flow:to_array), each retrieval is delayed by ms.

If ms < 0, bridging might raise an error. If the source ends, the transform yields NO_MORE_DATA normally.

Arguments: (delayMS, callback).

- `delayMS`: an integer (or single-element IntArray) specifying how many milliseconds to wait.

- `callback`: a function with no parameters, called once after the delay elapses.

Returns `Bool(true)` or a success indicator if it schedules successfully. The task is automatically removed once it fires.

Partial usage: If you only supply one argument, you get a partial function needing the missing argument. Use `_` placeholders to skip the first parameter if desired.

This function is asynchronous; the script continues running while the timer counts down.

sys:timestamp_micro() calls the system clock and returns a 64-bit integer (i64) measuring microseconds since the Unix epoch (1970-01-01).

No arguments are taken; if any arguments are passed, it raises an error.

If you need millisecond precision, see sys:timestamp_ms(). For microseconds, use this function.

sys:timestamp_ms() makes a synchronous call into the system clock and returns a 64-bit integer representing milliseconds since the Unix epoch (1970-01-01).

No arguments are taken; if you pass any arguments, it raises an error.

If you need finer granularity in microseconds, see sys:timestamp_micro().

Takes exactly one argument => (source). The source must be an InkIterator or an InkTransform.

It repeatedly retrieves items until 'NO_MORE_DATA', gathering them into an int_array, float_array, or str_array if uniform. Mixed types cause an error unless your bridging code supports a generic array.

This is a final stage that pulls the entire stream into memory. For extremely large streams, consider using partial consumption or separate techniques if memory is a concern.

Requires exactly 1 argument: a Value::Tensor with elem_type=Float32 and shape=[rows, cols].

Returns a float2D_array by reading each row from the data buffer.

If bridging sees shape != 2D, or the data is not float32, an error is raised. This function is a standard finishing step after GPU-based transforms.

Takes one argument (of any Value type) and returns a single string representation.

If the Value is already a string, it simply returns that string.

Use string:to_string in places where you need a textual representation of any data. or if a string is require by a function such as string:concat

gpu:to_tensor => exactly 1 argument: a 2D array (either int2D_array or float2D_array). The resulting shape is [rows, cols].

All values become float32. If rows differ in length, bridging fails with an 'inconsistent row lengths' error.

Used as the first step for GPU ops like multiply, add, etc.

If called with two arguments (userFunc, source), it returns a new InkTransform. The source can be an InkIterator or another InkTransform (chaining).

If fewer arguments or placeholders are provided, partial usage is returned until both a function and a source are known.

The user-defined function receives each item individually. If it returns an error or 'NO_MORE_DATA', iteration stops. Typical bridging expects a single transformed item per call.

Combine with flow:to_array(...) to gather all transformed items into an in-memory array.

gpu:transpose expects exactly 1 Tensor. Must be 2D, shape [rows, cols].

Returns a new tensor with shape [cols, rows].

If input is not 2D, bridging may raise an error or produce unexpected results.

Takes 0 or 1 arguments. If zero, partial usage is returned, expecting the actual 2D array next.

Returns a new 2D array with rows and columns swapped. If A is M×N, the result is N×M.

Works with int2d_array or float2d_array. If shape is irregular or data is not 2D, bridging might raise an error.

Arguments:

- Window handle

- Three points: [[x0, y0], [x1, y1], [x2, y2]]

- Color string

Draws a filled triangle with the specified color.

Accepts exactly 1 numeric argument, returning an integer part of x (as float or int). Negative numbers move toward 0.

Accepts **exactly one argument** of any `Value` type.

Returns a short string identifying that value’s runtime type. Common results include:

- "Int", "Float", "Bool", "Str"

- "IntArray", "StrArray", "BoolArray", "KeyedArray"

- "Fn" (any function or lambda)

If you pass the wrong number of arguments it raises an error immediately.

Accepts zero arguments, returns a single string in the form "tmp/test_<8_hex>" that is likely unique for this run.

Useful in tests to avoid name collisions when creating or overwriting files.

Does not actually create a file, only returns a path.

The function takes exactly one string argument and returns its uppercase equivalent.

It will fail if given something that is not a single string.

Argument patterns: - (path:string, textToWrite:string): writes the given string to that path all at once. - (path:string, something, callback:function): if streaming is supported, the callback is used to obtain successive chunks.

If the file does not exist, it is created. If it does exist, it’s overwritten unless your environment defaults to append mode.

Returns a boolean true or a success message (e.g. "OK"). Raises an error if writing fails.

Partial usage is possible, e.g. `file:write(path, _)` or `_` placeholders.

If your bridging layer does not implement streaming, the third argument and chunk callback references can be omitted or raise an error.