std

This system is depended on by virtually all CC lisp software. It contains our standard extensions to the Lisp language and implementation, SBCL.

The only exception is cl-ppcre which is an implicit dependency of this system.

The standard library itself is the set of symbols exported by the STD package, which is a wrapper for the other standard packages.

These packages contain all the creature comforts a seasoned Lisper needs. Some symbols are re-exported from the implementation internal packages - SB-INT, SB-KERNEL, SB-C, SB-SYS, SB-UNICODE and friends. Others are ported from long-standing community favorites (aka 'blessed' packages) such as ALEXANDRIA, SERAPEUM, CL-FAD, TRIVIAL-*, etc.

We refrain from re-inventing the wheel as much as possible and in most cases a dependency on STD may act as a drop-in replacement for multiple blessed packages. We reference the original source code repositories liberally in cases of pre-existing lisp systems, but you can expect the code itself to be re-written according to our style guide and further enriched or optimized based on our own expectations.

Packages

The names of all standard packages are stored as a list in the variable std-int:*std-packages*.

std-int:*std-packages*
  • STD/DEFSYS
  • STD/OS
  • STD/FMT
  • STD/RAND
  • STD/PAR
  • STD/ASYNC
  • STD/TASK
  • STD/THREAD
  • STD/PIPE
  • STD/FILE
  • STD/PATH
  • STD/SEQ
  • STD/META
  • STD/ALIEN
  • STD/SERDE
  • STD/COMP
  • STD/BIT
  • STD/SYS
  • STD/MACS
  • STD/READTABLE
  • STD/CURRY
  • STD/HASH-TABLE
  • STD/ARRAY
  • STD/STREAM
  • STD/NUM
  • STD/STRING
  • STD/TYPE
  • STD/CONDITION
  • STD/PRIM
  • STD/LIST
  • STD/SYM

As you can see, all packages are prefixed with std followed by our standard separator /. This pattern is adhered to throughout our package and system definitions. You can expect all ASD files to have at least one 'primary' system definition followed by a 'test' system and any subsystems defined like so:

