Performs assignment.

The abbreviation for quote.

The abbreviation for backquote.

The abbreviation for unquote.

The abbreviation for splay.

The abbreviation for atsign.

The abbreviation for met-name.

The abbreviation for access.

The abbreviation for template-str.

Alternative syntax for nested function calls.

Alternative syntax for nested function calls.

Addition.

Subtraction or negation.

Multiplication.

Division or reciprocation.

Remainder.

Numeric equality test.

Numeric less-than test.

Numeric less-than-or-equal test.

Numeric greater-than test.

Numeric greater-than-or-equal test.

Returns a reference to a method's self-object.

Equivalent to (class-of @self).

Equivalent to (class-name (class-of @self)).

Returns the name of the enclosing state or state* form.

Refers to a property's backing field.

Invokes a wrapped method, returning its result.

Equivalent to (enab! @self state-name ..args).

Equivalent to (enab? @self state-name).

Equivalent to (disab! @self state-name).

Returns #t if its first argument is numerically equal to any other argument.

Absolute value.

Replaces a number with its absolute value, in place.

Retrieves an item from a collection.

The abbreviation for access.

Mutates an item in a collection.

Arccosine, in radians.

Lazily tests whether all of an iterator's items match a predicate.

Performs a lazy Boolean AND.

Moves away from a target value.

Moves a number away from another number, in place.

Lazily tests whether any of an iterator's items match a predicate.

Returns a function's minimum and maximum argument count.

Constructs a new, mutable array.

Constructs a new, mutable array by repeating a value.

Returns #t if its argument is an array.

Arcsine, in radians.

Arctangent, in radians.

Accesses a method's self-object.

Accesses a method's self-object.

The abbreviation for atsign.

Invokes a wrapped method, returning its result.

Equivalent to (class-of @self).

Equivalent to (class-name (class-of @self)).

Equivalent to (disab! @self state-name).

Equivalent to (enab! @self state-name ..args).

Equivalent to (enab? @self state-name).

Refers to a property's backing field.

Returns a reference to a method's self-object.

Returns the name of the enclosing state or state* form.

Quasi-quotation.

The abbreviation for backquote.

Triggers an error.

Registers a classmacro.

Binds a global variable.

Binds a global macro.

Defines a new type of place.

Bitwise AND.

Bitwise NOT.

Bitwise inclusive OR.

Arithmetic right shift.

Left shift.

Logical right shift.

Bitwise exclusive OR.

Defines a pair of jump targets.

Converts its argument to a boolean.

Returns #t if its argument is a boolean.

Breaks out of a loop.

Invokes a method.

Returns #t if its argument can be invoked as a function.

Cube root.

Round up.

Sequences multiple iterators, one after another.

Returns #t or #f in the given ratio.

Converts its argument to a character.

Returns #t if its argument is a character.

Iterates over non-overlapping sub-arrays.

Iterates over non-overlapping sub-arrays with an exact size.

Clamps a value to a numeric range.

Clamps a number to lie within a numeric range, in place.

Defines a class.

Returns #t if a class incorporates a particular mixin.

Returns all of a class' mixins.

Returns the name of a class.

Returns the class of an object or RData.

Returns #t if its argument is a class.

Deletes all items from a collection.

Returns a shallow copy of its argument.

Clones another iterator's items.

Tests several conditions in turn.

Successively tests a value for equality using eq?.

Successively tests a value for equality using same?.

Successively tests a value for equality using ==.

Defines one or more associated constants.

Returns #t if a string contains a character or substring.

Skips the rest of a loop's current iteration.

Prematurely finishes a coroutine.

Resumes a paused coroutine.

Returns the current status of a coroutine.

Returns #t if its argument is a coroutine.

Cosine, in radians.

Consumes an iterator, counting its items.

Repeats another iterator indefinitely.

Prints its arguments, formatted for debugging.

Performs in-place subtraction or decrement.

Returns a deep, recursive copy of its argument.

Recursively clones another iterator's items.

Recursively freezes a tree of collections.

A shorthand for bind-global!.

Defines a class and binds it to a global variable.

Shorthand for bind-classmacro!.

Defers evaluation until the end of the current lexical scope.

Defers evaluation until a coroutine is paused and/or resumed.

A shorthand for bind-macro!.

Defines a mixin and binds it to a global variable.

Defines a function and binds it to a global variable.

A shorthand for bind-place!.

Defines a struct.

Deletes an item from a collection, without returning it.

Unbinds a global variable.

Unbinds a global macro.

Returns #t if its argument is a double-ended queue.

Disables a state.

Performs in-place division or reciprocation.

Euclidean division.

