Builtin Functions Index

All builtin functions in meta-lisp, categorized by functionality.

• Generic
• Boolean
• Integer
• Float
• Text
• Symbol
• Void
• Array
• List
• Set
• Hash table
• Pair
• Maybe
• Box
• Function operations
• for- Iteration
• File I/O
• Path operations
• Assertions
• Error handling
• Process
• Random
• Format
• S-expression
• JSON

Generic

Operations applicable to all types.

• is-atom — Check if a value is an atom
• same — Atom or reference equality
• equal — Structural equality
• format — Format any value as a text
• hash-code — Compute hash code
• total-compare — Total order comparison

Boolean

Operations on bool-t.

• is-bool — Check if a value is a boolean
• not — Logical not

Integer

Operations on int-t.

Type check

• is-int — Check if a value is an integer

Arithmetic

• ineg — Negation
• iadd — Addition
• isub — Subtraction
• imul — Multiplication
• idiv — Integer division
• imod — Modulo

Predicates

• int-is-positive — Check if positive
• int-is-non-negative — Check if non-negative
• int-is-non-zero — Check if non-zero

Comparisons

• int-less — Less than
• int-greater — Greater than
• int-less-or-equal — Less than or equal
• int-greater-or-equal — Greater than or equal
• int-compare-ascending — Ascending comparison function
• int-compare-descending — Descending comparison function

Extremum

• int-min — Smaller of two values
• int-max — Larger of two values

Derived

• int-sum — Sum of a list
• int-product — Product of a list
• int-align — Align to a multiple

Float

Operations on float-t.

Type check

• is-float — Check if a value is a float

Arithmetic

• fneg — Negation
• fadd — Addition
• fsub — Subtraction
• fmul — Multiplication
• fdiv — Division
• fmod — Modulo

Predicates

• float-is-positive — Check if positive
• float-is-non-negative — Check if non-negative
• float-is-non-zero — Check if non-zero

Comparisons

• float-less — Less than
• float-greater — Greater than
• float-less-or-equal — Less than or equal
• float-greater-or-equal — Greater than or equal
• float-compare-ascending — Ascending comparison function
• float-compare-descending — Descending comparison function

Extremum

• float-min — Smaller of two values
• float-max — Larger of two values

Derived

• float-sum — Sum of a list
• float-product — Product of a list

Text

Operations on text-t.

Type checks

• is-text — Check if a value is a text
• text-is-int — Check if text is integer format
• text-is-float — Check if text is float format

Basics

• text-length — Length
• text-is-empty — Check if empty
• text-is-blank — Check if blank

Concatenation and splitting

• text-append — Append two strings
• text-concat — Concatenate a list of strings
• text-slice — Extract substring
• text-split — Split by delimiter
• text-join — Join with delimiter

Search and replace

• text-has-prefix — Check if text has prefix
• text-has-suffix — Check if text has suffix
• text-include — Check if text contains substring
• text-find-index — Find substring position
• text-replace — Replace substring

Trimming

• text-trim — Trim both ends
• text-trim-start — Trim start
• text-trim-end — Trim end
• text-trim-left — Trim left
• text-trim-right — Trim right

Case conversion

• text-to-lower-case — Convert to lower case
• text-to-upper-case — Convert to upper case

Type conversion

• text-to-int — Parse text to integer
• text-to-float — Parse text to float
• text-to-symbol — Convert text to symbol

Characters and code points

• text-chars — Split into character list
• text-get-code-point — Get code point
• text-lines — Split into lines

Derived

• text-repeat — Repeat a text
• text-compare-lexical — Lexicographic comparison

Symbol

Operations on symbol-t.

• is-symbol — Check if a value is a symbol
• symbol-length — Length of symbol name
• symbol-append — Append two symbols
• symbol-concat — Concatenate a list of symbols
• symbol-to-text — Convert to text

Void

• is-void — Check if a value is void

Array

Operations on (array-t E) — mutable arrays.

Type and construction

• array-t — Array type constructor
• make-array — Create an empty array
• is-array — Check if a value is an array
• (@array ...) — Array literal

Access