(defsystem :foo #+nil ...)
(defsystem :foo/tests #+nil ...)

All package definition files (pkg.lisp) have at least one primary or 'top-level' package (defined towards the end) preceded by any number of sub-packages:

(defpackage :foo/bar (:use :cl) #+nil ... )
(defpackage :foo/baz (:use :cl :std) #+nil ... )
(defpackage :foo (:use :cl :foo/bar :foo/baz) #+nil ... )

defpkg

You may notice in the standard library package definitions there is no direct usage of the defpackage macro, or even uiop:define-package. Instead, we rely on our own incarnation, defpkg:

(describe 'std/defpkg:defpkg)
STD/DEFPKG:DEFPKG
  [symbol]

DEFPKG names a macro:
  Lambda-list: (PACKAGE &REST CLAUSES)
  Documentation:
    Richard's Robust DEFPACKAGE macro. Based on UIOP:DEFINE-PACKAGE ymmv.
    
    DEFPKG takes a PACKAGE and a number of CLAUSES, of the form (KEYWORD . ARGS).
    
    DEFPKG supports the following standard extensions:
    USE, SHADOW, SHADOWING-IMPORT-FROM, IMPORT-FROM, EXPORT, INTERN -- as per CL:DEFPACKAGE.
    
    As well as the common extensions:
    RECYCLE, MIX, REEXPORT, UNINTERN -- as per UIOP/PACKAGE:DEFINE-PACKAGE
    
    Additionally, DEFPKG supports the following combinators:
    
    MIX-REEXPORT -- combination of MIX and REEXPORT
    
    USE-REEXPORT -- combination of USE and REEXPORT
    
    and the following custom extensions:
    
    PRELUDE -- treat the first element as the name of a 'prelude' package which
    will be defined with the remaining symbols re-exported from PACKAGE and only
    those symbols.
    
    In addition to defining and returning a package, when *DEFPKG-HOOK* is
    non-nil, it is called as a function with a single argument - the package being
    defined.
  Source file: /home/ellis/comp/core/std/defpkg.lisp

WIP defsys

The std/defsys package is the last package defined in the std system, which itself uses the much more popular ASDF.

Similarly to std/defpkg, our goal is to provide a similar interface to asdf:defsystem. As of [2025-07-04 Fri] however this interface is mostly unwritten. At some point we will take another stab at it.

sym

Symbols are quite important in Lisp and in the std/sym package you will find some important utilities for working with them.

ALIAS-FUNCTION
FORMAT-SYMBOL
VBOUNDP!
MAKE-GENSYM
GENSYMIFY*
GENSYMIFY
SYMBOLICATE
SYMB
WITH-UNIQUE-NAMES
ALIAS-MACRO
MAKE-SLOT-NAME
FBOUNDP!
ENSURE-SYMBOL
KEYWORDICATE
MAKE-KEYWORD
WITH-GENSYMS
MAKE-GENSYM-LIST
  • vboundp! and fboundp! are inspired by the c-mera library and paper, providing quite useful for source-to-source compilers.
  • alias-function and alias-macro are from the lparallel library, implemented in terms of compiler-function and macro-function respectively.
  • with-gensyms is our preferred name as opposed to with-unique-names which is already defined by the implementation. Instead of re-writing we set the macro-function of the with-gensyms symbol directly.
  • symbolicate and keywordicate are popular extensions defined by the implementation and re-exported here.

list

Lists are the most primitive as well as the most flexible sequence type available in Lisp. At run-time seasoned Lispers have a tendency to use arrays instead of large lists when performance is needed, but lists have some additional properties not shared by arrays which make them the standard for all sorts of compile-time meta-programming. For starters, lambda expressions, function calls, and all special forms may be read and written as lists.

MEMQ
CART-TYPECASE
DCAR
CIRCULAR-LIST-ERROR
NUNIONF
UNIONF
CART-CASE
CART-ECASE
ZIPRM
LET-BINDING-TRANSFORM
ENSURE-CONS
MATCH-LAMBDA-LISTS
MAPTREE
MAPCART
DELETEF
DRDC
CIRCULAR-LIST
DOPLIST
CART-ETYPECASE
PAIRS
NCONSC
LASTCAR
ASSOC-VALUE
DCONS
FLATTEN*
SAFE-ENDP
DPUSH
CIRCULAR-LIST-P
RECURSIVE-APPEND
DAPPENDF
GROUP
TOPOLOGICAL-SORT
ENSURE-CAR
APPENDF
MAPTREE-IF
ENSURE-LIST
ZIPSYM
CART
RECONS
ZIP-TREE
NCONCF
ASSQ
REVERSEF
PROPER-LIST-LENGTH
NREVERSEF
ZIP-LIST
TOPOSORT
LIST-DIMENSIONS
FLATTEN
REMOVEF
SORT!
DPOP
MERGE!
CIRCULAR-TREE-P
SET-EQUAL
DLIST
FIRSTN
SINGLETON-P
DCDR
  • dlist is an implementation of doubly-linked lists, originally inspired by matlisp. The vocabluarly includes dcons, dpush, dpop, drdc, dcdr, dcar, and dappendf.
  • toposort is a variant on topological-sort also defined in matlisp.
  • common functions and macros from alexandria and serapeum
  • merge! and sort! from cl-bench
  • list utils from Let over Lambda and On Lisp

prim

Some useful primitives which don't have a clear home package are defined in std/prim.

USING-GENSYMS
DEFNOTINLINE
BINDING-GENSYMS
G!-SYMBOL-P
MACROFY
WITH-MARKING
WITH-OPTIMIZATION
DEFMACRO!
DEFUN!
O!-SYMBOL-TO-G!-SYMBOL
DEFMACRO/G!
UNQUOTE-ARGS
DEFINLINE
O!-SYMBOL-P
  • definline is one of the most commonly used exports - as the name suggests it defines a function which is automatically declaimed inline.

condition

Standard utilities for defining and handling conditions can be found in std/condition.

DEF-WARNING-REPORTER
META-CONDITION
DEFINE-ERROR-REPORTER
UNKNOWN-TOKEN
DEF-SIMPLE-ERROR-REPORTER
WRAPPED-CONDITION-VALUE
ERROR-MESSAGE
DEFWARNING
UNKNOWN-ARGUMENT
WRAP-ERROR
DEFERROR
WRAP-CONDITION
UNWIND-PROTECT-CASE
HANDLERS
ERROR-ITEM
ERROR-REASON
SIMPLE-PROGRAM-ERROR
DEF-SIMPLE-WARNING-REPORTER
STD-WARNING
INVALID-ARGUMENT
WRAPPED-CONDITION
ERROR-NAME
CIRCULAR-DEPENDENCIES
CONDITION-HANDLER
ERROR-MESSAGE
ERROR-ITEMS
MISSING-METHODS
SIMPLE-READER-ERROR
IGNORE-SOME-CONDITIONS
MISSING-ARGUMENT
NYI!
ERROR-KIND
STD-ERROR
SIMPLE-STYLE-WARNING
WRAPPED-ERROR
CONFLICTING-ARGUMENTS
REQUIRED-ARGUMENT
MISSING-METHOD
SIMPLE-PARSE-ERROR

type

std/type provides definitions for common types not covered in the ANSI CL standard.

NEGATIVE-INTEGER
NON-POSITIVE-REAL-P
POSITIVE-FIXNUM-P
NON-NEGATIVE-RATIONAL
NEGATIVE-INTEGER-P
TYPE-CACHE-NONCE
NON-NEGATIVE-SINGLE-FLOAT-P
POSITIVE-DOUBLE-FLOAT
MAKE-TYPE-CLASS
TYPE-CLASS-NAME
NON-NEGATIVE-FLOAT
NEGATIVE-FLOAT-P
TYPE-CLASS-OF
ARRAY-INDEX
NON-POSITIVE-INTEGER-P
NON-NEGATIVE-FIXNUM
NON-POSITIVE-FLOAT-P
NEGATIVE-RATIONAL-P
TYPE-ID->TYPE-CLASS
POSITIVE-SINGLE-FLOAT
NEGATIVE-REAL-P
POSITIVE-FLOAT-P
POSITIVE-RATIONAL-P
POSITIVE-FLOAT
POSITIVE-INTEGER
POSITIVE-FIXNUM
NEGATIVE-DOUBLE-FLOAT-P
POSITIVE-SHORT-FLOAT-P
NON-POSITIVE-FIXNUM-P
TYPE-CLASS-NAME-OF
INTEGER-TYPE-LENGTH
OCTET
TYPE-HASH-VALUE
NON-NEGATIVE-LONG-FLOAT
NEGATIVE-SHORT-FLOAT
NON-NEGATIVE-REAL-P
NON-NEGATIVE-FLOAT-P
TYPE-CLASSES
NEGATIVE-SHORT-FLOAT-P
NON-POSITIVE-SHORT-FLOAT-P
NEGATIVE-REAL
POSITIVE-SHORT-FLOAT
NON-NEGATIVE-SINGLE-FLOAT
NON-NEGATIVE-SHORT-FLOAT
NEGATIVE-LONG-FLOAT-P
NON-NEGATIVE-RATIONAL-P
NON-NEGATIVE-INTEGER
POSITIVE-SINGLE-FLOAT-P
NEGATIVE-RATIONAL
NON-POSITIVE-FIXNUM
NON-NEGATIVE-DOUBLE-FLOAT-P
OF-TYPE
NON-NEGATIVE-INTEGER-P
NON-NEGATIVE-DOUBLE-FLOAT
POSITIVE-REAL
NEGATIVE-SINGLE-FLOAT-P
NON-POSITIVE-LONG-FLOAT-P
POSITIVE-DOUBLE-FLOAT-P
NON-POSITIVE-REAL
CLASSOID-OF
CTYPE-HASHSETS
POSITIVE-INTEGER-P
NEGATIVE-FIXNUM-P
UNSIGNED-BYTE*
NON-NEGATIVE-REAL
NON-POSITIVE-FLOAT
CLASSOID
NON-POSITIVE-DOUBLE-FLOAT-P
NEGATIVE-LONG-FLOAT
TYPE-CLASS-ID
NON-POSITIVE-DOUBLE-FLOAT
POSITIVE-LONG-FLOAT
TYPE-CLASS
NON-POSITIVE-INTEGER
NON-POSITIVE-LONG-FLOAT
NON-POSITIVE-RATIONAL
DEFAULT-ELEMENT-TYPE
NON-POSITIVE-RATIONAL-P
COERCEF
NON-NEGATIVE-LONG-FLOAT-P
POSITIVE-REAL-P
NEGATIVE-FLOAT
POSITIVE-RATIONAL
NEGATIVE-DOUBLE-FLOAT
FIND-CLASSOID
ARRAY-LENGTH
NON-POSITIVE-SINGLE-FLOAT-P
OCTET-VECTOR
NON-POSITIVE-SINGLE-FLOAT
NON-NEGATIVE-FIXNUM-P
TYPE-CLASS-ID-OF
POSITIVE-LONG-FLOAT-P
NEGATIVE-SINGLE-FLOAT
TYPE=
NEGATIVE-FIXNUM
OCTET-VECTOR-P
LAYOUT-OF
NON-NEGATIVE-SHORT-FLOAT-P
NON-POSITIVE-SHORT-FLOAT
WORD
  • most of CDR5 is implemented except RATIO-related definitions

num

Standard numeric utilities are provided by std/num. This package spans multiple files covering specific features.

READ-LEB128
ENCODE-FLOAT32
ENCODE-ULEB128
BINOMIAL-COEFFICIENT
COUNT-PERMUTATIONS
MAP-IOTA
ENCODE-LEB128
ENCODE-FLOAT64
DECODE-FLOAT32
STANDARD-DEVIATION
%LERP
MAKE-FLOAT-CONVERTERS
DECODE-LEB128
POWER-OF-TWO-P
INVALID-NUMBER-VALUE
FACTORIAL
INVALID-NUMBER-REASON
DECODE-FLOAT64
GAUSSIAN-RANDOM
%MEAN
%MEDIAN
INVALID-NUMBER
VARIANCE
POWER-OF-TWO-CEILING
CLAMP
PARSE-REAL-NUMBER
PARSE-POSITIVE-REAL-NUMBER
MAXF
MINF
SUBFACTORIAL
PARSE-NUMBER
DECODE-ULEB128
READ-ULEB128
IOTA
  • utilities from alexandria/numbers
  • number parsing functions: parse-number, parse-integers, parse-real-number, parse-positive-real-number
  • floating-point encoding/decoding: decode-float32, decode-float64, encode-float32, and encode-float64
  • u/leb128 encoding/decoding: read-leb128, encode-leb128, encode-uleb128, decode-leb128, and decode-uleb128

stream

std/stream constains our standard set of stream definitions.

READ-UNTIL-END
STREAM-OF
WRAPPED-STREAM-P
READ-LISP-UNTIL-END
COUNTING-CHARACTER-INPUT-STREAM
COL-INDEX-OF
COL-COUNT-OF
WRAPPED-STREAM
CHAR-COUNT-OF
PREFIX-OF
WRITE-PREFIX
WITH-INPUT-FROM-FILE
PREFIXED-CHARACTER-OUTPUT-STREAM
WRAPPED-CHARACTER-INPUT-STREAM
PREV-COL-COUNT-OF
WITH-OUTPUT-TO-FILE
LINE-COUNT-OF
COPY-STREAM
WRAPPED-CHARACTER-OUTPUT-STREAM
  • wrapped-stream implements the standard 'transparent' stream interface used as a superclass by other stream classes. The stream slot is accessible via the generic stream-of.

array

WITH-ARRAY-DATA
VECTOR-FOLDR
VECTOR-MIN
VECTOR-PUSH-EXTEND-POSITION
VECTORIFY
SIMPLIFY-ARRAY
COPY-VECTOR-TO-LIST
VECTOR-EQ
ARRAY-SHIFT
VECTOR-FOLDL
VECTOR-TO-LIST
MAKE-ARRAY-ALLOCATOR
VECTOR-MAX
COPY-ARRAY
VECTOR-MAP-FOLDR
SIGNED-ARRAY-LENGTH
VECTOR-POP-POSITION
VECTOR-MAP-FOLDL
MODPROJ
ARRAY-RANK-LIMIT
  • implementation re-exports including with-array-data

hash-table

Hash-tables in Lisp are the O(1) older brother of alists and plists. Sometimes it is convenient to use the cons-based siblings, but for most instance of key -> value pairs you're better off with a hash-table. std/hash-table provides some utilities for working with them.

HASH-TABLE-KEYS
TABLE
DJB
MAPHASH-VALUES
HASH-TABLE-ALIST
POPHASH
HASH-TABLE-PLIST
DUMB-STRING-HASH
HASH-OBJECT
HASH-TABLE-VALUES
PLIST-HASH-TABLE
GLOBAL-HASHER
HASH-OBJECT-ADDRESS
GLOBAL-HASH
ENSURE-GETHASH
MAPHASH-KEYS
ALIST-HASH-TABLE

curry

Currying is a popular paradigm in pure(r) functional programming languages such as Haskell. std/curry provides such functional composition primitives.

ENSURE-FUNCTIONF
MULTIPLE-VALUE-COMPOSE
ENSURE-FUNCTION
MAP-PRODUCT
DISJOIN
CURRY
CONJOIN
COMPOSE
RCURRY

readtable

[-reader
{-reader
#f-reader
_
SUBST-MODE-PPCRE-LAMBDA-FORM
#`-reader
#~-reader
#$-reader
#"-reader
MATCH-MODE-PPCRE-LAMBDA-FORM
SEGMENT-READER
#l-reader

macs

Standard macros are defined in std/macs.

DOLLAR-SYMBOL-P
DLAMBDA
PANDORICLET
DEFINE-CLASS
DESTRUCTURING-CASE
WHEN-LET*
DESTRUCTURING-ECASE
DEFINE-CONSTANT
ALET
DEFCLASS*
PANDORIC-EVAL
SWITCH
LETY
NESTED-LOOP
DEFVAR-UNBOUND
COMPILE-AND-EVAL
IF*
DEF!
COLLECT
COLLECTING
IF-LET*
GET-PANDORIC
%P
ONCE-ONLY
ALAMBDA
PLAMBDA
ACASE
COMPILE-AND-EVAL*
DEFUNITS
IF-MATCH
DISTANCE-DESIGNATOR
UNIT-OF-DISTANCE
LETV*
XOR
WHEN-LET
%A
PANDORIC-RECODE
NLET-TAIL
IT
IFRET
DLET
COMPILE-AND-LOAD
WHEN-MATCH
ALET*
ESWITCH
AIF
PANDORICLET-GET
PANDORICLET-SET
LETY*
UNTIL
DESTRUCTURING-CCASE
AWHEN
CSWITCH
SORTF
EVAL-ALWAYS
ACOND
WITH-COLLECTORS
MAKE-MACRO-LAMBDA
ACOND2
WITH-PANDORIC
BUILD-BATCHER-SN
IF-LET
PARSE-LAMBDA-LIST
NAMED-LAMBDA

sys

EXTERNAL-FORMATS
AUGMENT-ENVIRONMENT
HOOKS
READ-ONLY-SPACE-OBJ-P
CPUID
LOGICAL-HOSTS
DO-INTERNAL-SYMBOLS
N-WORD-BYTES
HEXDUMP
FOLD-IDENTICAL-CODE
FASL-FILE-TYPE
FINALIZER-THREAD
MAP-ALLOCATED-OBJECTS
LIST-ALLOCATED-OBJECTS
SAVE-LISP-TREE-SHAKE-AND-DIE
REFERENCES-P
PRINT-ALLOCATED-OBJECTS
UNTRACE-PACKAGE
WIDETAG-MASK
GET-ASM-ROUTINE
CURRENT-SP
DEFAULT-GC-STRATEGY
WORD-SHIFT
REVIVE-IMAGE
FUNCTION-INFORMATION
LOWTAG-LIMIT
PARSE-MACRO
CANCEL-FINALIZATION
CURRENT-LISP-IMPLEMENTATION
DEFGLOBAL
DYNAMIC-SPACE-OBJ-P
.I
LDB-MONITOR
COMPILE-LISP
LOWTAG-OF
LIST-PACKAGE-SYMBOLS
32-BIT-P
ASSEMBLER-ROUTINES
SOURCE-LOCATION
CURRENT-FP
FASL-FILE-VERSION
DEFINE-LOGICAL-PATHNAME
FSET
UNTRACE-ALL
FUN-SIGNATURE=
GET-EXTERNAL-FORMAT
INFO-TYPES
N-LOWTAG-BITS
WITH-COUNTDOWN
WITH-PINNED-OBJECTS
MAKE-LOGICAL-HOST
MACROEXPAND-ALL
LOWTAG-MASK
LOOP-STANDARD-EXPANSION
FINALIZE
LINKAGE-NAME-MAP
NAME-RESERVED-BY-ANSI-P
LEXENV-FIND
DECLARATION-INFORMATION
FORGET-SHARED-OBJECTS
PACKAGE-SYMBOL-NAMES
LIST-ALL-SYMBOLS
DEFINE-DECLARATION
LOGICAL-HOST
SHOW-INFO
DEFINE-LOAD-TIME-GLOBAL
WITHOUT-FP-TRAPS
MEMORY-USAGE
HEXDUMP-OBJECT
N-FIXNUM-BITS
MAP-IMMOBILE-OBJECTS
DEFAULT-ARENA-SIZE
ASM-ROUTINE-INDEX-FROM-ADDR
64-BIT-P
REGISTER-PROJECT-DIRECTORY
PACKAGE-SYMBOLS
TIME-REMAINING
SAVE-SHARED-OBJECTS
COMPILER-LET
FORGET-SHARED-OBJECT
DEFPRINTER
MOST-POSITIVE-WORD
WIDETAG-OF
VARIABLE-INFORMATION
FIXNUM-TAG-MASK
GENERATION-OF
INT-SAP
INFO
SHOW-CTYPE-CTOR-CACHE-METRICS
LITTLE-ENDIAN-P
CURRENT-MACHINE
MAKE-NULL-LEXENV
CPU-VENDOR
GET-LISP-OBJ-ADDRESS
SHOW-FINALIZERS
LOGICAL-HOST-NAMES
LOOPS-ANSI-UNIVERSE
N-WIDETAG-BITS
LEXENV-USER-DATA
N-MACHINE-WORD-BYTES
MAYBE-INLINE
GET-REAL-TIME-SECONDS
TUNE-IMAGE-FOR-DUMP
ENCLOSE
SHAKE-PACKAGES
N-FIXNUM-TAG-BITS
PARSE-EVAL-WHEN-SITUATIONS
BACKEND-BYTE-ORDER

bit

BITFIELD-SLOT-END
BITFIELD-SLOT-UNPACK
BITFIELD-SLOT-NAME
INTEGER-TO-OCTETS-LE
BITFIELD-BOOLEAN-SLOT
BITFIELD-INTEGER-SLOT
OCTETS
OCTET-VECTOR-TO-HEX-STRING
SIGN-BIT
OCTETS-TO-INTEGER
MORTIFY-BITS
BITFIELD-SLOT-PACK
DEFINE-BITFIELD
HEX-STRING-TO-OCTET-VECTOR
PARSE-ATOMIC-BITFIELD-SLOT-SPECIFIER
LOGBIT
BITFIELD-SLOT-START
BITFIELD-MEMBER-SLOT
HEXCHAR-TO-INT
BITFIELD-SLOT
DIFFERENT-SIGNS-P
PARSE-COMPOUND-BITFIELD-SLOT-SPECIFIER
BITFIELD-SLOT-SIZE
MAKE-BIT-VECTOR
WRITE-LITTLE-ENDIAN
BITFIELD-SLOT-INITFORM
MAKE-BITS
OCTETS-TO-INTEGER-LE
MAKE-OCTETS
READ-LITTLE-ENDIAN
AREF-BIT
INTEGER-TO-OCTETS
INT-LIST-BITS
READ-N-BYTES
BITFIELD

comp

PRIMITIVE-TYPE-NAME-OF
BACKEND-SC-NAMES
BACKEND-PRIMITIVE-TYPE-ALIASES
INST*
COMPILE-COMPONENT
BACKEND-SBS
PRIMITIVE-TYPE
VOP
COMPILER-PRINT-VARIABLE-ALIST
EMIT-CFASL
BACKEND-PRIMITIVE-TYPE-NAMES
PRIMITIVE-OBJECTS
EMIT
INST
CTYPE-ARRAY-DIMENSIONS
DEFINE-SOURCE-TRANSFORM
BACKEND-SC-NUMBERS
DESCRIBE-IR2-COMPONENT
MAKE-LISP-SOURCE-INFO
VOP*
DEFKNOWN
WITHOUT-SCHEDULING
REGISTER-ARG-TNS
CTYPECASE
BACKEND-TYPE-PREDICATES
PRIMITIVE-OBJECT-WIDETAG
PRIMITIVE-OBJECT-NAME
PRIMITIVE-TYPE-OF
MAKE-FILE-SOURCE-INFO
COMPILE-COMPONENT-HOOK
ASSEMBLE
DEFOPTIMIZER
BACKEND-PREDICATE-TYPES
PRIMITIVE-OBJECT-LOWTAG
COMPILATION-UNIT
CTYPEP
PRIMITIVE-TYPE-NAME
DUMP-SYMBOLIC-ASM
COMPILE-PROGRESS
BOXED-IMMEDIATE-SC-P
INLINE-VOP
DEF-IR1-TRANSLATOR
IMMEDIATE-CONSTANT-SC
DEFINE-VOP
DEFTRANSFORM
DESCRIBE-COMPONENT
PARSE-DEFTRANSFORM

serde

SERDE-ERROR
SERIALIZABLE-P
PRIMITIVE-OBJECT-TABLE
SER
DE
DEFINE-IO
DESERIALIZE
SIMPLE-OBJECTS
CORE-OBJECT-TABLE
PRIM-TYPE
SERDE-CONDITION
DESERIALIZER-ERROR
DESERIALIZABLE-P
SERDE
SERIALIZE
SERIALIZER-ERROR
(generic-function-methods (function serialize))
(#<STANDARD-METHOD STD/SERDE:SERIALIZE (BOX/IGNITION:IGNITION-CONFIG
                                        (EQL :IGNITION)) {121961B023}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (POD:CONTAINERFILE
                                        (EQL :BYTES)) {120F20F7B3}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (POD:CONTAINERFILE
                                        (EQL :STRING)) {120F20F223}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (NET/CODEC/TLV:TLV
                                        (EQL :STRING)) {120526ED53}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (NET/CODEC/TLV:TLV
                                        (EQL :BYTES)) {120526ECB3}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (ORGAN/GRAPH:ORG-GRAPH T) {12052389B3}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (STRING (EQL :QRCODE)) {1204DD2A03}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (DAT/TOML:TOML-TABLE
                                        (EQL :TOML)) {1204B57103}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (T (EQL :XML)) {121A80A6F3}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (T (EQL :JSON)) {121A3C3E33}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (VECTOR (EQL :CSV)) {121A2C5E93}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (OBJ/GRAPH:GRAPH
                                        (EQL :DOT)) {121A2938D3}>
 #<STANDARD-METHOD STD/SERDE:SERIALIZE (T (EQL :SXP)) {121A24A4D3}>)
(generic-function-methods (function deserialize))
(#<STANDARD-METHOD STD/SERDE:DESERIALIZE (PATHNAME
                                          (EQL :PKGBUILD)) {1223AA4663}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (T (EQL :IGNITION)) {1219618403}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (PATHNAME
                                          (EQL :CONTAINERFILE)) {120F20EC83}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (T (EQL :OPENAPI)) {1210CCC7A3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (DAT/JSON:JSON-OBJECT
                                          (EQL :OPENAPI)) {1210CCB883}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STREAM (EQL :TLV)) {120526EF33}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (SIMPLE-ARRAY
                                          (EQL :TLV)) {120526EE93}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STRING (EQL :AUTHINFO)) {1205187843}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (PATHNAME
                                          (EQL :AUTHINFO)) {12051877A3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (T
                                          (EQL :DNSMASQ-CONFIG)) {1204D83EA3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (T (EQL :PACMAN-CONFIG)) {1204AF2E83}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STREAM (EQL :TOML)) {1204B572E3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STRING (EQL :TOML)) {1204B57243}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (PATHNAME (EQL :TOML)) {1204B571A3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (T (EQL :DESKTOP-ENTRY)) {1204B55B33}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (PATHNAME (EQL :INI)) {1204B54DA3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STRING (EQL :INI)) {1204B54D03}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STREAM (EQL :INI)) {1204B54C63}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (T (EQL :HTML)) {1204B50243}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (PATHNAME (EQL :XML)) {121A80A0E3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STREAM (EQL :XML)) {121A809AD3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STRING (EQL :XML)) {121A809263}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (T (EQL :JSON-SCHEMA)) {121A465253}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (DAT/JSON:JSON-OBJECT
                                          (EQL :JSON-SCHEMA)) {121A464C33}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STREAM (EQL :JSON)) {121A3C3813}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (PATHNAME (EQL :JSON)) {121A3C30F3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STRING (EQL :JSON)) {121A3C2A13}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STRING (EQL :CSV)) {121A2C74C3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (T (EQL :CSV)) {121A2C6BB3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (PATHNAME (EQL :CSV)) {121A2C64A3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STRING (EQL :DOT)) {121A293EF3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (PATHNAME (EQL :SXP)) {121A24BF03}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STREAM (EQL :SXP)) {121A24B6C3}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (STRING (EQL :SXP)) {121A24AF03}>
 #<STANDARD-METHOD STD/SERDE:DESERIALIZE (T (EQL :ASN1)) {121A19B023}>)

alien

READ-ALIEN-SIGNED-BYTE-64
LOFF-T
CLONE-OCTET-VECTOR-LIST*
READ-ALIEN-SIGNED-BYTE-32
WRITE-ALIEN
TIMEVAL
SHARED-OBJECT-NAME
OCTET-VECTOR-POINTER
CLONE-OCTETS-TO-ALIEN
READ-ALIEN
LINKAGE-INFO
COPY-C-STRING
DEFINE-OPAQUE
NUM-CPUS
FOREIGN-INT-TO-INTEGER
MEMCPY
READ-ALIEN-SINGLE-FLOAT
WRITE-ALIEN-UNSIGNED-BYTE-32
POSIX-MEMALIGN
PID-T
SHARED-OBJECTS
PULL-SAP*
OFFSET-CHAR-POINTER
WRITE-ALIEN-DOUBLE-FLOAT
WRITE-ALIEN-FIXNUM
WRITE-ALIEN-SIGNED-BYTE-32
DEFAR
SAP
DEFINE-ALIEN-LOADER
CLONE-STRINGS
PUSH-SAP*
CLONE-OCTET-VECTOR-LIST
MEMSET
CPUS
WITH-ALIEN-SLOTS
CLONE-OCTETS-FROM-ALIEN
BOOL-TO-FOREIGN-INT
ALIEN-OR-LISP-OCTETS
READ-ALIEN-UNSIGNED-BYTE-64
UID-T
WRITE-ALIEN-SINGLE-FLOAT
READ-ALIEN-DOUBLE-FLOAT
READ-ALIEN-FIXNUM
DOUBLE-ARRAY-POINTER
FOREIGN-FREE
DEFINE-ALIEN-ENUM
READ-ALIEN-UNSIGNED-BYTE-32
FREE
FLOAT-ARRAY-POINTER
C-STRINGS-TO-STRING-LIST
TIMESPEC
PULL-SAP
FOREIGN-INT-TO-BOOL
LIST-ALL-SHARED-OBJECTS
OCTETS-TO-ALIEN
GID-T
WRITE-ALIEN-SIGNED-BYTE-64
SETFA
FOREIGN-ALLOC
WRITE-ALIEN-UNSIGNED-BYTE-64
WITH-VECTOR-SAP
OCTETS-TO-ALIEN-ARRAY
CLONE-INTEGER-LIST
PUSH-SAP

meta

WITH-FSLOTS
CLASS-DIRECT-SUPERCLASSES
SPECIALIZER-DIRECT-GENERIC-FUNCTIONS
COPY-OBJECT
STANDARD-GENERIC-FUNCTION
T
STANDARD-OBJECT
REMOVE-DIRECT-METHOD
CLASS-PRECEDENCE-LIST
ENSURE-GENERIC-FUNCTION
GENERIC-FUNCTION-METHOD-COMBINATION
STANDARD-METHOD
DEFACCESSOR
CLASS
DIRECT-SLOT-DEFINITION
SLOT-DEFINITION-WRITERS
COMPUTE-EFFECTIVE-SLOT-DEFINITION
LIST-SLOT-VALUES-USING-CLASS
ADD-METHOD
EXPLORE
MAKE-INSTANCE
READER-METHOD-CLASS
SLOT-DEFINITION-LOCATION
ENSURE-CLASS-USING-CLASS
SLOT-DEFINITION-TYPE
GENERIC-FUNCTION-METHOD-CLASS
ACCESSOR-METHOD-SLOT-DEFINITION
ADD-DIRECT-SUBCLASS
EFFECTIVE-SLOT-DEFINITION
STARTED-P
REMOVE-DIRECT-SUBCLASS
STANDARD-EFFECTIVE-SLOT-DEFINITION
COMPUTE-CLASS-PRECEDENCE-LIST
CLASS-DEFAULT-INITARGS
FUNCALLABLE-STANDARD-OBJECT
WRITER-METHOD-CLASS
SLOT-DEFINITION-ALLOCATION
MAKE-METHOD-LAMBDA
GENERIC-FUNCTION
CLASS-DIRECT-SUBCLASSES
SPECIALIZER-DIRECT-METHODS
GENERIC-FUNCTION-METHODS
METHOD-COMBINATION
MAP-DEPENDENTS
REMOVE-METHOD
UPDATE-DEPENDENT
NAME
SLOT-DEFINITION-INITARGS
EXEC
STOPPED-P
COMPUTE-APPLICABLE-METHODS
METHOD-FUNCTION
SUBCLASSP
BUILT-IN-CLASS
COMPUTE-SLOTS
GENERIC-FUNCTION-LAMBDA-LIST
STANDARD-WRITER-METHOD
CLASS-SLOTS
SHUTDOWN
LOCK
DEFCLASS!
CLASS-NAME
STANDARD-ACCESSOR-METHOD
DATA
STATUS
ENSURE-FINALIZED
RUN-OBJECT
METHOD
METHOD-GENERIC-FUNCTION
SLOT-BOUNDP*
METAOBJECT
EXTRACT-SPECIALIZER-NAMES
STANDARD-CLASS
STANDARD-READER-METHOD
ENSURE-GENERIC-FUNCTION-USING-CLASS
LIST-CLASS-METHODS
GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER
RESET
CLASS-DIRECT-DEFAULT-INITARGS
SLOT-DEFINITION-READERS
SPECIALIZER
FUNCTION
STANDARD-DIRECT-SLOT-DEFINITION
ENSURE-CLASS
SLOT-MAKUNBOUND-USING-CLASS
DEFMETHODS
SLOT-DEFINITION-INITFUNCTION
FORWARD-REFERENCED-CLASS
STANDARD-INSTANCE-ACCESS
ALLOCATE-INSTANCE
SHALLOW-COPY-OBJECT
WRITE-OBJECT
INTERN-EQL-SPECIALIZER
ADD-DIRECT-METHOD
EFFECTIVE-SLOT-DEFINITION-CLASS
CLASS-FINALIZED-P
EXTRACT-LAMBDA-LIST
FINALIZE-INHERITANCE
GENERIC-FUNCTION-DECLARATIONS
COMPUTE-DISCRIMINATING-FUNCTION
SAFE-SUPERCLASSES
SLOT-DEFINITION-NAME
FUNCALLABLE-STANDARD-INSTANCE-ACCESS
SLOT-VALUE-USING-CLASS
METHOD-SPECIALIZERS
VERSION
VALIDATE-SUPERCLASS
UPGRADE
REMOVE-DEPENDENT
FUNCALLABLE-STANDARD-CLASS
EQL-SPECIALIZER
CLASS-PROTOTYPE
STANDARD-SLOT-DEFINITION
GENERIC-FUNCTION-NAME
ADD-DEPENDENT
EQL-SPECIALIZER-OBJECT
METHOD-QUALIFIERS
METHOD-LAMBDA-LIST
COMPUTE-EFFECTIVE-METHOD
LIST-CLASS-SLOTS
DEFACCESSOR*
SLOT-DEFINITION-INITFORM
CLASS-DIRECT-SLOTS
COMPUTE-APPLICABLE-METHODS-USING-CLASSES
STOP
BIND
SLOT-BOUNDP-USING-CLASS
SET-FUNCALLABLE-INSTANCE-FUNCTION
SLOT-DEFINITION
DIRECT-SLOT-DEFINITION-CLASS
COMPUTE-DEFAULT-INITARGS
FIND-METHOD-COMBINATION
VALIDATE
SLOT-VALUES
START
TAGS

seq

RAW-QUEUE-EMPTY-P
MAKE-QUEUE
WITH-ITER
RAW-QUEUE-COUNT
ITER
RAW-QUEUE-FULL-P
PEEK-CONS-QUEUE
MAKE-CONS-QUEUE
TRY-POP-QUEUE
QUEUE-FULL-P
PEEK-SPIN-QUEUE
ACCUMULATOR
SEQUENCEP
SPLIT-SEQUENCE-IF
QUEUE-COUNT*
CALL-WITH-QUEUE-LOCK
STARTS-WITH-ONE-OF-P
POP-RAW-QUEUE
PUSH-SPIN-QUEUE
VAL
KEY
QUEUE
PEEK-RAW-QUEUE
VECTOR-QUEUE
SEEK-TO-LAST
SPIN-QUEUE-COUNT
RAW-QUEUE-CAPACITY
PUSH-QUEUE
POP-CONS-QUEUE
WITH-QUEUE-LOCK
ITER
MAKE-SPIN-QUEUE
ACCUMULATED
SPLIT-SEQUENCE-IF-NOT
PUSH-QUEUE*
PEEK-QUEUE
QUEUE-FULL-P*
CONS-QUEUE-EMPTY-P
INC-COUNTER
POP-QUEUE*
MAKE-PRIORITY-QUEUE
MAKE-RAW-QUEUE
QUEUE-EMPTY-P
COUNTER
MAKE-COUNTER
COPY-N
POP-PRIORITY-QUEUE
SPIN-QUEUE-EMPTY-P
RAW-QUEUE
IDX
BASIC-QUEUE
PEEK-QUEUE*
DEFAULT-PRIORITY-QUEUE-SIZE
PUSH-PRIORITY-QUEUE
ITERATOR
TAKE*
MAX-ACCUMULATOR
MAKE-SPIN-LOCK
ENDS-WITH-SUBSEQ
CONS-QUEUE
SPIN-QUEUE
QUEUE-COUNT
NEXT
NTH-VALUE-OR
SEEK
DEFAULT-PRIORITY
SEEK-TO-FIRST
COUNTER-VALUE
PREV
PRIORITY-QUEUE
QUEUE-EMPTY-P*
STARTS-WITH
POP-QUEUE
ITER-VALID-P
STARTS-WITH-SUBSEQ
POP-SPIN-QUEUE
SPLIT-SEQUENCE
ACCUMULATE
MIN-ACCUMULATOR
DEC-COUNTER
SEEK-FOR-PREV
STARTS-WITH-P
TRY-POP-QUEUE*
TAKE
PUSH-CONS-QUEUE

thread

THREAD-DEADLOCK
RETURN-FROM-THREAD
DESTROY-THREAD
JOIN-WORKER
%DISPOSE-THREAD-STRUCTS
THREAD-YIELD
MAKE-MUTEX
WORKERS
TRY-RECEIVE-RESULT
ORACLE
THREAD-SUPPORT-P
THREAD-EPHEMERAL-P
CHANNEL-POOL
AVL-FIND<=
CURRENT-THREAD
RWLOCK-RDLOCK
DEFAULT-SPECIAL-BINDINGS
SEMAPHORE-NOTIFICATION
CURRENT-THREAD-SAP
INTERRUPT-THREAD-ERROR
GET-SPINLOCK
CLEAR-SEMAPHORE-NOTIFICATION
HANG
THREAD-POOL
CONDITION-WAIT*
KILL-WORKER
MUTEX-NAME
WAITQUEUE
WORKER
RESET-ALLOCATOR-HISTOGRAM
%THREAD-LOCAL-REFERENCES
THREAD-COUNT
WITH-DEATHLOK
SYNC-MESSAGE
WITH-SESSION-LOCK
CHANNEL
SYMBOL-VALUE-IN-THREAD
RELEASE-SPINLOCK
WORKER-RESTARTS
JOIN-THREAD-ERROR
KERNEL
BARRIER
MAKE-WORKERS
MAKE-RWLOCK
DUMP-THREAD
THREAD
FIND-THREAD-POOL
FIND-THREAD
RECEIVE-RESULT
WITH-DEFAULT-SPECIAL-BINDINGS
ABORT-THREAD
MAKE-THREAD
MAIN-THREAD-P
FIND-THREAD-BY-ID
COMPUTE-SPECIAL-BINDINGS
PRINT-ALLOCATOR-HISTOGRAM
POOL-KERNEL
MUTEX-OWNER
DEFKERNEL
MAKE-SEMAPHORE-NOTIFICATION
FIND-WORK
SEMAPHORE-COUNT
WITH-SYNC-MESSAGE
DEFAULT-SPINT-COUNT
INTERRUPT-THREAD
SUBMIT-WORK
SCHEDULE
SEMAPHORE
WITH-NEW-SESSION
SEMAPHORE-NAME
SIGNAL-SEMAPHORE
LIST-ALL-THREADS
WORK
SPINLOCK
CONDITION-NOTIFY
WORKER-THREADS
RUN-THREAD
MAKE-FOREIGN-THREAD
MAKE-ORACLE
DO-WORKERS
WAIT-FOR-THREADS
TERMINATE-THREAD
KERNEL
CHECK-THREAD-POOL
SCHEDULER
PRINTLN-TOP-LEVEL
RWLOCK-WRLOCK
THREAD-OS-TID
RELEASE-MUTEX
THREAD-DEADLOCK-CYCLE
JOIN-THREAD-ERROR-THREAD
WORKER-CLASS
THREAD-ERROR
KILL-THREAD
WITH-THREADS
RELEASE-FOREGROUND
WITH-THREAD
AVLTREE-LIST
PRINT-TOP-LEVEL
WORKER-INDEX*
WORKER-INDEX
RWLOCK-UNLOCK
CONDITION-BROADCAST
KERNEL-OBJECT
STANDARD-IO-BINDINGS
END-THREAD-POOL
WITH-MUTEX
BROADCAST-WORK
SUPER-THREADS
FUTEX-WAKE
TIMED-JOIN-THREAD
INTERRUPT-THREAD-ERROR-THREAD
AVL-FIND>=
WORKER
MUTEX-VALUE
GRAB-MUTEX
THREAD-ALIVE-P
DESIGNATE-ORACLE
GET-MUTEX
THREAD-ID-LIST
THREAD-ERROR-THREAD
MAKE-WAITQUEUE
CHANNEL-QUEUE
MAKE-THREADS
CHANNEL-KERNEL-FUNCTION
ORACLE-TABLE
WORKER-THREAD
WORKER-COUNT*
POOL-KERNEL-FUNCTION
WORKER-COUNT
MAKE-THREAD-POOL
TRY-SEMAPHORE
KERNEL-FUNCTION
THREAD-POOL-TABLE
WORKER-KERNEL
WAIT-FOR-WORKER
SEMAPHORE-NOTIFICATION-STATUS
JOIN-THREAD
MAIN-THREAD
WITH-SPINLOCK
ALLOCATOR-HISTOGRAM
MAKE-WORKER
SHUTDOWN-CHANNEL
START-WORKER
FOREIGN-THREAD
THREAD-POOL
FINISH-THREADS
JOIN-THREAD-PROBLEM
MAKE-SEMAPHORE
THREAD-NAME
WITH-RECURSIVE-LOCK
CONDITION-WAIT
CHECK-KERNEL
ALL-THREADS
ORACLE-ID
INTERRUPT-HANDLER
SYMBOL-VALUE-IN-THREAD-ERROR
HOLDING-MUTEX-P
RUN-WORKER
MAKE-LISTENER-THREAD
MUTEX
GET-FOREGROUND
WORKER-KERNEL-FUNCTION
WAIT-ON-SEMAPHORE
WAITQUEUE-NAME

task

TASK-CLASS
TASK-SCHEDULE
RESULTS
TASK
MAKE-JOB
MAKE-TASK-POOL
SCHEDULED-TASK
DEFINE-TASK-KERNEL
KILL-WORKERS
START-TASK-WORKERS
JOB
START-TASK-WORKER
POP-WORKER
RESULT
WITH-TASK-POOL
JOBP
TASKS
TASKS
TASK-PRIORITY
JOBS
JOBS
TASKP
STAGES
TASK
TASK-POOL
PUSH-WORKER

async

PROMISE
FULFILL
FUTURE
AWAIT
WHILE-WAITING-FOR
FULFILLEDP

par

rand

RANDOM-BYTES
RANDOM-CHAR
RANDOM-ELT
RANDOM-CHARS
RANDOM-REF
RANDOM-BOOLEANS
RANDOM-DO

fmt

std/fmt contains a variety of format and print-related functions, including basic text drawing primitives.

(smile)
 ▄▀▀▀▀▄ 
█ ▀  ▀ █
█ ▀▄▄▀ █
 ▀▄▄▄▄▀ 
PRINT-SLOTS
PRINT-BOXED
FORMAT-SLOTS
FORMAT-SXHASH
PATTERN-TO-BITMAP
FMT-ROW
BULLSEYE
DRAW
DRAW-ONE-IN-CHANCE
IPRINTLN
WITH-BITMAP
SUN
PEACE
PRINT-TABLE
DRAW-BORDER
SMILE
PLOT-FUNCTION
SUNBEAM
PRINT-IN-BOX
SET-PIXEL
MAKE-BITMAP
HUMAN-READABLE-SIZE
MOIRE
FILL-BITMAP
OUTSIDE-BOUNDS
PRINT-HEADING
PRINTLN
DRAW-LINE
WITH-COMIC-STRIP
PRINT-SLOT-INDENT
DRAW-FILLED-CIRCLE
DRAW-CHANCE
PRINTER-STATUS
FMT-TREE
DRAW-CIRCLE

Some examples are shown below:

(print-in-box "hello world")
┌───────────┐
│hello world│
└───────────┘
(print-slots (make-spin-queue))

HEAD                           = (:NULL)
TAIL                           = (:NULL)
(print-heading "table formatter")
(print-table (group (iota 200) 10) :align :right :gap " ")
(print-heading "tree formatter")
(fmt-tree t (group (zip-list (group (iota 42) 3)) 2))

table formatter
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

  0   1   2   3   4   5   6   7   8   9
 10  11  12  13  14  15  16  17  18  19
 20  21  22  23  24  25  26  27  28  29
 30  31  32  33  34  35  36  37  38  39
 40  41  42  43  44  45  46  47  48  49
 50  51  52  53  54  55  56  57  58  59
 60  61  62  63  64  65  66  67  68  69
 70  71  72  73  74  75  76  77  78  79
 80  81  82  83  84  85  86  87  88  89
 90  91  92  93  94  95  96  97  98  99
100 101 102 103 104 105 106 107 108 109
110 111 112 113 114 115 116 117 118 119
120 121 122 123 124 125 126 127 128 129
130 131 132 133 134 135 136 137 138 139
140 141 142 143 144 145 146 147 148 149
150 151 152 153 154 155 156 157 158 159
160 161 162 163 164 165 166 167 168 169
170 171 172 173 174 175 176 177 178 179
180 181 182 183 184 185 186 187 188 189
190 191 192 193 194 195 196 197 198 199

tree formatter
▀▀▀▀▀▀▀▀▀▀▀▀▀▀

 ╭─ ((18 19 20))
 │   ╰─ (21 22 23)
 ├─ ((12 13 14))
 │   ╰─ (15 16 17)
 ├─ ((6 7 8))
 │   ╰─ (9 10 11)
(((0 1 2)) ((3 4 5)))
 ├─ ((24 25 26))
 │   ╰─ (27 28 29)
 ├─ ((30 31 32))
 │   ╰─ (33 34 35)
 ╰─ ((36 37 38))
     ╰─ (39 40 41)
(draw-one-in-chance 3)
(draw-chance 87)
(plot-function 'sin -5 5)
▄▀ ▄    ▀ ▀▄    ▄ ▄▄  ▄  ▄   ▄  
▄▄█ ▀▀▄▄▄▀  ▀   ▀█▄█ ▄    ▀ ▀▄▀ 
  ▄ █ █  ▀▄▄█▄  ▀▄▄▄      █  ▀  
 ▄   ▄▀█▄   ▄ ▄▀▀  ▀█ █▄▄▄ ▄▄ ▀ 
 ▀▀▄ ▄  ▄ ▀ ▄▀ ▄▄  ▀█    █ ▀ ▀▄ 
█▄▀▄█ ▀  ▄▄▀▄ █▄ ▄ ▀▀▄▄▀▀ ▄  █▀▀
 ▀█▄▄▄  ▄█▀  █ ▀▄▄ ▀  ▄ █ ▄  ▀  
 █  ▀█  ▀▄ ▄▀▄  ▄▄    ▄█▀█   ▀▀ 
   ▀▀ ▀▀▄█    ▄  ▄▀  █▄ ▀▄▄█ ▄  
▄▄ ██    ▄ ▄    ▄ ▄ ▄█ █ ▄▄▄█ ▄ 
▀██▄█ ▀ █ ▀ ▀▄  ▄█▄▀▄   ▀▀▄▀ ▀▀ 
 ▄   █ ▄▄▄▀▀ ▀███▀ █ ▀▄▄  ▄  ▄ ▀
▀▀ ▄▄ ▀▀▄█▄█▀██ █ █▄  ▄▀█   ▄  ▄
▄▄▄█  ▀  ▄▀▀  ▄▀ ▄▀  ▄  ▀▀  ▄█▄▀
▄▄ ▄ ▄▀ ▄ ▀ ▀█▀▄▄▄  ▀▄▀▄ ▄█ ▄ ██
   ▄█▄▀▄▀█ ▄ ▄▀▀▄▄▄▄ ▀▄  ▀  ▀█▀ 
██▀████████████▀████▄ ███▀███▀█▀▄▀▄▄█▄▀▀▄▄ ▄ ▄█ ▀ ▄   ▀▀▄█▀ ▀█▀  ▀▄   ▄ ▄   ▀      ▀   
███████▀██████▄▀██ ▀▀███▀▀▀▀ ▀█▄█ ██ ▀▀ █ █▀▀▀▄   ▀▀▄  ▀ █▀▀▀  ▀ ▄ ▄▄   ▄        ▄ ▄   
█████████████▀▄▀██▄ █████▀██████▀█▄▀▄█ █ ▄█▄▄ ▀ ▄ ▄▄▀ ▄▀ ▄▄▀  ▄  ▄  ▀  ▄ ▄  ▄   ▄▀   ▄ 
██████████████▀███▄█▀▀▀▀█▄███▄▀▄▄▀█ █▀██▄███▄▄▄ ▄▄  ▄▄█▄ ▄▀   ▄▀▄ ▄      ▄       ▀     
████████▀███████████▄▀▄▄▀██ ▀▄██▄██▄█▄ ▀▀▀▄ ▀█ █  ▄▀▀  ▄ ▀  ▀▄▀ ▀▀▀▄  ▄▀     ▄         
█▄█████▀██▀█▄██████▄██▀▀████▀▄▄▀▀▄▄▀▀▄ ▄▀█ ▄▄▀ ▀▄ ▀▀▀▀▀  ▀ ▀   ██    ▄ ▀       ▀       
████▀▄██▄██████ █ ███▄▀▄▀▀ ▀▄██▄████ ▀ ▀ ██▄▄██▀██▀   ▄▀  ▀█▀▄▀▀  ▄▄      ▄█   ▄       
█████████▄███████▀ ██▄  ▀▀▀██▄██▄  █▀▀█▀ ▀▀ ██    ███ ▀ ▄  ▄▀   ▄▀     ▄     ▀         
█████████▄█▀███████████▀█▀ ▀▀▄ ▄█▀▀▄ ▄▀▄██▄▀   ▀▄▀ ▄█ ▀▀█▄▄ ▀  ▀▄ ▀   ▄▄▄▄ ▄       ▀   
██████████▄▄█████ █ ▀█▄  █ ▀█▀█▄█ █▀ ██ █ ▀▀▀ ▄ ▀▀▀  █ ▄▀ █ ▄     ▄▄   ▀    ▀          
██████▀█████▄█████▀█▀██▄▀███▄▀█▀▄▄█▄▀█ ▄▀▄▀▀▀█▀ ▀█▄ ▀ ▀ ▄ ▄  █▄  ▀▄    ▄█      ▄       
█████▄█▄███▀███▄█▄▀▀▄██▄▀▄▀▀█  ▄███ ▄█▀██▀▀▄  ▄█ ▀█▀  ▄ ▄ ▄█ ▀ ▀     ▀   ▀       ▄     
███████████████▄█▀█▄▀██▄███▄▀▄▀ █ ▀▄█▀█▄▀███▄▀▀█ █  ▀▀▄▄▄▄█▄     ▄▀▀ ▄     ▄  ▄        
███████▄██▄█▄██▄███▀▀█▄██▄▄▀███ █▀ ▀███▀▄██ ▀▀▄▀▀  ██▄   ▀▄ ▄▀ ▄ █       ▄▀ ▄    ▀▀    
███▀▄████▀▄█▀██▀██▄███ ▀▀▄▄ █ ▀██▄▀ ██ ▀ ▄▄  ▀▀   █▀▄▀▄▄  ▀ █▀  ██▄      ▄▄  ▄▀  ▄ ▀▄  
█████████████▄██▀▄██████▄██▄▄▀██   ▀███▄▄▄█▄  █ ▀█ ▀▄  █▄ ▀▄ ▄     ▀ █▀ ▀   ▄▄         
█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█
█                                                              █
█                                                              █
█                                                              █
█                                                              █
█▀▀▀▀▄▄                               ▄▄▀▀▀▀▀▄▄                █
█      ▀▄                           ▄▀         ▀▄              █
█        ▀▄                       ▄▀             ▀▀▄           █
█          ▀▄                  ▄▀▀                  ▀▄         █
█            ▀▄▄             ▄▀                       ▀▄       █
█               ▀▄         ▄▀                           ▀▄     █
█                 ▀▀▄▄▄▄▄▀▀                               ▀▀▄▄▄█
█                                                              █
█                                                              █
█                                                              █
█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█
(human-readable-size 101010101) ;; in btes
96.33 MB
(print-heading "ascii art")
(sun :size 24)
(peace)
(sunbeam :step 4 :size 32)
(moire :size 32 :filled t :step 2)

ascii art
▀▀▀▀▀▀▀▀▀

         ▄▄▄▄▄▄▄        
      ▄███████████▄     
    █████████████████   
  ▄███████████████████▄ 
 ▄█████████████████████▄
 ███████████████████████
 ███████████████████████
 ███████████████████████
  █████████████████████ 
   ▀█████████████████▀  
    ▀▀█████████████▀▀   
       ▀▀███████▀▀      
    ▄▄▄▄▄   
  ▄▀  █  ▀▄ 
 █    █    █
 █   ▄█▄   █
 ▀▄▄▀ █ ▀▄▄▀
   ▀▄▄█▄▄▀  
█  ▄▀  ▄▀  ▄▀  ▄▀  ▄▀  ▄▀  ▄▀ ▄▀
█  █   █  ▄▀  █   █  ▄▀  ▄▀ ▄▀  
█  █  █   █  █  ▄▀  █  ▄▀ ▄▀ ▄▀▀
█  █  █  █  █  ▄▀ ▄▀ ▄▀ ▄▀ ▄▀   
█ █  █  █  █  █  █ ▄▀ ▄▀ ▄▀  ▄▀▀
█ █  █ ▄▀ █ ▄▀ ▄▀ █ ▄▀▄▀▀ ▄▀▀   
█ █ █ ▄▀ █ ▄▀▄▀ ▄▀▄▀▄▀ ▄▄▀  ▄▄▀▀
█ █ █ █ █ █ ▄▀▄▀▄▀▄▀ ▄▀  ▄▄▀    
██ █ █ █ █▄▀▄▀▄█▄▀▄▀▀ ▄▀▀  ▄▄▀▀▀
██ █▄▀█▄▀▄█▀▄█▀▄▄▀▄▄▀▀ ▄▄▀▀     
███▄▀█▄█▀█▄█▀▄▀▄▄▀ ▄▄▀▀   ▄▄▄▀▀▀
███████▄███▀█▄▀▄▄▀▀ ▄▄▄▀▀▀      
██████████▀█▄▀▀▄▄▀▀▀   ▄▄▄▄▀▀▀▀▀
███████████▄▀▀█▄▄▄▀▀▀▀▀         
█████████▀▀███▄▄▄▄▄▄▄▀▀▀▀▀▀▀▀▀▀▀
███████████▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ 
          ▄▄▄▀▀▀▀▀▀▀▄▄▄   ▄▄▄▀▀▀▀▀▀▀▄▄▄         
       ▄▀▀▄▄▄▀▀▀▀▀▀▀▄▄▄█▀█▄▄▄▀▀▀▀▀▀▀▄▄▄▀▀▄      
    ▄▀▀▄▄▀ ▄▄▀▀▀▀▀▀▀▄█▀█▄█▀█▄▀▀▀▀▀▀▀▄▄ ▀▄▄▀▀▄   
   ▄▀▄▀ ▄▀▀▄▄▀▀▀▀▀▀██▄▀▀▄▀▀▄██▀▀▀▀▀▀▄▄▀▀▄ ▀▄▀▄  
  █ ▄▀▄▀ ▄▀ ▄▄▀▀▀▀█▄▄▀██ ██▀▄▄█▀▀▀▀▄▄ ▀▄ ▀▄▀▄ █ 
 █ █ ▄▀▄▀ ▄▀ ▄▀▀▀█▀█ ██▄▀▄██ █▀█▀▀▀▄ ▀▄ ▀▄▀▄ █ █
▄▀▄▀▄▀▄▀ █ ▄▀▄▄▀█▀▄███▄█ █▄███▄█▀▀▄▄▀▄ █ ▀▄█▄▀▄█
█ █ █ █ █ █ ▄▀▄▀█▀███ ███ ███▀██▀▀▄█▄ ███ ███ ██
█ █ █ █ █ █ █ █ █ ███ ███ ███ ██  ███ ███ ███ ██
█ █ █ █ ▀▄▀▄ █▄▀█▀███▄██▀▄██████▀▀▄█ ▄▀█▀ ███ ██
 █ █ █ █ ▀▄ ▀▄ ▀▀█ █▀█▄█ █▄█▀█ █▀▀ ▄▀ ▄▀ █ █ █ █
 ▀▄▀▄ █ ▀▄ ▀▄▄▀▀▀▀██▄▀█▄▀▄█▀▄██▀▀▀▀▄▄▀ ▄▀ █ ▄▀▄▀
  ▀▄ █ ▀▄ ▀▄▄ ▀▀▀▀▀▄▄█▀▀▄▀▀█▄▄▀▀▀▀▀ ▄▄▀ ▄▀ █ ▄▀ 
    █ ▀▄▄▀▀▄▄▀▀▀▀▀▀▀█▄▀█▄█▀▄█▀▀▀▀▀▀▀▄▄▀▀▄▄▀ █   
     ▀▀▄ ▀▄▄▄▀▀▀▀▀▀▀▄███ ███▄▀▀▀▀▀▀▀▄▄▄▀ ▄▀▀    
        ▀▀▄▄▄▀▀▀▀▀▀▀▄▄▄▀▀▀▄▄▄▀▀▀▀▀▀▀▄▄▄▀▀       

path

DIRECTORY-EMPTY-P
DIRECTORY-PATH-P
FILE-PATHNAME
WITH-TMP
WITH-DIRECTORY
TMP-SUFFIX
CALL-WITH-DIRECTORY
PATHSEP
MERGE-HOMEDIR-PATHNAMES
SYMLINK-PATHNAME
PATH
RELATIVE-PATHNAME
ABSOLUTE-PATHNAME
WALK-DIRECTORY
DIRECTORY-PATH
SYMLINKP
ABSOLUTE-DIRECTORY-PATHNAME
NON-WILD-PATHNAME
DIRECTORY-FILES
TMPIZE-PATHNAME
SET-PATHNAME-SUFFIX
ENSURE-DIRECTORY-TRUENAME
WILDFILE
DIRECTORY-WILDCARD
WILD-PATHNAME
DIRECTORY-PATHNAME
SUBDIRECTORIES

file

PROBE-DELETE-DIRECTORY
FILE-SIZE
DELETE-DIRECTORIES
DIR
FILE
FILE-DATE
WRITE-FILE-INTO-STREAM
PROBE-DELETE-FILE
UNKNOWN-FILE-TYPE
FILE-SIZE-IN-OCTETS
WRITE-STREAM-INTO-FILE
WITH-OPEN-FILES
DELETE-FILE-IF-EXISTS
READ-FILE
DELETE-FILE-ERROR
DELETE-DIRECTORY
FIND-FILES
FILE-TIMESTAMP
MOVE-FILE
TMPFILE
HIDDEN-PATH-P
PROBE-MERGE-FILE
HIDDEN-PATHS
COUNT-FILE-LINES
PROBE-DIRECTORY
FILE=
OCTET-VECTOR=

os

LIST-ALL-USERS
LIST-ALL-GROUPS
UNMERGE-PATHNAMES
TCGETATTR
USER-INFO
TERMIOS-IFLAG
INIT-XDG-USER-DIRS
GROUP-ADD
TCSETATTR*
SUDO-P
OPEN-PIPE
CFMAKERAW
XDG-BASE-DIR
TIOCSWINSZ
XDG-USER-DIRS
ISATTY
TERMIOS-CFLAG
TCSAFLUSH
PATHNAME-EXECUTABLE-P
TCSANOW
RELATIVE-PATHNAME-P
TCGETATTR*
TCSETATTR
FILE-KIND
ABSOLUTE-PATHNAME-P
USER-ADD
USER
XDG-BASE-DIRS
TERMIOS
TERMIOS-OFLAG
CURRENT-DIRECTORY
WITH-DIRECTORY-ITERATOR
TERMIOS-LFLAG
WITH-UMASK
OPOST
XDG-USER-DIR
TIOCGWINSZ
MERGE-ENV-PATHNAMES
WINSIZE
TIOCNOTTY
TCSADRAIN
SET-SIGNAL-HANDLER
INIT-XDG-BASE-DIRS
WITH-FD

pipe

FILTER
INDEX
BUFFER
MSG
FILE-SINK
EVENT
PREDICATE-FILTER
INSERT-ELEMENT
INSERT-ELEMENT*
PIPE
PRINT-FILTER
DEFPIPE
SWITCH-FILTER
STREAM-SOURCE
ELEMENT-STREAM
MESSAGE-CONTENT
ELEMENT
PREDICATE
SET-ELEMENT-ID
MOVE-ELEMENT
MESSAGE
SOURCE
CONDITION-MESSAGE
FILE-SOURCE
MAKE-PIPE
BUS
FORMAT-MESSAGE
VALUE
FIND-ELEMENT
REMOVE-ELEMENT
STREAM-SINK
ADD-ELEMENT
SIMPLE-MESSAGE
DEFPIPE*
RESOLVE-ELEMENT
MESSAGE-CONDITION
SINK
FIND-PARENT-ELEMENT
WITHDRAW-ELEMENT
BIN

string

UNICODE>
CASED-P
WHITESPACE-P
UNICODE-1-NAME
LOWERCASE-P
CHARACTER-DECODING-ERROR
WORD-BREAK-CLASS
CHAR-RANGE
HEX-DIGIT-P
SENTENCES
UNICODE<
UPPERCASE-P
PROPLIST-P
COMBINING-CLASS
EAST-ASIAN-WIDTH
ASCII-ICHAR=
WHITESPACES
GRAPHEME-BREAK-CLASS
UNICODE-EQUAL
NCONCAT
CASEFOLD
SSPLIT
UPPERCASE
ALPHABETIC-P
MIRRORED-P
CHAR-BLOCK
DEFAULT-IGNORABLE-P
MAKE-TEMPLATE-PARSER
MATH-P
NORMALIZE-STRING
BIDI-MIRRORING-GLYPH
STRING-CASE
DECIMAL-VALUE
LINE-BREAK-CLASS
CONFUSABLE-P
HANGUL-SYLLABLE-TYPE
BIDI-CLASS
EF-OCTETS-TO-STRING-FUN
LOWERCASE
NCONCATF
TITLECASE
WORDS
DIGIT-VALUE
SCRIPT
LINES
ASCII-ISTRING=
SOFT-DOTTED-P
IDEOGRAPHIC-P
DETABIFY
TRIM
AGE
OMIT-NULLS
EF-STRING-TO-OCTETS-FUN
CASE-IGNORABLE-P
NUMERIC-VALUE
MAKE-GROWABLE-STRING
NORMALIZED-P
REMOVE-STRING
SUPPRESS-CHARACTER-CODING-ERRORS
SENTENCE-BREAK-CLASS
UNICODE=
UNICODE>=
STRING-DESIGNATOR
CHARACTER-CODING-ERROR
GENERAL-CATEGORY
TAB-WIDTH
GRAPHEMES
UNICODE<=
COLLAPSE-WHITESPACES
CHARACTER-ENCODING-ERROR

Tests