Performs in-place Euclidean division or reciprocation.

Performs sequential evaluation.

Evaluates multiple forms, returning the first form's result.

Returns #t if a collection contains no items.

Enables a state.

Returns #t if a state is currently enabled.

Tests whether one deque is the suffix of another.

Triggers an error when an assertion fails.

Counts an iterator's items as they're yielded.

Prints to the standard error stream.

Prints to the standard error stream, followed by a newline.

Returns #t if its first argument is equal to any other argument.

Returns #t if all of its arguments are equal to one another.

Evaluates a value as a form.

Evaluates multiple values as forms.

Returns #t if its argument is even.

Completely expands a form.

Partially expands a form.

Completely expands multiple forms.

Returns #t if its argument can be registered as a macro expander.

Inserts any number of key/value pairs into a table.

Defines one or more fields.

Returns a string describing the current file and line number.

Discards items from another iterator which fail to match a predicate.

Returns the first of an iterator's items which match a predicate.

Defines a finalizer method.

Defines a mixin finalizer method.

Defines a state finalizer method.

Jumps to the end of an enclosing block.

Flattens nested structure.

Converts its argument to a floating-point number.

Converts a float to a string, with the specified number of digits after the decimal point.

Floating-point sign bit.

Returns #t if its argument is a floating-point number.

Round down.

Defines a function.

Returns a function's name.

Returns #t if a function might yield.

Defines a function with zero arguments.

Defines a function with one argument.

Returns #t if its argument is a GameLisp function.

Passes all of an iterator's items to an accumulator function.

Loops over each value produced by an iterator.

Loops over a numeric range.

Loops over an inclusive numeric range.

Returns the fractional part of a float.

Returns #t if an RData has been freed.

Freezes a collection so that it can no longer be mutated.

Freezes a global variable.

Defines a set of mutually exclusive states.

Runs the garbage collector.

Retrieves information about the garbage collector.

Tunes the garbage collector.

Constructs a unique symbol.

Accesses a global variable.

Assigns a new value to a global variable.

Increases a deque's size.

Returns #t if the given symbol has a global binding.

Returns #t if the given symbol has a global macro binding.

Returns #t if the given name is bound to a method.

Returns #t if an object or class has a particular state.

Returns #t if a collection contains a particular item.

Returns its argument.

Performs conditional evaluation.

Performs in-place addition or increment.

Replaces itself with the contents of a file.

Returns #t if its argument is infinite.

Defines an initializer method.

Defines a mixin initializer method.

Defines a state initializer method.

Inserts one or more elements into a deque.

Converts its argument to an integer.

Converts an integer to a string, with the specified radix.

Returns #t if its argument is an integer.

Returns #t if an object or RData belongs to the specified class.

Constructs an iterator over a collection.

Returns #t if an iterator can be advanced from the back.

Returns #t if an iterator has no more items to produce.

Advances an iterator.

Advances the back of a double-ended iterator.

Returns #t if its argument is an iterator.

Returns #t if its argument can be iterated.

Combines an array of deques into one deque.

Iterates over the keys of a table.

Returns #t if all of its arguments would occupy the same table entry when used as keys.

Returns the number of items in a collection.

Binds a local variable.

Defines a class and binds it to a local variable.

Defines a function and binds it to a local variable.

Defines a local macro.

Defines a mixin and binds it to a local variable.

Iterates over lines in a string.

Evaluates the contents of a file.

Parses and evaluates a string.

Logarithm.

An endless loop.

Converts a string to lowercase.

Accesses a global macro.

Suppresses macro expansion.

Assigns a new global macro to a symbol.

Calls a function for each of another iterator's items.

Maps a function over a deque in-place.

Maps a function over a collection, preserving syntax information.

Attempt to match a value against several patterns.

Returns #t if a value matches a pattern.

Maximum.

Returns a function's maximum argument count.

Defines a method.

Shorthand for a method call.

The abbreviation for met-name.

Minimum.

Returns a function's minimum argument count.

Defines a mixin.

Applies mixins to a class definition.

Returns #t if a class is a mixin.

Performs in-place multiplication.

Defines the name of a class.

Returns #t if its argument is a NaN.

Returns #t if its argument is a natural integer (>= 0).

Negates a number, in place.

Returns #t if its argument is a negative integer (< 0).

Returns #t if its argument is #n.

Discards any number of arguments and returns #n.

Converts its argument to a boolean and negates it.

Returns an iterator's nth item.

Returns a double-ended iterator's nth-from-last item.

Returns #t if its argument is a number.

Permanently deactivates an object.

Returns #t if an object has been killed.

Returns #t if its argument is an object.

Returns #t if its argument is odd.