• array-get — Get element by index
• array-length — Array length
• array-is-empty — Check if empty

Mutation

• array-put — Replace at index
• array-push — Append at end
• array-pop — Pop from end
• array-push-front — Prepend at front
• array-pop-front — Pop from front
• array-reverse — Reverse in-place
• array-sort — Sort in-place with comparator

Copy and conversion

• array-copy — Copy an array
• array-to-list — Convert to list
• list-to-array — Convert from list

Iteration

• array-each — Iterate with side effects
• array-each-index — Iterate with index

List

Operations on (list-t E) — immutable lists.

Type and construction

• list-t — List type constructor
• null — The empty list
• is-list — Check if a value is a list
• cons — Prepend an element

Access

• car — First element
• cdr — Rest of the list
• list-head — First element (same as car)
• list-rest — Rest of the list (same as cdr)
• list-first — First element
• list-second — Second element
• list-third — Third element
• list-last — Last element
• list-but-last — All but last element
• list-get — Get element by index

Info

• list-length — List length
• list-is-empty — Check if empty
• list-has — Check if list has element

Transformation

• list-copy-put — Replace at index (immutable)
• list-copy-reverse — Reverse
• list-to-set — Convert to set

Generation

• list-range — Generate integers from 0 to n - 1
• list-enumerate — Pair elements with indices

Iteration and mapping

• list-each — Iterate with side effects
• list-each-index — Iterate with index
• list-map-concat — Map and flatten
• list-map-index-concat — Map with index and flatten
• list-map — Map over elements
• list-map-index — Map with index
• list-zip-map — Map over two lists in parallel
• list-zip — Pair elements by position
• list-unzip — Unzip pairs
• list-filter — Filter (keep matching)

Folding

• list-fold-left — Left fold
• list-fold-left-index — Left fold with index
• list-fold-right — Right fold
• list-fold-right-index — Right fold with index

Quantification

• list-every — All elements satisfy predicate
• list-some — Some element satisfies predicate

Sublists

• list-take — Take first n
• list-drop — Drop first n
• list-append — Append two lists
• list-concat — Concatenate list of lists

Grouping and search

• list-group — Group by predicate
• list-find — Find first matching element
• list-find-index — Find first matching index

Set

Operations on (set-t E).

Type and construction

• set-t — Set type constructor
• make-set — Create set from a list

Info

• set-size — Set size
• set-is-empty — Check if empty
• set-has — Check if set has element
• set-include — Check if set includes subset

Mutation

• set-copy — Copy a set
• set-add — Add element (mutable)
• set-copy-add — Add element (immutable)
• set-delete — Delete element (mutable)
• set-copy-delete — Delete element (immutable)
• set-clear — Clear set (mutable)

Set operations

• set-union — Union
• set-inter — Intersection
• set-difference — Difference
• set-disjoint — Check if disjoint

Iteration and transformation

• set-each — Iterate with side effects
• set-every — All elements satisfy predicate
• set-some — Some element satisfies predicate
• set-map — Map over elements
• set-select — Filter
• set-reject — Opposite of filter
• set-to-list — Convert to list

Hash table

Operations on (hash-t K V).

Type and construction

• hash-t — Hash table type constructor
• make-hash — Create empty hash table
• make-hash-from-entries — Build hash from pair list

Info

• hash-is-empty — Check if empty
• hash-length — Entry count
• hash-has — Check if contains key

Access

• hash-get — Get value by key
• hash-get-maybe — Get value as maybe

Conversion

• hash-keys — Get key list
• hash-values — Get value list
• hash-entries — Get entry list

Mutation

• hash-put — Add key-value pair (mutable)
• hash-copy-put — Add key-value pair (immutable)
• hash-put-entries — Put entries (mutable)
• hash-copy-put-entries — Put entries (immutable)
• hash-delete — Delete by key (mutable)
• hash-copy — Copy hash table

Iteration

• hash-each — Iterate over key-value pairs
• hash-each-key — Iterate over keys
• hash-each-value — Iterate over values
• hash-each-entry — Iterate over entries

Mapping

