Functions

The numbers from start up to, but not including, end - the same as start..<end. Empty when end <= start.

Compiles a regular expression from a pattern and its flags - the same as Regex.new. An invalid pattern is a ParseError.

Fills each {} in template with the next value's toString(), and each {n} with the nth value (from 0). {{ and }} are literal braces. A placeholder without a matching value is a ParseError.

Joins path segments with /, dropping duplicate separators - joinPath("a/", "b", "c.rfn") is "a/b/c.rfn". A segment starting with / starts over from the root.

The last segment of a path - baseName("src/main.rfn") is "main.rfn".

Everything before the last segment of a path - dirName("src/main.rfn") is "src", and "." when there's no directory part.

The last segment's extension without its dot - "rfn" for "src/main.rfn", and "" when there's none.

Ends the program with the given exit code. Pending defer blocks still run first.

Hands message to &panicHandler, which by default prints it on standard error and stops the program - for states that mean a bug, not a failure the caller should handle (return an Error for those). Pending defer blocks still run first.

A placeholder for code that isn't written yet: type-checks as anything, and panics with message when reached.

Marks a branch that can't happen - panics with message if it does.

The runtime type of value - its actual type, not the static one (see #runtime.typeof).

The same as value.hash(), as a function to pass around.

The same as value.clone(), as a function to pass around.

The same as value.toString(), as a function to pass around - e.g. xs.map(toString).

How a compares to b - the same as a.compare(b), as a function to pass to sorting.

Its two arguments in the other order: (b, a). set (x, y) := swap(x, y) exchanges two variables.

Returns its argument unchanged - a no-op to pass where a function is required.

A function that ignores its argument and always returns value.

f after g: a function that runs g and passes its result to f.

The functions run left to right, each on the previous one's result - pipe(f, g)(x) is g(f(x)), the same as x |> f |> g. With no functions it's identity.

Wraps f so each distinct argument is computed once, and later calls with an equal argument return the stored result.

Pairs up the elements of a and b by position, stopping at the end of the shorter one.

Each element paired with its position, from 0.

value, count times - endlessly when count is undefined.

start, then next(start), then next of that, and so on - ending when next returns undefined.

Every element of the first source, then every element of the next, and so on.

Every pair of an element of a with an element of b, with a's element changing slowest.

start, start + step, start + 2 * step, ... - endlessly.

The smallest of its arguments.

The largest of its arguments.

π, the ratio of a circle's circumference to its diameter - 3.14159....

τ = 2π, a full turn in radians.

Euler's number, the base of the natural logarithm - 2.71828....

Positive infinity. Its negation is negative infinity.

Not-a-number - the result of an undefined operation like 0 / 0. It isn't equal to anything, itself included; check with Math.isNan.

The absolute value of x.

-1, 0 or 1, matching the sign of x.

x limited to the range low to high, both included.

All the arguments added together - T.zero() when there are none.

All the arguments multiplied together - T.one() when there are none.

The arithmetic mean of the arguments. No arguments is an EmptyError.

The middle argument once they're sorted - the mean of the two middle ones when there's an even number. No arguments is an EmptyError.

The largest whole number not greater than x.

The smallest whole number not less than x.

x rounded to decimals places after the point, halves away from zero.

x with its fractional part dropped - rounded toward zero.

The fractional part of x: x - Math.trunc(x).

The square root of x - NaN below zero.

The cube root of x, negative for a negative x.

The square root of the sum of the squares of the arguments - the length of a vector with those components - computed without overflowing on the way.

base raised to exponent - the same as base ^ exponent.

e raised to x.

The natural (base-e) logarithm of x.

The logarithm of x in base.

The base-2 logarithm of x.

The base-10 logarithm of x.

The sine of an angle in radians.

The cosine of an angle in radians.

The tangent of an angle in radians.

The angle, in radians from -π/2 to π/2, whose sine is x.

The angle, in radians from 0 to π, whose cosine is x.

The angle, in radians from -π/2 to π/2, whose tangent is x.

The angle, in radians from -π to π, from the positive x-axis to the point (x, y) - unlike atan(y / x), it tells the quadrants apart.

The hyperbolic sine of x.

The hyperbolic cosine of x.

The hyperbolic tangent of x.

An angle in degrees converted to radians.

An angle in radians converted to degrees.

The point t of the way from a to b: a at t = 0, b at t = 1. t outside 0 to 1 extrapolates.

How far x is along the way from a to b - the t for which Math.lerp(a, b, t) is x.

x moved from one range to the same relative place in another - Math.remap(5, 0..<10, 100..<200) is 150.

The greatest common divisor of a and b - never negative, and 0 only when both are.

The least common multiple of a and b - never negative, and 0 when either is.

1 * 2 * ... * n, and 1 for 0. A result too large for the type is an OverflowError.

The number of ways to choose k items out of n - 0 when k > n.

Whether n is a prime number.

Whether x is not-a-number. x == Math.nan() is always false, so this is the only way to check.

Whether x is neither infinite nor not-a-number.

Whether a and b differ by at most tolerance, relative to the larger of the two (absolute below 1) - for comparing results of float arithmetic, where == is too strict.