Iterates over zero or more arguments.

Returns an iterator which lazily calls a function.

Performs a lazy Boolean OR.

Numeric or lexicographic ordering.

Adds padding characters to the end of a string.

Adds padding characters to the end of a string.

Adds padding characters to the beginning of a string.

Incrementally parses values from a string.

Parses exactly one value from a string.

Parses zero or more values from a string.

Removes the deque's last element, and returns it.

Removes the deque's first element, and returns it.

Returns #t if its argument is a positive integer (> 0).

Searches within a deque.

Exponentiation.

Prints to the standard output stream.

Pretty-prints to the standard error stream.

Pretty-prints to the standard output stream.

Converts GameLisp syntax into a string with appropriate whitespace.

Losslessly converts GameLisp data into a string with appropriate whitespace.

Prints to the standard output stream, followed by a newline.

Defines a property.

Appends one or more elements to the end of a deque.

Prepends one or more elements to the beginning of a deque.

Suppresses evaluation.

The abbreviation for quote.

Generates a random number.

Randomly selects one of its arguments.

Restarts the random number generator from a fixed seed.

Randomly selects one item from a group, with unequal probability.

Iterates over non-overlapping sub-arrays, in reverse order.

Iterates over non-overlapping sub-arrays with an exact size, in reverse order.

Returns #t if its argument is Rust data.

Performs in-place remainder.

Euclidean remainder.

Performs in-place Euclidean remainder.

Removes an item from a collection, and returns it.

Returns an iterator which infinitely yields its arguments.

Returns an iterator which repeatedly calls a function.

Performs text substitution.

Returns #t if its argument would be a valid, representable symbol.

Evaluates the contents of a file, if it hasn't been seen before.

Jumps to the start of an enclosing block.

Filters a deque in-place.

Returns from a function call.

Reverses an iterator.

Reverses a deque in-place.

Returns the first of an iterator's items which match a predicate, searching backwards.

Returns #t if its argument is a Rust function.

Passes all of an iterator's items to an accumulator function in reverse order.

Iterates over a numeric range.

Iterates over an inclusive numeric range.

Round-to-nearest.

Searches backwards within a deque.

Returns #t if its first argument has the same identity as any other argument.

Returns #t if all of its arguments share the same identity.

Moves closer to a target value.

Moves a number closer to a target number, in place.

Reduces a deque's size.

Sign.

Sine, in radians.

Skips a fixed number of leading items from another iterator.

Skips leading items which match a predicate.

Sleeps the current thread for the given number of seconds.

Smoothly interpolates between 0.0 and 1.0.

Returns a sorted copy of a deque.

Sorts a deque in-place.

Passes all of an iterator's items as function arguments.

The abbreviation for splay.

Splices a form into its parent form.

Iterates over sub-strings.

Square root.

Returns a string describing the current call-stack.

Tests whether one deque is the prefix of another.

Defines a class state.

Defines a class state which is enabled by default.

Skips over another iterator's items by the given interval.

Constructs a string.

Returns #t if its argument is a string.

Exchange values stored in two different places.

Swaps an element with the deque's last element, then removes it and returns it.

Swaps an element with the deque's first element, then removes it and returns it.

Constructs a symbol.

Returns #t if its argument is a symbol.

Constructs a table.

Returns #t if its argument is a table.

Limits another iterator to a fixed number of items.

Limits another iterator using a predicate.

Tangent, in radians.

Constructs a string.

The abbreviation for template-str.

Generates a high-precision timestamp.

Triggers an error with a "not yet implemented" message.

Trims leading and trailing characters from a string.

Trims trailing characters from a string.

Trims leading characters from a string.

Returns the integer part of a float, as a float.

Captures errors with a brief error message.

Captures errors with a verbose error message.

Returns the primitive type of its argument as a symbol.

Returns the number of seconds elapsed since the UNIX epoch, as a string.

Evaluates its body when a condition is false.

Losslessly converts GameLisp data into a string.

Evaluate a quasi-quoted form.

The abbreviation for unquote.

Loops as long as a condition is false.

Converts a string to uppercase.

Returns #t if its argument is a valid symbol character.

Returns #t if its argument would be a valid symbol.

Iterates over the values of a table.

Evaluates its body when a condition is true.

Evaluates some forms when a value matches a pattern.

Loops as long as a condition is true.

Returns #t if the given character or string is whitespace.

Iterates over overlapping sub-arrays.

Mutates a global variable for the duration of a dynamic scope.

Wraps another method in the same class.

Wraps another property in the same class.

Yields a value from a coroutine.

Yields each value produced by an iterator.

Combines multiple iterators.