• hash-map — Map over key-value pairs
• hash-map-key — Map over keys
• hash-map-value — Map over values
• hash-map-entry — Map over entries

Selection

• hash-select — Filter by key-value predicate
• hash-select-key — Filter by key predicate
• hash-select-value — Filter by value predicate
• hash-reject — Remove by key-value predicate
• hash-reject-key — Remove by key predicate
• hash-reject-value — Remove by value predicate

Aggregation

• hash-append — Merge two hash tables
• hash-invert — Swap keys and values
• hash-invert-group — Invert with value grouping

Pair

Operations on (pair-t A B).

• pair-t — Pair type constructor
• make-pair — Construct a pair
• pair-first — First element
• pair-second — Second element
• pair-put-first — Replace first element
• pair-put-second — Replace second element

Maybe

Operations on (maybe-t A).

• maybe-t — Maybe type constructor
• just — Construct a present value
• nothing — Represent a missing value
• is-just — Check if just
• is-nothing — Check if nothing
• just-value — Extract value from just
• just-put-value — Replace value in just

Box

Operations on the opaque type (box-t E).

• box-t — Box type constructor
• make-box — Create an empty box
• box-is-empty — Check if empty
• box-put — Store a value
• box-get-maybe — Get value as maybe
• box-get — Get value (error if empty)

Function operations

Higher-order function manipulation.

• constant — Return first argument
• identity — Return argument unchanged
• swap — Swap function arguments
• drop — Ignore first argument
• dup — Duplicate argument

File I/O

File handle read/write operations.

Type

• file-t — File handle type

Open and close

• open-input-file — Open file for reading
• open-output-file — Open file for writing
• file-close — Close file

Read and write

• file-read — Read entire file
• file-write — Write a text
• file-writeln — Write a text with newline

Convenience

• use-input-file — Auto-closing read
• use-output-file — Auto-closing write

Standard output

• print — Print any value
• println — Print any value with newline

Path operations

Path text manipulation and file system functions.

• path-file-name — Get file name
• path-directory-name — Get directory name
• path-extension — Get file extension
• path-stem — Get file stem
• path-is-absolute — Check if absolute
• path-is-relative — Check if relative
• path-join — Join paths
• path-normalize — Normalize path
• path-relative — Compute relative path
• path-relative-to-cwd — Relative to current working directory
• path-resolve — Resolve to absolute path

Query

• path-exists — Check if path exists
• path-is-file — Check if path is a file
• path-is-directory — Check if path is a directory

Read and write

• path-read — Read file
• path-write — Write file

Directory operations

• path-list — List directory contents
• path-list-recursive — List directory recursively
• path-ensure-file — Ensure file exists
• path-ensure-directory — Ensure directory exists

Delete and rename

• path-delete-file — Delete file
• path-delete-directory — Delete empty directory
• path-delete — Delete recursively
• path-rename — Rename

Assertions

Assertion functions for testing.

• assert — Assert condition is true
• assert-not — Assert condition is false
• assert-equal — Assert two values are equal
• assert-not-equal — Assert two values are not equal

Error handling

• error — Throw an error

Process

• exit — Exit with a code
• current-directory — Get current directory
• current-command-line — Get command line after --
• current-full-command-line — Get full command line
• current-stdout-file — Get current stdout file handle
• current-stderr-file — Get current stderr file handle

Random

• random-int — Random integer
• random-float — Random float

Format

Type-specific S-expression formatting functions.

• format-as-sexp — Format an arbitrary value as an S-expression
• format-int — Format an integer
• format-float — Format a float
• format-symbol — Format a symbol
• format-bool — Format a bool
• format-text — Format a text
• format-void — Format void

S-expression

S-expression parsing, formatting, and related types.

Types

• sexp-t — Located S-expression type
• source-location-t — Source location type
• source-span-t — Source span type
• source-position-t — Source position type

Operations

• parse-sexps — Parse to located S-expressions
• format-sexp — Format an S-expression

JSON

JSON values and operations.

Type

• json-t — JSON value type

Parse and format

• parse-json — Parse a JSON text
• format-json — Format as a JSON text