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
STD/TASK STD/PIPE STD/ASYNC STD/BIT STD/HASH-TABLE STD/DEFSYS STD/LIST STD/SERDE STD/SYM STD/COMP STD-USER STD/OS STD/PRIM STD/TESTS STD-LISP STD/READTABLE STD/META STD/PAR STD/CONDITION STD/MACS STD/FILE STD/STREAM STD/PATH STD/ARRAY STD/RAND STD/DEFPKG STD/THREAD STD/STRING STD/NAMED-READTABLES STD/CURRY STD/SYS STD/ALIEN STD/FMT STD-INT STD STD/SEQ STD/TYPE STD/NUM dependencies
dependents
ublk ssh2 wasmer web/dash web/index web gui krypt packy tree-sitter syn box pod vc/tests vc skel ffmpeg/tests ffmpeg alsa chromaprint jack glib/tests glib gstreamer/tests gstreamer cuda blas math sndfile dsp organ doc q/tests q rocksdb rdb nlp rustls keyutils blake3 cry rt parse net aws-lc zstd btrfs evdev xkb obj uring ironclad/core ironclad io log/tests log cli std/tests core/bench core bin/skc bin/skel bin/vc bin/rdb bin/pod bin/mpk bin/homer bin/organ files
named-readtables.lisp defpkg.lisp pkg.lisp condition.lisp sym.lisp list.lisp prim.lisp type.lisp string.lisp num/float.lisp num/parse.lisp num/leb128.lisp num/math.lisp stream.lisp curry.lisp array.lisp hash-table.lisp readtable.lisp macs/ana.lisp macs/pan.lisp macs/const.lisp macs/var.lisp macs/collecting.lisp macs/loop.lisp macs/control.lisp macs/unit.lisp macs/sugar.lisp pipe.lisp sys.lisp serde.lisp alien.lisp comp.lisp meta.lisp bit.lisp seq.lisp thread.lisp task.lisp async.lisp par.lisp fmt.lisp path.lisp os.lisp file.lisp rand.lisp defsys.lisp tests
THREAD-POOL TIMERS THREADS WITH-THREADS ITER ACCUMULATOR PRIORITY-QUEUE SPIN-QUEUE CONS-QUEUE VECTOR-QUEUE PARSE-NUMBERS LEB128 BITS CURRY ALIEN PAN ANA FMT ERR LIST STRING SYM READTABLES
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 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!
andfboundp!
are inspired by thec-mera
library and paper, providing quite useful for source-to-source compilers.alias-function
andalias-macro
are from thelparallel
library, implemented in terms ofcompiler-function
andmacro-function
respectively.with-gensyms
is our preferred name as opposed towith-unique-names
which is already defined by the implementation. Instead of re-writing we set themacro-function
of thewith-gensyms
symbol directly.symbolicate
andkeywordicate
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 bymatlisp
. The vocabluarly includesdcons
,dpush
,dpop
,drdc
,dcdr
,dcar
, anddappendf
.toposort
is a variant on topological-sort also defined inmatlisp
.- common functions and macros from
alexandria
andserapeum
merge!
andsort!
fromcl-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 declaimedinline
.
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 |
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
, andencode-float64
- u/leb128 encoding/decoding:
read-leb128
,encode-leb128
,encode-uleb128
,decode-leb128
, anddecode-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. Thestream
slot is accessible via the genericstream-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 |
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 |
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 |
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 |
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 |
XDG-USER-DIRS |
ISATTY |
TERMIOS-CFLAG |
PATHNAME-EXECUTABLE-P |
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 |
XDG-USER-DIR |
MERGE-ENV-PATHNAMES |
WINSIZE |
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 |