util.mcl

Return the input unchanged, usually as a default mapper or sort key.

let identity = |x| x

let same = map(values, identity)

Reverse a list or string.

let reverse = |v| ...

Stable sort with an optional key function.

The key lambda is evaluated once per element; elements with equal keys keep their input order.

let sort = |v, key = identity| ...

let ordered = sort(points, |p| p[0])

Map a function over a list.

let map = |v, f| {
    var out = []
    for (x in v) { out .= f(x) }
    return out
}

let dots = map(sample(-1, 1, 5), |x| center{[x, 0, 0]} Dot())

Keep only elements for which predicate returns truthy.

let filter = |v, predicate| {
    var out = []
    for (x in v) {
        if (predicate(x)) { out .= x }
    }
    return out
}

let positives = filter(values, |x| x > 0)

Fold a list from left to right with an explicit seed.

reduce([a, b, c], seed, f) evaluates like f(f(f(seed, a), b), c).

let reduce = |v, seed, binary| {
    var acc = seed
    for (x in v) { acc = binary(acc, x) }
    return acc
}

let total = reduce(values, 0, |acc, x| acc + x)

Pair corresponding elements from two lists, truncating to the shorter length.

let zip = |u, v| ...

let stops = zip(sample(0, 1, 3), [BLUE, CYAN, WHITE])

Pair every list element with its zero-based index.

let enumerate = |v| ...

for ([i, piece] in enumerate(pieces)) { print [i, piece] }

Return truthy when every element is truthy.

let all = |v| {
    for (x in v) { if (not x) { return 0 } }
    return 1
}

Return truthy when any element is truthy.

let any = |v| {
    for (x in v) { if (x) { return 1 } }
    return 0
}

Count elements satisfying a predicate.

let count = |v, predicate| {
    var n = 0
    for (x in v) { if (predicate(x)) { n = n + 1 } }
    return n
}

Sum a list; list values are added element-wise by the language.

let sum = |v| {
    var s = 0
    for (x in v) { s = s + x }
    return s
}

let centroid = sum(points) / len(points)

Product of all elements in a list.

let product = |v| {
    var p = 1
    for (x in v) { p = p * x }
    return p
}

Maximum element of a non-empty list, optionally by key.

Errors on an empty list. Use std.math.max(a, b) for pairwise numeric maximum.

let max_of = |v, key = identity| ...

Minimum element of a non-empty list, optionally by key.

Errors on an empty list. Use std.math.min(a, b) for pairwise numeric minimum.

let min_of = |v, key = identity| ...

Keys from a map in insertion order.

let map_keys = |m| ...

Values from a map in insertion order.

let map_values = |m| ...

Key/value pairs from a map in insertion order.

let map_items = |m| ...

for ([key, value] in map_items(stats)) { print [key, value] }

First n elements of a list.

Negative counts are treated as zero.

let take = |v, n| ...

List with the first n elements removed.

Negative counts are treated as zero.

let drop = |v, n| ...

Select list elements by index list.

Indexes are zero-based and must be in bounds; duplicates are allowed and preserve the order of indexes.

let list_subset = |src, indexes| ...

let corners = list_subset(points, [0, 2, 3])

Concatenate one level of nested lists.

let flatten = |v| {
    var out = []
    for (x in v) {
        for (y in x) { out .= y }
    }
    return out
}

let all_terms = flatten(rows)

Maximum list nesting depth of a value.

Atoms have depth 0; [1, 2] has depth 1.

let depth = |v| ...

Character length of a string.

let str_len = |s| ...

Replace all occurrences of needle with with.

let str_replace = |s, needle, with| ...

Split a string by a separator.

let str_split = |s, sep| ...

Uppercase a string.

let str_upper = |s| ...

Lowercase a string.

let str_lower = |s| ...

Join strings with a separator.

let str_join = |parts, sep = ""| ...

let label = str_join(["x", "y", "z"], ", ")

Convert a value to a string.

Uses the same stringification rules as text constructors, so lists become concatenated text fragments.

let to_string = |x| ...

Convert an integer, float, or numeric string to an integer.

Float conversion truncates toward zero; strings are trimmed before parsing.

let to_int = |x| ...

Convert an integer, float, or numeric string to a float.

let to_float = |x| ...

Real part of a number; non-complex numbers return themselves.

let real = |x| ...

Imaginary part of a number; non-complex numbers return 0.

let imag = |x| ...

Runtime type name for a value.

let type_of = |x| ...

Test whether a live function/operator value has a named argument attribute.

let has_attr = |x, name| ...

Read a named argument attribute from a live function/operator value.

let get_attr = |x, name| ...

Return a value with a named live-call argument changed.

This is the dynamic form of ball.radius = 0.8; it returns the updated value so it works inside expressions.

let set_attr = |x, name, value| ...

ball = set_attr(ball, "radius", 0.8)

Read callable default arguments.

Returns the names that can be pre-filled with set_default or set_defaults.

let get_defaults = |x| ...

Pre-fill multiple named default arguments on a callable target.

Map keys must be strings naming defaults on the target.

let set_defaults = operator |target, defaults| ...

Raise a runtime error with the given message.

let runtime_error = |message| ...

Test whether a value is nil.

let is_nil = |x| ...

Test whether a value is an integer.

let is_int = |x| ...

Test whether a value is a float.

let is_float = |x| ...

Test whether a value is complex.

let is_complex = |x| ...

Test whether a value is numeric.

let is_number = |x| ...

Test whether a value is a string.

let is_string = |x| ...

Test whether a value is a list.

let is_list = |x| ...

Test whether a value is a map.

let is_map = |x| ...

Test whether a value is a mesh.

let is_mesh = |x| ...

Test whether a value is a primitive animation.

let is_primitive_anim = |x| ...

Test whether a value is an animation block.

let is_anim_block = |x| ...

Test whether a value is a function.

let is_function = |x| ...

Test whether a value is an operator.

let is_operator = |x| ...

Test whether a value is a live function invocation.

let is_live_function = |x| ...

Test whether a value is a live operator invocation.

let is_live_operator = |x| ...

Test whether a value can be called.

let is_callable = |x| ...

Test whether a value is stateful.

let is_stateful = |x| ...