The serapeum Reference Manual

Source

Methods

Method: add-hook ((hook hook-any) (handler handler-any) &key append) ¶

Add HANDLER to HOOK. Return HOOK. HOOK must be of type HOOK-ANY HANDLER must be of type HANDLER-ANY.

Source: hooks.lisp.

Method: add-hook ((hook hook-number->number) (handler handler-number->number) &key append) ¶

Add HANDLER to HOOK. Return HOOK.
HOOK must be of type HOOK-NUMBER->NUMBER HANDLER must be of type HANDLER-NUMBER->NUMBER.

Source: hooks.lisp.

Method: add-hook ((hook hook-string->string) (handler handler-string->string) &key append) ¶

Add HANDLER to HOOK. Return HOOK.
HOOK must be of type HOOK-STRING->STRING HANDLER must be of type HANDLER-STRING->STRING.

Source: hooks.lisp.

Method: add-hook ((hook hook-void) (handler handler-void) &key append) ¶

Add HANDLER to HOOK. Return HOOK. HOOK must be of type HOOK-VOID HANDLER must be of type HANDLER-VOID.

Source: hooks.lisp.

Method: add-hook ((hook symbol) fn &key append) ¶

Generic Reader: combination (object) ¶

Generic Writer: (setf combination) (object) ¶

Package

Methods

Reader Method: combination ((hook hook)) ¶

Writer Method: (setf combination) ((hook hook)) ¶

This can be used to reverse the execution order, return a single value, etc.

Source: hooks.lisp.
Target Slot: combination.

Generic Function: combine-composed-hook (hook &rest args) ¶

Package

Methods

Method: combine-composed-hook ((hook hook) &rest args) ¶

Return the result of the composition of the HOOK handlers on ARGS, from oldest to youngest.
Without handler, return ARGS as values.
This is an acceptable ‘combination’ for ‘hook’.

Source: hooks.lisp.

Generic Function: combine-hook-until-failure (hook &rest args) ¶

Package

Methods

Method: combine-hook-until-failure ((hook hook) &rest args) ¶

Return the list of values until the first nil result.
Handlers after the failing one are not run.

You need to check if the hook has handlers to know if a NIL return value is due to the first handler failing or an empty hook.

This is an acceptable ‘combination’ for ‘hook’.

Source: hooks.lisp.

Generic Function: combine-hook-until-success (hook &rest args) ¶

Package

Methods

Method: combine-hook-until-success ((hook hook) &rest args) ¶

Return the value of the first non-nil result.
Handlers after the successful one are not run.

You need to check if the hook has handlers to know if a NIL return value is due to all handlers failing or an empty hook.

This is an acceptable ‘combination’ for ‘hook’.

Source: hooks.lisp.

Generic Function: default-combine-hook (hook &rest args) ¶

Package

Methods

Method: default-combine-hook ((hook hook) &rest args) ¶

Return the list of the results of the HOOK handlers applied from youngest to oldest to ARGS.
Return ’() when there is no handler.
This is an acceptable ‘combination’ for ‘hook’.

Source: hooks.lisp.

Generic Reader: description (object) ¶

Generic Writer: (setf description) (object) ¶

Package

Methods

Reader Method: description ((handler handler)) ¶

Writer Method: (setf description) ((handler handler)) ¶

Description of the handler. This is purely informative.

Source: hooks.lisp.
Target Slot: description.

Generic Function: disable-hook (hook &rest handlers) ¶

Package

Methods

Method: disable-hook ((hook hook) &rest handlers) ¶

Prepend HANDLERS to the list of disabled handlers. Without HANDLERS, disable all of them.

Source: hooks.lisp.

Generic Reader: disabled-handlers (object) ¶

Generic Writer: (setf disabled-handlers) (object) ¶

Package

Methods

Reader Method: disabled-handlers ((hook hook)) ¶

Writer Method: (setf disabled-handlers) ((hook hook)) ¶

Those handlers are not run by ‘run-hook’.
This is useful it the user wishes to disable some or all handlers without removing them from the hook.

Source: hooks.lisp.
Target Slot: disabled-handlers.

Generic Function: enable-hook (hook &rest handlers) ¶

Package

Methods

Method: enable-hook ((hook hook) &rest handlers) ¶

Prepend HANDLERS to the list of HOOK’s handlers. Without HANDLERS, enable all of them.

Source: hooks.lisp.

Generic Reader: fn (object) ¶

Generic Writer: (setf fn) (object) ¶

Package

Methods

Reader Method: fn ((handler handler)) ¶

Writer Method: (setf fn) ((handler handler)) ¶

The handler function. It can be an anonymous function.

Source: hooks.lisp.
Target Slot: fn.

Generic Reader: handler-type (object) ¶

Generic Writer: (setf handler-type) (object) ¶

Package

Methods

Reader Method: handler-type ((handler handler)) ¶

Writer Method: (setf handler-type) ((handler handler)) ¶

The function type of FN. This is purely informative.

Source: hooks.lisp.
Target Slot: handler-type.

Generic Reader: handlers (object) ¶

Generic Writer: (setf handlers) (object) ¶

Package

Methods

Reader Method: handlers ((hook hook)) ¶

Writer Method: (setf handlers) ((hook hook)) ¶

Source: hooks.lisp.
Target Slot: handlers.

Generic Reader: inconsistent-graph-constraints (condition) ¶

The constraints of an ‘inconsistent-graph’ error. Cf. ‘toposort’.

Package

Methods

Reader Method: inconsistent-graph-constraints ((condition inconsistent-graph)) ¶

Source: sequences.lisp.
Target Slot: constraints.

Generic Function: monitor (object) ¶

Return a unique lock associated with OBJECT.

Package

Source

threads.lisp.

Methods

Reader Method: monitor ((synchronized synchronized)) ¶

automatically generated reader method

Target Slot: monitor.

Method: monitor (object) ¶

Method: monitor ((object mutex)) ¶

Generic Reader: name (object) ¶

Generic Writer: (setf name) (object) ¶

Package

Methods

Reader Method: name ((handler handler)) ¶

Writer Method: (setf name) ((handler handler)) ¶

Name of the handler.
If defaults to the function name if ‘fn’ is a named function.
This is useful so that the user can build handlers out of anonymous functions.

Source: hooks.lisp.
Target Slot: name.

Generic Reader: place (object) ¶

Generic Writer: (setf place) (object) ¶

Package

Methods

Reader Method: place ((handler handler)) ¶

Writer Method: (setf place) ((handler handler)) ¶

If the handler is meant to be a setter, PLACE describes what is set. PLACE can be a symbol or a pair (CLASS SLOT).
This can be left empty if the handler is not a setter.

Source: hooks.lisp.
Target Slot: place.

Generic Function: remove-hook (hook fn) ¶

Remove FN from the symbol value of HOOK.

Package

Source

Methods

Method: remove-hook ((hook hook) handler-or-name) ¶

Remove handler matching HANDLER-OR-NAME from the handlers or the disabled-handlers in HOOK.
HANDLER-OR-NAME is either a handler object or a symbol. Return HOOK’s handlers.

Source: hooks.lisp.

Method: remove-hook ((hook symbol) fn) ¶

Generic Function: run-hook (hook &rest args) ¶

Apply each function in HOOK to ARGS.

Package

Source

Methods

Method: run-hook ((hook hook) &rest args) ¶

Source: hooks.lisp.

Method: run-hook ((*hook* symbol) &rest args) ¶

Generic Function: run-hook-until-failure (hook &rest args) ¶

Like ‘run-hook-with-args’, but quit once a function returns nil.

Package

Source

Methods

Method: run-hook-until-failure ((*hook* symbol) &rest args) ¶

Generic Function: run-hook-until-success (hook &rest args) ¶

Like ‘run-hook-with-args’, but quit once a function returns non-nil.

Package

Source

Methods

Method: run-hook-until-success ((*hook* symbol) &rest args) ¶

Generic Function: run-hook-with-args-until-failure (hook &rest args) ¶

Package

Methods

Method: run-hook-with-args-until-failure ((hook hook) &rest args) ¶

This is equivalent to setting the combination function to ‘combine-hook-until-failure’ and calling ‘run-hook’.

Source: hooks.lisp.

Generic Function: run-hook-with-args-until-success (hook &rest args) ¶

Package

Methods

Method: run-hook-with-args-until-success ((hook hook) &rest args) ¶

This is equivalent to setting the combination function to ‘combine-hook-until-success’ and calling ‘run-hook’.

Source: hooks.lisp.

Generic Reader: static-binding-flush-error-all-groups-p (condition) ¶

Package

Methods

Reader Method: static-binding-flush-error-all-groups-p ((condition static-binding-flush-error)) ¶

Source: static-let.lisp.
Target Slot: all-groups-p.

Generic Reader: static-binding-flush-error-group (condition) ¶

Package

Methods

Reader Method: static-binding-flush-error-group ((condition static-binding-flush-error)) ¶

Source: static-let.lisp.
Target Slot: group.

Generic Reader: value (object) ¶

Generic Writer: (setf value) (object) ¶

Package

Methods

Reader Method: value ((handler handler)) ¶

Writer Method: (setf value) ((handler handler)) ¶

If the handler is meant to be a setter, VALUE can be used to describe what FN is going to set to PLACE.
In particular, PLACE and VALUE can be used to compare handlers.
This can be left empty if the handler is not a setter.

Source: hooks.lisp.
Target Slot: value.

Next: Method combinations, Previous: Generic functions, Up: Public Interface [Contents][Index]

6.1.9 Standalone methods

Method: initialize-instance :around ((class topmost-object-class) &rest initargs &key direct-superclasses topmost-class) ¶

Source: mop.lisp.

Method: make-load-form ((self bounds) &optional env) ¶

Source: vector=.lisp.

Method: make-load-form ((queue queue) &optional env) ¶

Source: queue.lisp.

Method: make-load-form ((self box) &optional env) ¶

Source: box.lisp.

Method: make-load-form ((self %read-only-struct) &optional env) ¶

Source: defining-types.lisp.

Method: make-load-form ((self unbound) &optional env) ¶

Source: definitions.lisp.

Method: make-load-form ((self agroup) &optional env) ¶

Source: sequences.lisp.

Method: make-load-form ((self subenv) &optional env) ¶

Source: internal-definitions.lisp.

Method: print-object ((object bounds) stream) ¶

Source: vector=.lisp.

Method: print-object ((queue queue) stream) ¶

Source: queue.lisp.

Method: print-object ((self box) stream) ¶

Source: box.lisp.

Method: print-object ((self topmost-object-class) stream) ¶

Source: mop.lisp.

Method: print-object ((object agroup) stream) ¶

Source: sequences.lisp.

Method: print-object ((object subenv) stream) ¶

Source: internal-definitions.lisp.

Method: reinitialize-instance :around ((class topmost-object-class) &rest initargs &key direct-superclasses) ¶

Source: mop.lisp.

Method: validate-superclass ((class1 topmost-object-class) (class2 standard-class)) ¶

Package: sb-mop.
Source: mop.lisp.

Next: Conditions, Previous: Standalone methods, Up: Public Interface [Contents][Index]

6.1.10 Method combinations

Method Combination: standard/context () ¶

Package: serapeum.
Source: mop.lisp.

Next: Structures, Previous: Method combinations, Up: Public Interface [Contents][Index]

6.1.11 Conditions

Condition: case-failure ¶

A subtype of type-error specifically for case failures.

Package: serapeum.
Source: macro-tools.lisp.
Direct superclasses: type-error.

Condition: dispatch-case-error ¶

Package

dispatch-case-error-matched-types.

Source

dispatch-case.lisp.

Direct superclasses

type-error.

Direct methods

Direct Default Initargs

Initarg	Value
`:matched-types`	`nil`

Direct slots

Slot: matched-types-slot ¶

Package: serapeum/dispatch-case.
Initargs: :matched-types
Readers: dispatch-case-error-matched-types.
Writers: This slot is read-only.

Condition: econd-failure ¶

An ECOND failed.

Package

Source

control-flow.lisp.

Direct superclasses

error.

Direct Default Initargs

Initarg	Value
`:test-count`	`0`

Direct slots

Slot: test-count ¶

Initargs: :test-count

Condition: inconsistent-graph ¶

A graph that cannot be consistently sorted.

Package

inconsistent-graph-constraints.

Source

sequences.lisp.

Direct superclasses

error.

Direct methods

Direct slots

Slot: constraints ¶

The offending constraints

Initargs: :constraints
Readers: inconsistent-graph-constraints.
Writers: This slot is read-only.

Condition: letrec-restriction-violation ¶

Violation of the letrec restriction.

The "letrec restriction" means that the expressions being bound in a ‘letrec’ cannot refer to the value of other bindings in the same ‘letrec’.

For ‘fbindrec’, the restriction applies everywhere. For ‘fbindrec*’, it only applies to functions not yet bound.

Package

Source

fbind.lisp.

Direct superclasses

error.

Direct methods

(setf args-of).
args-of.

Direct slots

Slot: args ¶

Initargs: :args
Readers: args-of.
Writers: (setf args-of).

Condition: recursion-forbidden ¶

Package

Source

control-flow.lisp.

Direct superclasses

error.

Direct slots

Slot: form ¶

Initargs: :form

Condition: static-binding-active-error ¶

A subtype of error related to attempts to flush static bindings which are currently active.

Package

Source

static-let.lisp.

Direct superclasses

program-error.
static-binding-flush-error.

Direct Default Initargs

Initarg	Value
`:group`	`(required-argument group)`

Condition: static-binding-flush-error ¶

A subtype of error related to attempts to flush static bindings in a potentially unsafe way.

Package

static-binding-active-error.

Source

static-let.lisp.

Direct superclasses

error.

Direct subclasses

Direct methods

static-binding-flush-error-all-groups-p.
static-binding-flush-error-group.

Direct Default Initargs

Initarg	Value
`:all-groups-p`	`nil`
`:group`	`nil`

Direct slots

Slot: group ¶

Package: serapeum/static-let.
Initargs: :group
Readers: static-binding-flush-error-group.
Writers: This slot is read-only.

Slot: all-groups-p ¶

Package: serapeum/static-let.
Initargs: :all-groups-p
Readers: static-binding-flush-error-all-groups-p.
Writers: This slot is read-only.

Condition: static-load-time-value-error ¶

Package

Source

portability.lisp.

Direct superclasses

error.

Direct slots

Slot: form ¶

Initargs: :form

Slot: read-only-p ¶

Initargs: :read-only-p

Next: Classes, Previous: Conditions, Up: Public Interface [Contents][Index]

6.1.12 Structures

Structure: box ¶

A box is just a mutable cell.

You create a box using ‘box’ and get and set its value using the accessor ‘unbox’.

(def a-box (box t))
(unbox a-box) => t
(setf (unbox a-box) nil)
(unbox a-box) => nil

Serapeum attempts to provide the guarantee that, on Lisps that support atomic operations (compare-and-swap), ‘unbox‘ on boxes should be updateable atomically. (See [atomics](https://github.com/Shinmera/atomics)).

At the moment, boxes are implemented as structures, but that may change. In particular, you should not depend on being able to recognize boxes using a type or predicate.

Package

Source

box.lisp.

Direct superclasses

structure-object.

Direct methods

make-load-form.
print-object.

Direct slots

Slot: unbox ¶

Readers: unbox.
Writers: (setf unbox).

Structure: queue ¶

Basic cons queues, with an implementation based on PAIP and the original Norvig & Waters paper, and an API mostly borrowed from Arc.

About Arc. For the most part, Arc-style identifiers are pessimal, neither quite opaque nor quite explicit, like riddles. But by using abbreviated names, we avoid the danger of clashing with special-purpose queue implementations.

Create a queue with ‘queue’, like ‘list’:

(queue 1 2 3) => #<QUEUE (1 2 3)>

Get the items with ‘qlist’:

(qlist (queue 1 2 3)) => ’(1 2 3)

Add items with ‘enq’:

(enq 3 (queue 1 2)) => #<QUEUE (1 2 3)>

Remove an item with ‘deq’:

(deq (queue 1 2 3)) => 1

Prepend an item with ‘undeq’:

(qlist (undeq 1 (queue 2 3))) => ’(1 2 3)

To (destructively) join a list to the end of the queue, use ‘qconc’:

(qconc (queue 1 2 3) ’(4 5 6)) => #<QUEUE (1 2 3 4 5 6)>

The rest of the API:

- ‘queuep’ Test for a queue
- ‘qlen’ Like ‘(length (qlist ...))’
- ‘clear-queue’ Clear the queue
- ‘front’ Like ‘(car (qlist ...))’
- ‘qback’ Get the last element of the queue
- ‘queue-empty-p’ Test if the queue is empty
- ‘qappend’ Non-destructively join a list to the end of the queue - ‘qconc’ Destructively join a list to the end of the queue
- ‘qprepend’ Non-destructively join a list to the front of the queue

Note that support for both ‘deq’ and ‘undeq’ means that a queue is also effectively a stack. (But not quite a double-ended queue: you can push to either end, and pop from the front, but you can’t pop from the end.)

The idea is that *collecting* is something we do often enough to justifying making *collectors* (queues) first-class.

Package

Source

queue.lisp.

Direct superclasses

structure-object.

Direct methods

make-load-form.
print-object.

Direct slots

Slot: cons ¶

Package: common-lisp.
Type: cons
Initform: (error "no cons!")
Readers: queue-cons.
Writers: This slot is read-only.

Next: Types, Previous: Structures, Up: Public Interface [Contents][Index]

6.1.13 Classes

Class: handler ¶

Handlers are wrappers around functions used in typed hooks.
They serve two purposes as opposed to regular functions:

- They can embed a NAME so that anonymous functions can be conveniently used in lambda.
- If the handler is meant to be a setter, the PLACE and VALUE slot can be used to identify and compare setters.

With this extra information, it’s possible to compare handlers and, in particular, avoid duplicates in hooks.

Package

Source

Direct subclasses

handler-any.
handler-number->number.
handler-string->string.
handler-void.

Direct methods

(setf description).
description.
equals.
(setf fn).
fn.
(setf handler-type).
handler-type.
(setf name).
name.
(setf place).
place.
(setf value).
value.

Direct slots

Slot: name ¶

Name of the handler.
If defaults to the function name if ‘fn’ is a named function.
This is useful so that the user can build handlers out of anonymous functions.

Type: symbol
Initargs: :name
Readers: name.
Writers: (setf name).

Slot: description ¶

Description of the handler. This is purely informative.

Type: string
Initform: ""
Initargs: :description
Readers: description.
Writers: (setf description).

Slot: fn ¶

The handler function. It can be an anonymous function.

Type: function
Initform: (alexandria:required-argument (quote serapeum/contrib/hooks:fn))
Initargs: :fn
Readers: fn.
Writers: (setf fn).

Slot: handler-type ¶

The function type of FN. This is purely informative.

Initargs: :handler-type
Readers: handler-type.
Writers: (setf handler-type).

Slot: place ¶

If the handler is meant to be a setter, PLACE describes what is set. PLACE can be a symbol or a pair (CLASS SLOT).
This can be left empty if the handler is not a setter.

Type: (or symbol list)
Initargs: :place
Readers: place.
Writers: (setf place).

Slot: value ¶

Initargs: :value
Readers: value.
Writers: (setf value).

Class: handler-any ¶

Package: serapeum/contrib/hooks.
Source: hooks.lisp.
Direct superclasses: handler.
Direct methods: add-hook.

Class: handler-number->number ¶

Package: serapeum/contrib/hooks.
Source: hooks.lisp.
Direct superclasses: handler.
Direct methods: add-hook.

Class: handler-string->string ¶

Package: serapeum/contrib/hooks.
Source: hooks.lisp.
Direct superclasses: handler.
Direct methods: add-hook.

Class: handler-void ¶

Package: serapeum/contrib/hooks.
Source: hooks.lisp.
Direct superclasses: handler.
Direct methods: add-hook.

Class: hook ¶

This hook class serves as support for typed-hook.

Typing in hook is crucial to guarantee that a hook is well formed, i.e. that it’s handlers accept the right argument types and return the right value types.

Because typing is too limited in Common Lisp, we leverage CLOS to generate subclasses of ‘hook’ and ‘handlers’ with typed helper functions.
The ‘add-hook’ will thus only accept handlers of the right types.
This implementation is good enough to catch typing errors at compile time.

Package

Source

Direct subclasses

hook-any.
hook-number->number.
hook-string->string.
hook-void.

Direct methods

(setf combination).
combination.
combine-composed-hook.
combine-hook-until-failure.
combine-hook-until-success.
default-combine-hook.
disable-hook.
(setf disabled-handlers).
disabled-handlers.
enable-hook.
handler-class.
(setf handlers).
handlers.
remove-hook.
run-hook.
run-hook-with-args-until-failure.
run-hook-with-args-until-success.

Direct slots

Slot: handler-class ¶

The class of the supported handlers.

Type: symbol
Initform: t
Readers: handler-class.
Writers: This slot is read-only.

Slot: handlers ¶

Type: list
Initform: (quote nil)
Initargs: :handlers
Readers: handlers.
Writers: (setf handlers).

Slot: disabled-handlers ¶

Those handlers are not run by ‘run-hook’.
This is useful it the user wishes to disable some or all handlers without removing them from the hook.

Type: list
Initform: (quote nil)
Initargs: :disabled-handlers
Readers: disabled-handlers.
Writers: (setf disabled-handlers).

Slot: combination ¶

This can be used to reverse the execution order, return a single value, etc.

Type: function
Initform: (function serapeum/contrib/hooks:default-combine-hook)
Initargs: :combination
Readers: combination.
Writers: (setf combination).

Class: hook-any ¶

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: handler-class ¶

Initform: (quote serapeum/contrib/hooks:handler-any)

Class: hook-number->number ¶

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: handler-class ¶

Initform: (quote serapeum/contrib/hooks:handler-number->number)

Class: hook-string->string ¶

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: handler-class ¶

Initform: (quote serapeum/contrib/hooks:handler-string->string)

Class: hook-void ¶

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: handler-class ¶

Initform: (quote serapeum/contrib/hooks:handler-void)

Class: synchronized ¶

Mixin for a class with its own monitor.

Package

Source

threads.lisp.

Direct methods

monitor.

Direct slots

Slot: monitor ¶

Initform: (bordeaux-threads:make-recursive-lock "object monitor")
Readers: monitor.
Writers: This slot is read-only.

Class: topmost-object-class ¶

Package

Source

mop.lisp.

Direct superclasses

standard-class.

Direct methods

initialize-instance.
print-object.
reinitialize-instance.
topmost-class.
validate-superclass.

Direct slots

Slot: topmost-class ¶

Package: serapeum/mop.
Type: symbol
Initargs: :topmost-class
Readers: topmost-class.
Writers: This slot is read-only.

Previous: Classes, Up: Public Interface [Contents][Index]

6.1.14 Types

Type: -> (args &optional values) ¶

The type of a function from ARGS to VALUES.

Package: serapeum.
Source: types.lisp.

Type: absolute-directory-pathname () ¶

Package: serapeum.
Source: files.lisp.

Type: absolute-pathname () ¶

Package: serapeum.
Source: files.lisp.

Type: assure (type-spec) ¶

Package: serapeum.
Source: types.lisp.

Type: directory-pathname () ¶

Package: serapeum.
Source: files.lisp.

Type: file-pathname () ¶

Package: serapeum.
Source: files.lisp.

Type: input-stream () ¶

Package: serapeum.
Source: types.lisp.

Type: no-applicable-method-error () ¶

The type of the error signaled by ‘no-applicable-method’ on this Lisp. Note this may not be unique.

Package: serapeum.
Source: portability.lisp.

Type: non-wild-pathname () ¶

A pathname without wild components.

Package: serapeum.
Source: files.lisp.

Type: nor (&rest types) ¶

Package: serapeum.
Source: types.lisp.

Type: octet () ¶

Package: serapeum.
Source: types.lisp.

Type: octet-vector (&optional length) ¶

An array of octets.

Package: serapeum.
Source: types.lisp.

Type: output-stream () ¶

Package: serapeum.
Source: types.lisp.

Type: relative-pathname () ¶

Package: serapeum.
Source: files.lisp.

Type: single () ¶

Package: serapeum.
Source: sequences.lisp.

Type: soft-alist-of (key-type value-type) ¶

A soft constraint for the elements of an alist.

Equivalent to ‘(soft-list-of (cons KEY-TYPE VALUE-TYPE))‘.

Package: serapeum.
Source: types.lisp.

Type: soft-list-of (type) ¶

A soft constraint for the elements of a list.

The elements are restricted only as far as is practical, which is not very far, using heuristics which will not be specified here because they may improve over time. That said, since the goal of this type is to be practically useful, it will avoid any checks that would be O(n) in the length of the list.

Package: serapeum.
Source: types.lisp.

Type: subclass-union (class-name) ¶

Return a disjunction of all the direct subtypes of CLASS.
This can be useful for exhaustiveness checking over the direct subtypes of a class.

This should not be used for classes meant to be subclassed by library users.

Package: serapeum.
Source: clos.lisp.

Type: true () ¶

Package: serapeum.
Source: types.lisp.

Type: tuple (&rest types) ¶

A proper list where each element has the same type as the corresponding element in TYPES.

(typep ’(1 :x #c) ’(tuple integer keyword character)) => T

As a shortcut, a quoted form among TYPES is expanded to an ‘eql’ type specifier. (tuple ’function symbol)
≡ (tuple (eql function) symbol)

Literal keywords, numbers, and characters are also treated as ‘eql’ type specifiers. (tuple :name 1 #a symbol)
≡ (tuple (eql :name) (eql 1) (eql #a) symbol)

Package: serapeum.
Source: types.lisp.

Type: wholenum () ¶

A whole number. Equivalent to ‘(integer 0 *)’.

Package: serapeum.
Source: types.lisp.

Type: wild-pathname () ¶

A pathname with wild components.

Package: serapeum.
Source: files.lisp.

Previous: Public Interface, Up: Definitions [Contents][Index]

Next: Special variables, Previous: Internals, Up: Internals [Contents][Index]

6.2.1 Constants

Constant: +atomic-accessors+ ¶

Package: serapeum.
Source: box.lisp.

Constant: +hash-table-default-size+ ¶

Package: serapeum.
Source: hash-tables.lisp.

Constant: +pathsep+ ¶

Path separator for this OS.

Package: serapeum.
Source: files.lisp.

Constant: +seconds-in-day+ ¶

Package: serapeum.
Source: time.lisp.

Constant: +seconds-in-hour+ ¶

Package: serapeum.
Source: time.lisp.

Constant: +storage-for-deflex-var-+alist-breakeven++ ¶

Package: serapeum.
Source: functions.lisp.

Constant: +storage-for-deflex-var-iec-prefixes+ ¶

The IEC binary prefixes, as powers of 2.

Package: serapeum.
Source: units.lisp.

Constant: +storage-for-deflex-var-no-bounds-checks+ ¶

Package: serapeum.
Source: range.lisp.

Constant: +storage-for-deflex-var-no-break-space+ ¶

Package: serapeum.
Source: strings.lisp.

Constant: +storage-for-deflex-var-octet-vector-class+ ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Constant: +storage-for-deflex-var-seq-cutoff+ ¶

Max length above which to operate pairwise.

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Constant: +storage-for-deflex-var-si-prefixes+ ¶

List as SI prefixes: power of ten, long form, short form.

Package: serapeum.
Source: units.lisp.

Constant: +storage-for-deflex-var-si-prefixes-base-1000+ ¶

The SI prefixes as powers of 1000, with centi, deci, deca and hecto omitted.

Package: serapeum.
Source: units.lisp.

Constant: +storage-for-deflex-var-standard-input-syntax-vars+ ¶

Reader control variables bound by ‘with-standard-io-syntax’.

Package: serapeum.
Source: reader.lisp.

Constant: +storage-for-deflex-var-whitespace+ ¶

Whitespace characters.

Package: serapeum.
Source: strings.lisp.

Constant: +unix-epoch+ ¶

The Unix epoch as a universal time.

Package: serapeum.
Source: time.lisp.

Next: Symbol macros, Previous: Constants, Up: Internals [Contents][Index]

6.2.2 Special variables

Special Variable: %hook-table ¶

Global hook table.

Package: serapeum/contrib/hooks.
Source: hooks.lisp.

Special Variable: *active-groups* ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Special Variable: *case-macro-target* ¶

Implementation-appropriate target syntax clause deduplication.
How should repeated clauses in a case macro be deduplicated? With flet or a tagbody?

Package: serapeum.
Source: macro-tools.lisp.

Special Variable: *flushable-bindings* ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Special Variable: *flushing-lock* ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Special Variable: *forbidden-heads* ¶

Symbols that should not occur in the head of a list of forms. E.g. ‘progn’, ‘locally’.

Package: serapeum.
Source: macro-tools.lisp.

Special Variable: *internal-definitions-slots* ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Special Variable: *lexenv* ¶

The environment of the macro being expanded.

Package: serapeum.
Source: fbind.lisp.

Special Variable: *monitors* ¶

Package: serapeum.
Source: threads.lisp.

Special Variable: *recursions* ¶

Package: serapeum.
Source: control-flow.lisp.

Special Variable: *soft-list-cutoff* ¶

Package: serapeum.
Source: types.lisp.

Special Variable: *subenv* ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Special Variable: *units* ¶

Package: serapeum.
Source: defining-types.lisp.

Special Variable: *vref-by-type* ¶

Package: serapeum.
Source: types.lisp.

Next: Macros, Previous: Special variables, Up: Internals [Contents][Index]

6.2.3 Symbol macros

Symbol Macro: %all-branches% ¶

Package: serapeum.
Source: types.lisp.

Symbol Macro: %in-branching% ¶

Package: serapeum.
Source: types.lisp.

Symbol Macro: +alist-breakeven+ ¶

Package: serapeum.
Source: functions.lisp.

Symbol Macro: iec-prefixes ¶

Package: serapeum.
Source: units.lisp.

Symbol Macro: matched-types ¶

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Symbol Macro: no-bounds-checks ¶

Package: serapeum.
Source: range.lisp.

Symbol Macro: no-break-space ¶

Package: serapeum.
Source: strings.lisp.

Symbol Macro: octet-vector-class ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Symbol Macro: rest-arg ¶

Package: serapeum/op.
Source: op.lisp.

Symbol Macro: seq-cutoff ¶

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Symbol Macro: si-prefixes ¶

Package: serapeum.
Source: units.lisp.

Symbol Macro: si-prefixes-base-1000 ¶

Package: serapeum.
Source: units.lisp.

Symbol Macro: sorting-networks ¶

Package: serapeum.
Source: control-flow.lisp.

Symbol Macro: standard-input-syntax-values ¶

Package: serapeum.
Source: reader.lisp.

Symbol Macro: standard-input-syntax-vars ¶

Package: serapeum.
Source: reader.lisp.

Symbol Macro: test/= ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Symbol Macro: test/char-equal ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Symbol Macro: test/char= ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Symbol Macro: test/eq ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Symbol Macro: test/eql ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Symbol Macro: test/equal ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Symbol Macro: test/equalp ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Symbol Macro: underscore ¶

Package: serapeum/op.
Source: op.lisp.

Next: Compiler macros, Previous: Symbol macros, Up: Internals [Contents][Index]

6.2.4 Macros

Macro: %do-each ((var seq &optional return) &body body) ¶

Only for Lisps that do not support extensible sequences.

Package: serapeum.
Source: sequences.lisp.

Macro: %with-boolean ((&rest branches) &body body) ¶

Package: serapeum.
Source: types.lisp.

Macro: assure-values (typespecs &body form) ¶

Package: serapeum.
Source: types.lisp.

Macro: case-using-aux (pred keyform &body clauses) ¶

Package: serapeum.
Source: control-flow.lisp.

Macro: char-case-1 (keyform &body clauses) ¶

Package: serapeum.
Source: tree-case.lisp.

Macro: char-ecase-1 (keyform &body clauses) ¶

Package: serapeum.
Source: tree-case.lisp.

Macro: check-range/inline (start stop step) ¶

Package: serapeum.
Source: range.lisp.

Macro: collecting* (&body body) ¶

Intern COLLECT in the current package and bind it as a collector with MACROLET.

Package: serapeum.
Source: iter.lisp.

Macro: declaim-constant-function (&rest fns) ¶

Declare that FNs are constant functions, for the benefit of Lisps that understand such declarations.

Package: serapeum.
Source: types.lisp.

Macro: declaim-freeze-type (&rest types) ¶

Declare that TYPES is not going to change.

On Lisps that understand it, this is roughly equivalent to "sealing" a type in an OOP language: a promise that the type will never have any new subtypes, so tests for the type can be open-coded.

Package: serapeum.
Source: types.lisp.

Macro: declaim-freeze-type-1 (type) ¶

Package: serapeum.
Source: types.lisp.

Macro: declaim-maybe-inline (&rest fns) ¶

Package: serapeum.
Source: macro-tools.lisp.

Macro: declaim-maybe-inline-1 (fn) ¶

Package: serapeum.
Source: macro-tools.lisp.

Macro: define-env-method (name (self &rest args) &body body) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Macro: define-real-range (name &body &key) ¶

Package: serapeum.
Source: range.lisp.

Macro: define-simple-exporter (macro-name lambda-list) ¶

Package: serapeum.
Source: exporting.lisp.

Macro: define-variadic-equality (variadic binary) ¶

Package: serapeum.
Source: control-flow.lisp.

Macro: dispatch-case/nobindings (vars-and-types &body clauses) ¶

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Macro: do-each/map ((var seq &optional return) &body body) ¶

The simple, out-of-line version.

Package: serapeum.
Source: sequences.lisp.

Macro: do-strings ((s more?) &body body) ¶

Package: serapeum.
Source: strings.lisp.

Macro: do-subseq ((var seq &optional return &key start end from-end) &body body) ¶

Package: serapeum.
Source: sequences.lisp.

Macro: do-vector ((var vec &optional return) &body body) ¶

Iterate over the items of a vector in a manner similar to ‘dolist’.

Package: serapeum.
Source: sequences.lisp.

Macro: ensuring-functions (vars &body body) ¶

Package: serapeum.
Source: macro-tools.lisp.

Macro: etypecase-of/no-shadows (type expr &body clauses) ¶

Like ‘etypecase-of’, but filter shadowed clauses.

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Macro: firstn-values (n expr) ¶

Package: serapeum.
Source: binding.lisp.

Macro: flet* (bindings &body body) ¶

Package: serapeum.
Source: binding.lisp.

Macro: generate-values-vector-case (vec) ¶

Package: serapeum.
Source: vectors.lisp.

Macro: if-let1 (var test &body then) ¶

Package: serapeum.
Source: control-flow.lisp.

Macro: length-gt (cmp offset-fn seqs) ¶

Package: serapeum.
Source: sequences.lisp.

Macro: let-initialized (bindings &body body) ¶

Like LET, but if any of BINDINGS are uninitialized, try to give them sane initialization values.

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Macro: let1 (var expr &body body) ¶

Bind VAR, immutably, to EXPR and evaluate BODY.

This may be pronounced with equal propriety as "let-one" or "let-once".

Package: serapeum.
Source: binding.lisp.

Macro: letrec-with (setq (&rest bindings) &body body) ¶

Package: serapeum.
Source: binding.lisp.

Macro: lret-aux (let (&rest bindings) &body body) ¶

Package: serapeum.
Source: binding.lisp.

Macro: mvdef (vars &body &optional) ¶

Package: serapeum.
Source: definitions.lisp.

Macro: nix-1 (place) ¶

Package: serapeum.
Source: control-flow.lisp.

Macro: op/no-walker (&body body) ¶

Package: serapeum/op.
Source: op.lisp.

Macro: policy-quality-in-env (qual) ¶

Package: serapeum.
Source: types.lisp.

Macro: read-only-var (real-var &optional name) ¶

Setf Expander: (setf read-only-var) (real-var &optional name) ¶

Package: serapeum.
Source: macro-tools.lisp.

Macro: rebinding-functions (bindings &body body) ¶

Like ‘rebinding’, but specifically for functions.
The value being rebound will be wrapped in ‘ensure-function’.

Package: serapeum.
Source: macro-tools.lisp.

Macro: seq-dispatch (seq &body list-form) ¶

Efficiently dispatch on the type of SEQ.

Package: serapeum.
Source: macro-tools.lisp.

Macro: si-prefix-rec (n base prefixes) ¶

Package: serapeum.
Source: units.lisp.

Macro: sort-values/network (pred &rest values) ¶

Package: serapeum.
Source: control-flow.lisp.

Macro: sort-values/temp-vector (pred &rest values) ¶

Package: serapeum.
Source: control-flow.lisp.

Macro: stack-flet (bindings &body body) ¶

Package: serapeum.
Source: binding.lisp.

Macro: truly-the (type &body expr) ¶

Package: serapeum.
Source: types.lisp.

Macro: variable-type-in-env (var) ¶

Package: serapeum.
Source: types.lisp.

Macro: vector-dispatch (vec &body bit-vector-form) ¶

Efficiently dispatch on the type of VEC.
The first form provides special handling for bit vectors. The second form provides generic handling for all types of vectors.

Package: serapeum.
Source: macro-tools.lisp.

Macro: with-bounds ((start1 end1 start2 end2) bounds &body body) ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Macro: with-canonicalized-binding-accessors (() &body body) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Macro: with-int-vector ((var vect) &body body) ¶

Package: serapeum.
Source: range.lisp.

Macro: with-list-bucket ((seq) &body body) ¶

Wrap BODY with inlined bucket accessors for lists.

Package: serapeum.
Source: sequences.lisp.

Macro: with-matched-type (type &body body) ¶

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Macro: with-nullable ((var type) &body body) ¶

Package: serapeum.
Source: types.lisp.

Macro: with-sequence-bucket ((seq) &body body) ¶

Wrap BODY with inlined bucket accessors for generic sequences.

This might not seem worthwhile, and it’s not for ‘bucket-seq’, but for ‘bucket-push’ (and even ‘make-bucket’) it is, since accumulating for generic sequences just uses queues.

Package: serapeum.
Source: sequences.lisp.

Macro: with-simple-vector (((v vector) (s start) (e end)) &body body) ¶

If VECTOR is a displaced or adjustable array, binds V to the underlying simple vector, adds an adequate offset to START and END and binds those offset values to S and E. Otherwise, if VECTOR is already a simple array, it’s simply bound to V with no further changes.

START and END are unchecked and assumed to be within bounds.

Note that in some Lisps, a slow copying implementation is necessary to obtain a simple vector thus V will be bound to a copy of VECTOR coerced to a simple-vector. Therefore, you shouldn’t attempt to modify V.

Package: serapeum.
Source: portability.lisp.

Macro: with-specialized-buckets ((seq) &body body) ¶

Ensure BODY is run with the appropriate specialized, inlined versions of the bucket accessors.

This is only likely to be worthwhile around a loop; if you’re calling a bucket accessor once or twice the code bloat isn’t worth it.

Package: serapeum.
Source: sequences.lisp.

Macro: with-string-bucket ((seq) &body body) ¶

Wrap BODY with inlined bucket accessors for strings.

Package: serapeum.
Source: sequences.lisp.

Macro: with-syms (syms &body body) ¶

Like ‘with-gensyms’, but binds SYMS in the current package.

Package: serapeum.
Source: iter.lisp.

Macro: with-type-declarations-trusted ((&key) &body body) ¶

Package: serapeum.
Source: types.lisp.

Macro: with-vector-bucket ((seq) &body body) ¶

Wrap BODY with inlined bucket accessors for vectors (including strings).

Package: serapeum.
Source: sequences.lisp.

Macro: with-vref (type &body body) ¶

Package: serapeum.
Source: types.lisp.

Macro: without-internal-definitions (&body body) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Macro: wrong-type (datum type restart &body report) ¶

Package: serapeum.
Source: types.lisp.

Next: Ordinary functions, Previous: Macros, Up: Internals [Contents][Index]

6.2.5 Compiler macros

Compiler Macro: count-range (start &optional end by) ¶

Package: serapeum.
Source: range.lisp.

Compiler Macro: require-type (datum spec) ¶

Package: serapeum.
Source: types.lisp.

Compiler Macro: require-type-for (datum spec place) ¶

Package: serapeum.
Source: types.lisp.

Compiler Macro: test-load-time-value (fn form read-only-p) ¶

Package: serapeum.
Source: portability.lisp.

Next: Generic functions, Previous: Compiler macros, Up: Internals [Contents][Index]

6.2.6 Ordinary functions

Function: $path () ¶

Split the PATH environment variable.

Package: serapeum.
Source: files.lisp.

Function: %flatten (array) ¶

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Function: %flush (group) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: %make-static-binding (&key name value initializedp read-only lock) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: (setf %read-only-var) (var) ¶

Package: serapeum.
Source: macro-tools.lisp.

Function: %require-type (datum spec) ¶

Package: serapeum.
Source: types.lisp.

Function: %require-type-for (datum spec place) ¶

Package: serapeum.
Source: types.lisp.

Function: add-hook-internal (hook handler &key append) ¶

Add HANDLER to HOOK if not already in it.
Return HOOK.
HANDLER is also not added if in the ‘disabled-handlers’. If APPEND is non-nil, HANDLER is added at the end.

Package: serapeum/contrib/hooks.
Source: hooks.lisp.

Function: agroup (exemplar bucket) ¶

Package: serapeum.
Source: sequences.lisp.

Reader: agroup-bucket (instance) ¶

Package: serapeum.
Source: sequences.lisp.
Target Slot: bucket.

Reader: agroup-exemplar (instance) ¶

Package: serapeum.
Source: sequences.lisp.
Target Slot: exemplar.

Function: analyze-fbinds (bindings lexenv) ¶

Pull apart BINDINGS, looking for lambdas to lift.

Package: serapeum.
Source: fbind.lisp.

Function: augment/block (block &optional subenv) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: augment/funs (funs &optional subenv) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: augment/macros (macros &optional subenv) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: augment/symbol-macros (symbol-macros &optional subenv) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: augment/tags (tags &optional subenv) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: augment/vars (binds &optional subenv) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: body+vars (body env) ¶

Package: serapeum/op.
Source: op.lisp.

Function: body-decls (body) ¶

Package: serapeum.
Source: fbind.lisp.

Function: bounds (start1 end1 start2 end2) ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Reader: bounds-end1 (instance) ¶

Package: serapeum/vector=.
Source: vector=.lisp.
Target Slot: end1.

Reader: bounds-end2 (instance) ¶

Package: serapeum/vector=.
Source: vector=.lisp.
Target Slot: end2.

Reader: bounds-start1 (instance) ¶

Package: serapeum/vector=.
Source: vector=.lisp.
Target Slot: start1.

Reader: bounds-start2 (instance) ¶

Package: serapeum/vector=.
Source: vector=.lisp.
Target Slot: start2.

Function: bounds-trivial? (vec start end) ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Function: boxp (object) ¶

Package: serapeum.
Source: box.lisp.

Function: branch-type (branch) ¶

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Function: bucket-append (seq items bucket) ¶

Append ITEMS to the end of BUCKET according to SEQ.

The items will appear, together and in the same order, in the sequence taken from the bucket by BUCKET-SEQ.

Package: serapeum.
Source: sequences.lisp.

Function: bucket-push (seq item bucket) ¶

Insert ITEM at the end of BUCKET according to SEQ.

Package: serapeum.
Source: sequences.lisp.

Function: bucket-seq (seq bucket) ¶

Return a sequence "like" SEQ using the elements of BUCKET.

Note that it is not safe to call the function more than once on the same bucket.

Package: serapeum.
Source: sequences.lisp.

Function: build-bind/ftype (fn var decls env) ¶

Return a form, suitable for the bindings of a ‘flet’ or ‘labels’ form, that binds a function named FN which calls the function in a variable named VAR.

If there is a declared ftype for FN in the decls-env combination, it may be used to make calling VAR more efficient by avoiding ‘apply’.

Package: serapeum.
Source: fbind.lisp.

Function: call-with-array-data/copy (vector start end fn) ¶

Package: serapeum.
Source: portability.lisp.

Function: call-with-array-data/fast (vector start end fn) ¶

Package: serapeum.
Source: portability.lisp.

Function: call/standard-input-syntax (fn) ¶

Package: serapeum.
Source: reader.lisp.

Function: call/string (fn stream) ¶

Resolve STREAM like ‘format’ and call FN with the result.

Package: serapeum.
Source: strings.lisp.

Function: canonicalize-binding (binding) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: canonicalize-bindings (bindings) ¶

Package: serapeum.
Source: binding.lisp.

Function: canonicalize-key (k) ¶

Package: serapeum.
Source: sequences.lisp.

Function: canonicalize-test (test &optional test-not) ¶

Package: serapeum.
Source: sequences.lisp.

Function: check-exhaustiveness (style type clauses env) ¶

Package: serapeum.
Source: control-flow.lisp.

Function: check-match-exhaustive (union clauses env) ¶

Package: serapeum.
Source: defining-types.lisp.

Function: check-no-dynamic-extent (names declarations) ¶

Check that none of NAMES are declared ‘dynamic-extent’ in DECLARATIONS.

Package: serapeum/static-let.
Source: static-let.lisp.

Function: check-no-underscores (holes) ¶

Package: serapeum.
Source: control-flow.lisp.

Function: check-range (start stop step) ¶

Package: serapeum.
Source: range.lisp.

Function: check-same-test (ht1 ht2) ¶

Check that HT1 and HT2, two hash tables, have the same value for ‘hash-table-test’.

This should work even for "custom" hash tables with user-defined tests.

Package: serapeum.
Source: hash-tables.lisp.

Function: clause-leading-type (clause) ¶

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Function: clauses+default (clauses &key default-keys) ¶

Package: serapeum.
Source: macro-tools.lisp.

Function: collect-fallthrough-clauses (branch more-branches &optional env) ¶

Collect fallthrough clauses from MORE-BRANCHES into BRANCH.

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Function: conditional-error (name) ¶

Package: serapeum.
Source: types.lisp.

Function: constructor= (x y) ¶

Package: serapeum.
Source: defining-types.lisp.

Function: copy-agroup (agroup1 &key exemplar bucket) ¶

Copy an instance of AGROUP, optionally overriding some or all of its slots.

Package: serapeum.
Source: sequences.lisp.

Function: copy-bounds (bounds1 &key start1 end1 start2 end2) ¶

Copy an instance of BOUNDS, optionally overriding some or all of its slots.

Package: serapeum/vector=.
Source: vector=.lisp.

Function: copy-box (instance) ¶

Package: serapeum.
Source: box.lisp.

Function: copy-hash-table/empty (table &key test size rehash-size rehash-threshold) ¶

Make a hash table with the same parameters (test, size, &c.) as TABLE, but empty.

Package: serapeum.
Source: hash-tables.lisp.

Function: copy-heap (instance) ¶

Package: serapeum.
Source: heap.lisp.

Function: copy-string (x) ¶

Package: serapeum.
Source: strings.lisp.

Function: copy-subenv (subenv1 &key vars funs blocks tags) ¶

Copy an instance of SUBENV, optionally overriding some or all of its slots.

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: count-cpus-string (&key online) ¶

Package: serapeum.
Source: threads.lisp.

Function: count-range (start &optional end step) ¶

Return a vector of ascending positive integers.

With one argument, return all the integers in the interval [0,end).

With two arguments, return all the integers in the interval [start,end).

With three arguments, return the integers in the interval [start,end) whose difference from START is evenly divisible by STEP.

Package: serapeum.
Source: range.lisp.

Function: count-range/1 (end) ¶

Package: serapeum.
Source: range.lisp.

Function: count-range/2 (start end) ¶

Package: serapeum.
Source: range.lisp.

Function: count-range/3 (start end step) ¶

Package: serapeum.
Source: range.lisp.

Function: declared-ftype (fn decls &optional env) ¶

If DECLS contains an ftype declaration for FN, return it.
Returns three values. The first two values are the arguments type and return type. The third is a boolean, which is ‘t’ only when there was an ftype declaration.

Package: serapeum.
Source: fbind.lisp.

Function: default-tie-breaker (min-elts constraints) ¶

The default tie breaker for a topological sort.

Package: serapeum.
Source: sequences.lisp.

Function: delete* (item sequence &key from-end test start end count key) ¶

Like ‘delete’ but return (values NEW-SEQUENCE FOUNDP) with FOUNDP being T if the element was found, NIL otherwise.

Package: serapeum/contrib/hooks.
Source: hooks.lisp.

Function: describe-non-exhaustive-match (stream partition type env) ¶

Package: serapeum.
Source: control-flow.lisp.

Function: digit-length (n &optional base) ¶

Package: serapeum.
Source: strings.lisp.

Function: displace (array shape &optional offset) ¶

Shorthand function for displacing an array.

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Function: double-float-range (start stop step) ¶

Package: serapeum.
Source: range.lisp.

Function: ensure-monitor (object string) ¶

Package: serapeum.
Source: threads.lisp.

Function: ensure-shape (x) ¶

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Function: ensure-var (var) ¶

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Function: env-super (env &optional default) ¶

Look for the superclass bound in ENV.

Package: serapeum.
Source: defining-types.lisp.

Function: escape/no-arg-parsing (string table start end stream) ¶

Package: serapeum.
Source: strings.lisp.

Function: expand-binding (bind) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: expand-bindings (bindings) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: expand-case-macro (cont expr clauses &key default-keys error macro-name) ¶

Package: serapeum.
Source: macro-tools.lisp.

Function: expand-case-macro/common (clauses &key jump macro-name) ¶

Package: serapeum.
Source: macro-tools.lisp.

Function: expand-case-macro/flet (cont expr-temp normal-clauses default &key macro-name) ¶

Package: serapeum.
Source: macro-tools.lisp.

Function: expand-case-macro/tagbody (cont expr-temp normal-clauses default &key macro-name) ¶

Package: serapeum.
Source: macro-tools.lisp.

Function: expand-char-case-keys (clauses) ¶

Package: serapeum.
Source: tree-case.lisp.

Function: expand-destructuring-case-of (type key clauses case-of) ¶

Package: serapeum.
Source: control-flow.lisp.

Function: expand-dispatch-caseql-clauses (clauses) ¶

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Function: expand-fbindings (bindings) ¶

Package: serapeum.
Source: fbind.lisp.

Function: expand-href (table keys) ¶

Package: serapeum.
Source: hash-tables.lisp.

Function: expand-mvfold (fn seq seeds &optional from-end) ¶

Package: serapeum.
Source: sequences.lisp.

Function: expand-nest (things) ¶

Helper function for ‘nest’.

Package: serapeum.
Source: control-flow.lisp.

Function: expand-pad-x (call fn env vec len pad) ¶

Auxiliary function for ‘pad-X’ compiler macros. Optimizes some cases where PAD is a constant sequence.

Package: serapeum.
Source: vectors.lisp.

Function: expand-read-only-var (var env) ¶

Package: serapeum.
Source: macro-tools.lisp.

Function: expand-variadic-equality (binary variadic args) ¶

Package: serapeum.
Source: control-flow.lisp.

Function: explode-type (type env) ¶

Extract the individual types from a type defined as a disjunction. TYPE could be the actual disjunction, or the name of the type.

If TYPE is not a disjunction, just return TYPE as a list.

Note that ‘member’ types are disjunctions:

(explode-type (member :x :y :z) nil)
=> ((eql :x) (:eql y) (eql :z))

Package: serapeum.
Source: control-flow.lisp.

Function: exponent-char-format (exponent-char) ¶

Package: serapeum.
Source: numbers.lisp.

Function: exponent-char? (char) ¶

Package: serapeum.
Source: numbers.lisp.

Function: extract-function-name (x) ¶

If possible, extract the name from X, a function designator.

Package: serapeum.
Source: macro-tools.lisp.

Function: extract-op-env (body env) ¶

Package: serapeum/op.
Source: op.lisp.

Function: extract-tagbody-tags (body) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: file=/loop (file1 file2 &key buffer-size) ¶

Compare two files by looping over their contents using a buffer.

Package: serapeum.
Source: files.lisp.

Function: fill-int-range! (vect start stop step) ¶

Package: serapeum.
Source: range.lisp.

Function: filter/counted (pred seq &rest args &key count from-end start end key) ¶

Helper for FILTER.

Package: serapeum.
Source: sequences.lisp.

Function: filter/swapped-arguments (seq pred &rest args &key &allow-other-keys) ¶

Package: serapeum.
Source: sequences.lisp.

Function: frange (start stop step) ¶

Perform floating-point contagion on START, STOP, and STEP, and call ‘range’ on the results.

Package: serapeum.
Source: range.lisp.

Function: free? (x env) ¶

Package: serapeum/op.
Source: op.lisp.

Function: fun (name init) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: gensym? (x) ¶

Is X a gensym’d (uninterned) symbol?

Package: serapeum.
Source: fbind.lisp.

Reader: heap-key (instance) ¶

Writer: (setf heap-key) (instance) ¶

Package: serapeum.
Source: heap.lisp.
Target Slot: key.

Function: heap-left (i) ¶

Package: serapeum.
Source: heap.lisp.

Function: heap-p (object) ¶

Package: serapeum.
Source: heap.lisp.

Function: heap-parent (i) ¶

Package: serapeum.
Source: heap.lisp.

Function: heap-right (i) ¶

Package: serapeum.
Source: heap.lisp.

Reader: heap-test (instance) ¶

Writer: (setf heap-test) (instance) ¶

Package: serapeum.
Source: heap.lisp.
Target Slot: test.

Reader: heap-vector (instance) ¶

Package: serapeum.
Source: heap.lisp.
Target Slot: vector.

Function: heapify (vec start key test) ¶

Package: serapeum.
Source: heap.lisp.

Function: hoist-clause-bodies (block clauses env) ¶

Hoist the bodies of the clauses into tags.
This is needed because the same clause may be spliced into the dispatch-case form in several places (in order to implement fallthrough).

Returns two values: a list of alternating tags and forms, and a list of clauses rewritten to jump to the tags.

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Function: ignored-functions-in-body (body) ¶

Package: serapeum.
Source: fbind.lisp.

Function: ignored-functions-in-decls (decls) ¶

Package: serapeum.
Source: fbind.lisp.

Function: include+opts (opts) ¶

Package: serapeum.
Source: defining-types.lisp.

Function: initialize-binds-from-decls (binds-in decls &optional env) ¶

Given a list of bindings and a set of declarations, look for any uninitialized bindings. If there are any, try to extrapolate reasonable initialization values for them based on the declarations in DECLS.

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Reader: initializedp (instance) ¶

Writer: (setf initializedp) (instance) ¶

Package: serapeum/static-let.
Source: static-let.lisp.
Target Slot: initializedp.

Function: insert-superclass (superclass list) ¶

Package: serapeum/mop.
Source: mop.lisp.

Function: int-range-shape (start stop step) ¶

Return the length and element type for a range vector from START to STOP by STEP.

Package: serapeum.
Source: range.lisp.

Function: integer-range (start stop step) ¶

Package: serapeum.
Source: range.lisp.

Function: intern-unit (name ctor) ¶

Package: serapeum.
Source: defining-types.lisp.

Function: intersperse/list (new-elt list) ¶

Package: serapeum.
Source: sequences.lisp.

Function: intersperse/seq (new-elt seq) ¶

Package: serapeum.
Source: sequences.lisp.

Function: invalid (&rest args) ¶

Package: serapeum.
Source: fbind.lisp.

Function: key-test (key test &optional test-not) ¶

Return a function of two arguments which uses KEY to extract the part of the arguments to compare, and compares them using TEST.

Package: serapeum.
Source: sequences.lisp.

Function: lambda-list-vars (lambda-list) ¶

Return a list of the variables bound in LAMBDA-LIST, an ordinary lambda list.

Package: serapeum.
Source: macro-tools.lisp.

Function: let-over-lambda (form lexenv) ¶

Expand form, using ‘expand-macro’. If the result is a simple let-over-lambda, analyze it into an environment, declarations, and a lambda.

Package: serapeum.
Source: fbind.lisp.

Function: link (arrays) ¶

Return a list of all of the items in ARRAYS.

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Function: list+length (list start end) ¶

Package: serapeum.
Source: lists.lisp.

Function: list-collapse-duplicates (test key list) ¶

Package: serapeum.
Source: sequences.lisp.

Function: list-map-from-end/bordeaux (fun list &key start end) ¶

Traverse LIST from the end, calling FUN on each item.

This uses the technique described by Durand and Strandh in their paper presented at ECLS 2015, “Processing List Elements in Reverse Order.”

Package: serapeum.
Source: lists.lisp.

Function: list-runs (list start end key test count compare-last) ¶

Package: serapeum.
Source: sequences.lisp.

Reader: lock (instance) ¶

Package: serapeum/static-let.
Source: static-let.lisp.
Target Slot: lock.

Function: lock-form (object objectp env string) ¶

Package: serapeum.
Source: threads.lisp.

Function: long-float-range (start stop step) ¶

Package: serapeum.
Source: range.lisp.

Function: longest-list (lists) ¶

Find the longest list in LISTS.

Package: serapeum.
Source: sequences.lisp.

Function: longest-seq (seqs) ¶

Package: serapeum.
Source: sequences.lisp.

Function: macro (name init) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: make-active-groups-binding (bindings) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: make-bucket (seq &optional init) ¶

Return a "bucket" suitable for collecting elements from SEQ.

If SEQ is restricted as to the type of elements it can hold (for example, if SEQ is an array with an element type) the same restriction will apply to the bucket.

Package: serapeum.
Source: sequences.lisp.

Function: make-float (number divisor &optional format) ¶

Package: serapeum.
Source: numbers.lisp.

Function: make-flusher (x) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: make-handler (fn &key class-name name handler-type place value) ¶

Return a ‘handler’.
NAME is only mandatory if FN is a lambda.
CLASS-NAME can be used to create handler subclasses.

HANDLER-TYPE, PLACE and VALUE are as per the sltos in ‘handler-type’.

This function should not be used directly.
Prefer the typed make-handler-* functions instead.

Package: serapeum/contrib/hooks.
Source: hooks.lisp.

Function: make-initform (x) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: make-let-binding (x) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: make-macrolet-binding (x) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: make-op-env (&rest args &key &allow-other-keys) ¶

Package: serapeum/op.
Source: op.lisp.

Function: make-queue () ¶

Package: serapeum.
Source: queue.lisp.

Function: make-queue-cons () ¶

Package: serapeum.
Source: queue.lisp.

Function: make-sequence-like (seq len &rest args &key initial-element initial-contents) ¶

Helper function: make a sequence of length LEN having the same type as SEQ.

Package: serapeum.
Source: sequences.lisp.

Function: make-static-binding (&key once name read-only) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: make-type-declaration (x) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: make-unique-name-list (length &optional x) ¶

Alias for ‘alexandria:make-gensym-list’.

Package: serapeum.
Source: macro-tools.lisp.

Function: map-splits (fn split-fn seq start end from-end) ¶

Package: serapeum.
Source: sequences.lisp.

Function: map-splits-from-end (fn split-fn seq start end) ¶

Package: serapeum.
Source: sequences.lisp.

Function: map-splits-from-start (fn split-fn seq start end) ¶

Package: serapeum.
Source: sequences.lisp.

Function: map-subseq (fn seq &optional start end from-end) ¶

Helper function to map SEQ between START and END.

Package: serapeum.
Source: sequences.lisp.

Function: map-tree/inorder (fun tree tag tagp) ¶

Package: serapeum.
Source: trees.lisp.

Function: map-tree/postorder (fun tree tag tagp) ¶

Package: serapeum.
Source: trees.lisp.

Function: map-tree/preorder (fun tree tag tagp) ¶

Package: serapeum.
Source: trees.lisp.

Function: mapconcat/list (fun list sep stream) ¶

Package: serapeum.
Source: strings.lisp.

Function: mapconcat/seq (fun seq sep stream) ¶

Package: serapeum.
Source: strings.lisp.

Function: merely-syntactic-functions (names body-with-decls env) ¶

Which functions in NAMES are merely syntactic?

Functions are "merely syntactic" if they are never dereferenced with ‘function’ (or sharp-quote).

This function may return false negatives – it may fail to detect that a function is syntactic – but it should never return a false positive – it should never say a function is syntactic when it is not.

Package: serapeum.
Source: fbind.lisp.

Function: merge-tables! (table &rest tables) ¶

Package: serapeum.
Source: hash-tables.lisp.

Function: missing-branch (name) ¶

Package: serapeum.
Source: types.lisp.

Function: move-hook-handlers (hook source-handlers-slot destination-handlers-slot select-handlers) ¶

Package: serapeum/contrib/hooks.
Source: hooks.lisp.

Function: mutual-element-type (arrays) ¶

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Function: mvfold-aux (fn seq seeds &optional from-end) ¶

Package: serapeum.
Source: sequences.lisp.

Reader: name (instance) ¶

Writer: (setf name) (instance) ¶

Package: serapeum/static-let.
Source: static-let.lisp.
Target Slot: name.

Function: normalize-cases (cases &key allow-default) ¶

Normalize CASES, clauses for a case-like macro.
Return each non-default clause normalized to ‘(keys . body)’, where keys is a *list* of keys.

Return the default clause as a second value.

If there is more than one default clause, signal an error.

Package: serapeum.
Source: macro-tools.lisp.

Function: nsplice-list (list new start end) ¶

Package: serapeum.
Source: sequences.lisp.

Function: nsplice-vector (vector new start end) ¶

Package: serapeum.
Source: sequences.lisp.

Function: numbered-placeholder? (x env) ¶

Package: serapeum/op.
Source: op.lisp.

Function: octet-vector=/unsafe (v1 v2 start1 end1 start2 end2) ¶

Package: serapeum.
Source: octets.lisp.

Function: pairwise (fn xs) ¶

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Function: parse-defmethod-args (args) ¶

Parse the args to defmethod (everything except the name). Returns three values: a list of qualifiers, the specialized lambda-list, and the forms that make up the body.

Package: serapeum.
Source: macro-tools.lisp.

Function: parse-static-let (bindings body) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: parse-static-let* (bindings body env) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: partition-declarations-by-kind (simple complex lambda decls) ¶

Package: serapeum.
Source: fbind.lisp.

Function: partition-fbinds (fbinds body) ¶

Partition FBINDS using the "Fixing Letrec" algorithm.
Returns the bindings in four sets: unreferenced, literal lambdas, simple (external references) and complex (everything else).

BODY is needed because we detect unreferenced bindings by looking for ‘ignore’ declarations.

Package: serapeum.
Source: fbind.lisp.

Function: pattern-type (pattern union) ¶

Return two values: the type and the final pattern.

Package: serapeum.
Source: defining-types.lisp.

Function: placeholder? (x env) ¶

Package: serapeum/op.
Source: op.lisp.

Function: policy-quality (quality &optional env) ¶

Query ENV for optimization declaration information. Returns 1 when the environment cannot be accessed.

Package: serapeum.
Source: macro-tools.lisp.

Function: policy> (env policy1 policy2) ¶

Package: serapeum.
Source: macro-tools.lisp.

Function: prepare-int-range (start stop step) ¶

Package: serapeum.
Source: range.lisp.

Function: print-constructor (object stream fields) ¶

Package: serapeum.
Source: defining-types.lisp.

Function: print-unit (object stream depth) ¶

Package: serapeum.
Source: defining-types.lisp.

Function: proper-alist? (x &optional cutoff) ¶

Package: serapeum.
Source: types.lisp.

Function: proper-list-without-nil? (x &optional cutoff) ¶

Package: serapeum.
Source: types.lisp.

Function: proper-list? (x &optional cutoff) ¶

Package: serapeum.
Source: types.lisp.

Reader: queue-cons (instance) ¶

Package: serapeum.
Source: queue.lisp.
Target Slot: cons.

Function: quickselect (a k lt) ¶

Hoare’s quickselect, as implemented by Wirth ("FIND"), with refinements by V. Zabrodsky ("MODIFIND").

Package: serapeum.
Source: sequences.lisp.

Function: quotation? (x env) ¶

Package: serapeum/op.
Source: op.lisp.

Function: quote-unless-constant (value &optional env) ¶

Package: serapeum.
Source: defining-types.lisp.

Function: random-range-type (low high) ¶

Package: serapeum.
Source: numbers.lisp.

Function: range-error (start stop step) ¶

Package: serapeum.
Source: range.lisp.

Function: read-float (stream junk-allowed type) ¶

Package: serapeum.
Source: numbers.lisp.

Function: read-float-aux (stream junk-allowed type) ¶

Package: serapeum.
Source: numbers.lisp.

Function: read-new-value () ¶

Read and evaluate a value.

Package: serapeum.
Source: types.lisp.

Reader: read-only (instance) ¶

Writer: (setf read-only) (instance) ¶

Package: serapeum/static-let.
Source: static-let.lisp.
Target Slot: read-only.

Function: read-only-include-clause (name clause &optional env) ¶

Rewrite CLAUSE, an include clause, for use with a read-only structure.

Package: serapeum.
Source: defining-types.lisp.

Function: read-only-slotdef (slot) ¶

Rewrite SLOT, a structure slot definition, to be read-only.
Note that if SLOT is of an odd length, then it is treated as being without an initialization form, and a default initialization form that raises an error is supplied.

Package: serapeum.
Source: defining-types.lisp.

Function: real-range (start stop step) ¶

Package: serapeum.
Source: range.lisp.

Function: reduce-between (fn xs start end) ¶

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Function: reduce-vector-pairwise (fun xs) ¶

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Function: reify-bounds (vec1 vec2 start1 end1 start2 end2) ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Function: remove-duplicated-subtypes (subtypes) ¶

Package: serapeum.
Source: types.lisp.

Function: remove-shadowed (binds &optional subenv) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: remove-shadowed-clauses (clauses &optional env) ¶

Given a list of typecase clauses, remove any clauses that are shadowed by previous clauses.

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Function: remove-shadowed-subtypes (subtypes) ¶

Package: serapeum.
Source: types.lisp.

Function: repeat-list (list n) ¶

Package: serapeum.
Source: sequences.lisp.

Function: repeat-vector (vec n) ¶

Package: serapeum.
Source: sequences.lisp.

Function: replace* (out in) ¶

Like ‘replace’ with no keyword arguments, but if IN is shorter than OUT, extend it cyclically.

In the base case, if IN is empty, leave OUT alone.

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Function: report-group-substring (&key group all-groups-p) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: report-static-binding-active-error (condition stream) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: report-static-binding-flush-error (condition stream) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: require-type (datum spec) ¶

Package: serapeum.
Source: types.lisp.

Function: require-type-for (datum spec place) ¶

Package: serapeum.
Source: types.lisp.

Function: rest-op? (x env) ¶

Package: serapeum/op.
Source: op.lisp.

Function: rest-placeholder? (x env) ¶

Package: serapeum/op.
Source: op.lisp.

Function: rotation (seq n) ¶

Like ‘rotate’, but non-destructive.

Package: serapeum.
Source: sequences.lisp.

Function: same-literal-p (x y) ¶

A predicate that compares whether X and Y have the same literal representation.

Package: serapeum.
Source: definitions.lisp.

Function: same-test? (ht1 ht2) ¶

Do two hash tables have the same test?

Package: serapeum.
Source: hash-tables.lisp.

Function: same-type? (type1 type2 &optional env) ¶

Like ‘alexandria:type=’, but takes an environment.

Package: serapeum.
Source: control-flow.lisp.

Function: seq=/2 (x y) ¶

Package: serapeum.
Source: sequences.lisp.

Function: setslice (seq1 seq2 start &optional end) ¶

Helper to ‘set’ a slice non-destructively.

Package: serapeum.
Source: sequences.lisp.

Function: shadow-names (binds) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: shape= (array1 array2) ¶

Return true if ARRAY1 and ARRAY2 have the same shape.

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Function: short-float-range (start stop step) ¶

Package: serapeum.
Source: range.lisp.

Function: shortest-list (lists) ¶

Find the shortest list in LISTS.

Package: serapeum.
Source: sequences.lisp.

Function: shortest-seq (seqs) ¶

Package: serapeum.
Source: sequences.lisp.

Function: shortest/longest (seqs extreme-seq extreme-list length-predicate) ¶

Package: serapeum.
Source: sequences.lisp.

Function: shrink-wrap (object shape) ¶

Make an array of shape SHAPE containing OBJECT as its initial element. The array will have the smallest element type sufficient to contain OBJECT.

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Function: simple-binding-p (binding) ¶

Package: serapeum.
Source: binding.lisp.

Function: simple-lambda-list? (lambda-list) ¶

A lambda list with no inits.

Package: serapeum.
Source: fbind.lisp.

Function: simplify-args-for-string-plus (args &optional env) ¶

Package: serapeum.
Source: strings.lisp.

Function: simplify-keylists (clauses) ¶

Simplify the keylists in CLAUSES.

If the keylist is an empty list, omit the clause.

If the keylist is a list with one element, unwrap that element.

Otherwise, leave the keylist alone.

Package: serapeum.
Source: macro-tools.lisp.

Function: simplify-string (string) ¶

Package: serapeum.
Source: strings.lisp.

Function: simplify-subtypes (subtypes) ¶

Package: serapeum.
Source: types.lisp.

Function: single-float-range (start stop step) ¶

Package: serapeum.
Source: range.lisp.

Function: slice-bounds (len start end) ¶

Normalize START and END, which may be negative, to offsets acceptable to SUBSEQ.

Package: serapeum.
Source: sequences.lisp.

Function: sort-clauses (clauses &optional env) ¶

Given a list of typecase clauses, order them so no preceding clause shadows later ones, if possible.

Package: serapeum/dispatch-case.
Source: dispatch-case.lisp.

Function: sort-subtypes (subtypes) ¶

Package: serapeum.
Source: types.lisp.

Function: sorting-network (size) ¶

Package: serapeum.
Source: control-flow.lisp.

Function: speed-matters? (env) ¶

Return T if ENV says we should prefer space to speed.

Package: serapeum.
Source: macro-tools.lisp.

Function: splice-list (list new start end) ¶

Package: serapeum.
Source: sequences.lisp.

Function: splice-vector (vector new start end) ¶

Package: serapeum.
Source: sequences.lisp.

Function: split-at (list k) ¶

Package: serapeum.
Source: sequences.lisp.

Function: string-case-failure (expr keys) ¶

Package: serapeum.
Source: control-flow.lisp.

Function: subenv (vars funs blocks tags) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Reader: subenv-blocks (instance) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.
Target Slot: blocks.

Function: subenv-empty? () ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Reader: subenv-funs (instance) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.
Target Slot: funs.

Reader: subenv-tags (instance) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.
Target Slot: tags.

Reader: subenv-vars (instance) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.
Target Slot: vars.

Function: subtypes-exhaustive? (type subtypes &optional env) ¶

Package: serapeum.
Source: types.lisp.

Function: sym-numbered-placeholder? (x) ¶

Package: serapeum/op.
Source: op.lisp.

Function: sym-rest-arg? (x) ¶

Package: serapeum/op.
Source: op.lisp.

Function: sym-underscore? (x) ¶

Package: serapeum/op.
Source: op.lisp.

Function: symbol-macro (name init) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: symbol-macro-bindings (&optional subenv) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: tagbody-tag? (form) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: test-fn (test) ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Function: test-kind (test) ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Function: test-load-time-value (fn form read-only-p) ¶

Package: serapeum.
Source: portability.lisp.

Function: thread-aux (threader needle holes thread-fn) ¶

Package: serapeum.
Source: control-flow.lisp.

Function: tsort (elts constraints tie-breaker &key test) ¶

Package: serapeum.
Source: sequences.lisp.

Function: tsort/hash-table (objects constraints tie-breaker &key test) ¶

Package: serapeum.
Source: sequences.lisp.

Function: tsort/list (elts constraints tie-breaker &key test) ¶

Do the initial topological sort.

Package: serapeum.
Source: sequences.lisp.

Function: type-vref (type) ¶

Package: serapeum.
Source: types.lisp.

Function: unbound (var) ¶

Package: serapeum.
Source: definitions.lisp.

Function: unbound-p (object) ¶

Package: serapeum.
Source: definitions.lisp.

Reader: unbound-var (instance) ¶

Package: serapeum.
Source: definitions.lisp.
Target Slot: var.

Reader: value (instance) ¶

Writer: (setf value) (instance) ¶

Package: serapeum/static-let.
Source: static-let.lisp.
Target Slot: value.

Function: value-ref (static-binding) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: (setf value-ref) (static-binding) ¶

Package: serapeum/static-let.
Source: static-let.lisp.

Function: var (name init) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: var-lexical? (x env) ¶

Package: serapeum/op.
Source: op.lisp.

Function: variable-special? (var &optional env) ¶

Package: serapeum.
Source: macro-tools.lisp.

Function: variable-type (var &optional env) ¶

Package: serapeum.
Source: macro-tools.lisp.

Function: vector-kind (v) ¶

Package: serapeum/vector=.
Source: vector=.lisp.

Function: visible-of-type (type subenv) ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.

Function: void (x) ¶

Package: serapeum/generalized-arrays.
Source: generalized-arrays.lisp.

Next: Structures, Previous: Ordinary functions, Up: Internals [Contents][Index]

6.2.7 Generic functions

Generic Function: %constructor= (x y) ¶

Package

Source

Methods

Method: %constructor= ((o1 subenv) (o2 subenv)) ¶

Source: internal-definitions.lisp.

Method: %constructor= ((o1 bounds) (o2 bounds)) ¶

Source: vector=.lisp.

Method: %constructor= ((o1 agroup) (o2 agroup)) ¶

Source: sequences.lisp.

Method: %constructor= (x y) ¶

Generic Function: alias-decls (self decls) ¶

Package

Methods

Method: alias-decls ((self internal-definitions-env) decls) ¶

Source: internal-definitions.lisp.

Generic Reader: args-of (condition) ¶

Generic Writer: (setf args-of) (condition) ¶

Package

Methods

Reader Method: args-of ((condition letrec-restriction-violation)) ¶

Writer Method: (setf args-of) ((condition letrec-restriction-violation)) ¶

Source: fbind.lisp.
Target Slot: args.

Generic Function: at-beginning? (self) ¶

Package

Methods

Method: at-beginning? ((self internal-definitions-env)) ¶

Return non-nil if this is the first form in the ‘local’.

Source: internal-definitions.lisp.

Generic Reader: binding-init (object) ¶

Package

Methods

Reader Method: binding-init ((%binding %binding)) ¶

automatically generated reader method

Source: internal-definitions.lisp.
Target Slot: init.

Generic Reader: binding-name (object) ¶

Package

Methods

Reader Method: binding-name ((%binding %binding)) ¶

automatically generated reader method

Source: internal-definitions.lisp.
Target Slot: name.

Generic Function: bounds-plausible? (bounds v1 v2) ¶

Package

Source

Methods

Method: bounds-plausible? ((bounds null) v1 v2) ¶

Method: bounds-plausible? ((bounds bounds) v1 v2) ¶

Generic Function: check-beginning (self offender) ¶

Package

Methods

Method: check-beginning ((self internal-definitions-env) offender) ¶

Source: internal-definitions.lisp.

Generic Function: compare-elements (kind1 kind2 test-kind bounds) ¶

Package

Source

Methods

Method: compare-elements ((v1 vector) (v2 vector) test (bounds bounds)) ¶

Method: compare-elements ((v1 vector) (v2 vector) test (bounds null)) ¶

Method: compare-elements ((v1 vector) (v2 vector) (test test/equalp) (bounds null)) ¶

Method: compare-elements ((v1 simple-array-unsigned-byte-8) (v2 simple-array-unsigned-byte-8) (test test/rat=) (bounds bounds)) ¶

Method: compare-elements ((v1 simple-array-unsigned-byte-8) (v2 simple-array-unsigned-byte-8) (test test/rat=) (bounds null)) ¶

Method: compare-elements ((v vector) (w vector-wrapper) test bounds) ¶

Method: compare-elements ((w vector-wrapper) (v vector) test bounds) ¶

Method: compare-elements ((w1 vector-wrapper) (w2 vector-wrapper) test bounds) ¶

Method: compare-elements ((w1 rat-vector) (w2 rat-vector) (test test/rat=) (bounds null)) ¶

Method: compare-elements ((w1 numeric-vector) (w2 numeric-vector) (test test/=) (bounds null)) ¶

Method: compare-elements ((v1 bit-vector) (v2 bit-vector) (test test/rat=) (bounds bounds)) ¶

Method: compare-elements ((v1 bit-vector) (v2 bit-vector) (test test/rat=) (bounds null)) ¶

Method: compare-elements ((s1 string) (s2 string) (test test/char-equal) (bounds bounds)) ¶

Method: compare-elements ((s1 string) (s2 string) (test test/char=) (bounds bounds)) ¶

Method: compare-elements ((s1 string) (s2 string) (test test/char-equal) (bounds null)) ¶

Method: compare-elements ((s1 string) (s2 string) (test test/char=) (bounds null)) ¶

Generic Function: constructor-values/generic (x) ¶

Package

Source

serapeum/dispatch-case.

Methods

Method: constructor-values/generic ((x subenv)) ¶

Source: internal-definitions.lisp.

Method: constructor-values/generic ((x bounds)) ¶

Source: vector=.lisp.

Method: constructor-values/generic ((x agroup)) ¶

Source: sequences.lisp.

Generic Reader: dispatch-case-error-matched-types (condition) ¶

Package

Methods

Reader Method: dispatch-case-error-matched-types ((condition dispatch-case-error)) ¶

Source: dispatch-case.lisp.
Target Slot: matched-types-slot.

Generic Function: eject-macro (self name wrapper) ¶

Package

Methods

Method: eject-macro ((self internal-definitions-env) name wrapper) ¶

Source: internal-definitions.lisp.

Generic Function: ensure-var-alias (self var) ¶

Package

Methods

Method: ensure-var-alias ((self internal-definitions-env) var) ¶

Source: internal-definitions.lisp.

Generic Function: equals (fn1 fn2) ¶

Package

Methods

Method: equals ((fn1 handler) (fn2 handler)) ¶

Return non-nil if FN1 and FN2 are equal.
Handlers are equal if they are setters of the same place and same value, or if their names are equal.

Source: hooks.lisp.

Generic Function: expand-body (self body) ¶

Package

Methods

Method: expand-body ((self internal-definitions-env) body) ¶

Shorthand for recursing on an implicit ‘progn’.

Source: internal-definitions.lisp.

Generic Function: expand-in-env (self form &optional env) ¶

Package

Methods

Method: expand-in-env ((self internal-definitions-env) form &optional env) ¶

Source: internal-definitions.lisp.

Generic Function: expand-in-env-1 (self form &optional env) ¶

Package

Methods

Method: expand-in-env-1 ((self internal-definitions-env) form &optional env) ¶

Like macroexpand-1, but handle local symbol macro bindings.

Source: internal-definitions.lisp.

Generic Function: expand-partially (self form) ¶

Package

Methods

Method: expand-partially ((self internal-definitions-env) form) ¶

Macro-expand FORM until it becomes a definition form or macro expansion stops.

Source: internal-definitions.lisp.

Generic Function: expand-top (self forms) ¶

Package

Methods

Method: expand-top ((self internal-definitions-env) forms) ¶

Source: internal-definitions.lisp.

Generic Function: expansion-done (self form) ¶

Package

Methods

Method: expansion-done ((self internal-definitions-env) form) ¶

Source: internal-definitions.lisp.

Generic Function: generate-internal-definitions (self body) ¶

Package

Methods

Method: generate-internal-definitions ((self internal-definitions-env) body) ¶

Source: internal-definitions.lisp.

Generic Reader: handler-class (object) ¶

Package

Methods

Reader Method: handler-class ((hook hook)) ¶

The class of the supported handlers.

Source: hooks.lisp.
Target Slot: handler-class.

Generic Function: hoisted-var? (self var) ¶

Package

Methods

Method: hoisted-var? ((self internal-definitions-env) var) ¶

Source: internal-definitions.lisp.

Generic Function: in-subenv? (self) ¶

Package

Methods

Method: in-subenv? ((self internal-definitions-env)) ¶

Are we within a binding form?

Source: internal-definitions.lisp.

Generic Function: known-var? (self var) ¶

Package

Methods

Method: known-var? ((self internal-definitions-env) var) ¶

Source: internal-definitions.lisp.

Generic Function: op-env-lambda (op-env) ¶

Package

serapeum/op.

Methods

Method: op-env-lambda ((op-env op-env)) ¶

Source: op.lisp.

Generic Function: read-only-struct-slot-names (x) ¶

Package

Source

Method Combination

append.

Options: :most-specific-first

Methods

Method: read-only-struct-slot-names append ((self subenv)) ¶

Source: internal-definitions.lisp.

Method: read-only-struct-slot-names append ((self bounds)) ¶

Source: vector=.lisp.

Method: read-only-struct-slot-names append ((self agroup)) ¶

Source: sequences.lisp.

Method: read-only-struct-slot-names append ((self unbound)) ¶

Source: definitions.lisp.

Method: read-only-struct-slot-names append (x) ¶

Generic Function: save-symbol-macro (self name exp) ¶

Package

Methods

Method: save-symbol-macro ((self internal-definitions-env) name exp) ¶

Source: internal-definitions.lisp.

Generic Function: shadow-symbol-macro (self name) ¶

Package

Methods

Method: shadow-symbol-macro ((self internal-definitions-env) name) ¶

Source: internal-definitions.lisp.

Generic Function: splice-forms (self spliced-forms) ¶

Package

Methods

Method: splice-forms ((self internal-definitions-env) spliced-forms) ¶

Source: internal-definitions.lisp.

Generic Function: step-expansion (self form) ¶

Package

Methods

Method: step-expansion ((self internal-definitions-env) form) ¶

Source: internal-definitions.lisp.

Generic Function: test.fn (test) ¶

Package

Source

Methods

Method: test.fn ((test test/eq)) ¶

Method: test.fn ((test test/eql)) ¶

Method: test.fn ((test test/equal)) ¶

Method: test.fn ((test test/char=)) ¶

Method: test.fn ((test test/char-equal)) ¶

Method: test.fn ((test test/=)) ¶

Method: test.fn ((test test/equalp)) ¶

Method: test.fn ((test function)) ¶

Generic Reader: topmost-class (object) ¶

Package

serapeum/mop.

Methods

Reader Method: topmost-class ((topmost-object-class topmost-object-class)) ¶

automatically generated reader method

Source: mop.lisp.
Target Slot: topmost-class.

Generic Reader: unwrap (object) ¶

Package

Methods

Reader Method: unwrap ((vector-wrapper vector-wrapper)) ¶

automatically generated reader method

Source: vector=.lisp.
Target Slot: vector.

Generic Function: var-alias-bindings (self) ¶

Package

Methods

Method: var-alias-bindings ((self internal-definitions-env)) ¶

Source: internal-definitions.lisp.

Generic Function: wrap-bindings (self bindings) ¶

Package

Methods

Method: wrap-bindings ((self internal-definitions-env) bindings) ¶

Source: internal-definitions.lisp.

Generic Function: wrap-expr (self form) ¶

Package

Methods

Method: wrap-expr ((self internal-definitions-env) form) ¶

Source: internal-definitions.lisp.

Generic Function: wrap-fn-bindings (self bindings) ¶

Package

Methods

Method: wrap-fn-bindings ((self internal-definitions-env) bindings) ¶

Source: internal-definitions.lisp.

Next: Classes, Previous: Generic functions, Up: Internals [Contents][Index]

6.2.8 Structures

Structure: %read-only-struct ¶

Abstract base class for read-only structures.

Package

Source

Direct superclasses

structure-object.

Direct subclasses

%unit.
agroup.
bounds.
subenv.
unbound.

Direct methods

make-load-form.

Structure: %unit ¶

Abstract base class for unit classes.

Package: serapeum.
Source: defining-types.lisp.
Direct superclasses: %read-only-struct.

Structure: agroup ¶

Auxiliary data structure for ‘assort’. A pair of an exemplar (to compare against) and a bucket of matching items. Note that while the agroup is immutable, the bucket itself is mutable.

Package

Source

sequences.lisp.

Direct superclasses

Direct methods

%constructor=.
constructor-values/generic.
make-load-form.
print-object.
read-only-struct-slot-names.

Direct slots

Slot: exemplar ¶

Initform: (alexandria:required-argument (quote serapeum::exemplar))
Readers: agroup-exemplar.
Writers: This slot is read-only.

Slot: bucket ¶

Initform: (alexandria:required-argument (quote serapeum::bucket))
Readers: agroup-bucket.
Writers: This slot is read-only.

Structure: bounds ¶

Package

Source

Direct superclasses

Direct methods

%constructor=.
bounds-plausible?.
compare-elements.
compare-elements.
compare-elements.
compare-elements.
compare-elements.
constructor-values/generic.
make-load-form.
print-object.
read-only-struct-slot-names.

Direct slots

Slot: start1 ¶

Type: alexandria:array-index
Initform: (alexandria:required-argument (quote serapeum/vector=::start1))
Readers: bounds-start1.
Writers: This slot is read-only.

Slot: end1 ¶

Type: alexandria:array-length
Initform: (alexandria:required-argument (quote serapeum/vector=::end1))
Readers: bounds-end1.
Writers: This slot is read-only.

Slot: start2 ¶

Type: alexandria:array-index
Initform: (alexandria:required-argument (quote serapeum/vector=::start2))
Readers: bounds-start2.
Writers: This slot is read-only.

Slot: end2 ¶

Type: alexandria:array-length
Initform: (alexandria:required-argument (quote serapeum/vector=::end2))
Readers: bounds-end2.
Writers: This slot is read-only.

Structure: heap ¶

Create an empty (max) heap.

SIZE is a hint for at least how many items will be used; it is not a limit but providing it speeds up initializing the heap.

ELEMENT-TYPE is like the ‘:element-type’ argument to ‘make-array’. It may, or may not, restrict the element type of the heap, depending on the request type and what the Lisp implementation supports. It is for optimization, not type safety.

KEY and TEST are used to order the heap elements.

Package

Source

heap.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: vector ¶

Package: common-lisp.
Type: vector
Initform: #()
Readers: heap-vector.
Writers: This slot is read-only.

Slot: key ¶

Type: function
Initform: (function identity)
Readers: heap-key.
Writers: (setf heap-key).

Slot: test ¶

Type: function
Initform: (function >=)
Readers: heap-test.
Writers: (setf heap-test).

Structure: static-binding ¶

Package

serapeum/static-let.

Source

static-let.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: name ¶

Type: symbol
Initform: (quote serapeum/static-let::unknown)
Readers: name.
Writers: (setf name).

Slot: value ¶

Readers: value.
Writers: (setf value).

Slot: initializedp ¶

Type: boolean
Readers: initializedp.
Writers: (setf initializedp).

Slot: read-only ¶

Type: boolean
Readers: read-only.
Writers: (setf read-only).

Slot: lock ¶

Type: (or null bordeaux-threads:lock)
Readers: lock.
Writers: This slot is read-only.

Structure: struct-to-try-instantiating ¶

Package: serapeum.
Source: clos.lisp.
Direct superclasses: structure-object.

Structure: subenv ¶

Minimal lexical environment.

Package

internal-definitions.lisp.

Source

Direct superclasses

Direct methods

%constructor=.
constructor-values/generic.
make-load-form.
print-object.
read-only-struct-slot-names.

Direct slots

Slot: vars ¶

Type: list
Initform: (alexandria:required-argument (quote serapeum/internal-definitions::vars))
Readers: subenv-vars.
Writers: This slot is read-only.

Slot: funs ¶

Type: list
Initform: (alexandria:required-argument (quote serapeum/internal-definitions::funs))
Readers: subenv-funs.
Writers: This slot is read-only.

Slot: blocks ¶

Type: list
Initform: (alexandria:required-argument (quote serapeum/internal-definitions::blocks))
Readers: subenv-blocks.
Writers: This slot is read-only.

Slot: tags ¶

Type: list
Initform: (alexandria:required-argument (quote serapeum/internal-definitions::tags))
Readers: subenv-tags.
Writers: This slot is read-only.

Structure: unbound ¶

Placeholder for an unbound variable.

Package

Source

definitions.lisp.

Direct superclasses

Direct methods

make-load-form.
read-only-struct-slot-names.

Direct slots

Slot: var ¶

Type: symbol
Initform: (alexandria:required-argument (quote serapeum::var))
Readers: unbound-var.
Writers: This slot is read-only.

Next: Types, Previous: Structures, Up: Internals [Contents][Index]

6.2.9 Classes

Class: %binding ¶

Package

internal-definitions.lisp.

Source

Direct subclasses

fun.
macro.
symbol-macro.
var.

Direct methods

binding-init.
binding-name.

Direct slots

Slot: name ¶

Type: symbol
Initargs: :name
Readers: binding-name.
Writers: This slot is read-only.

Slot: init ¶

Type: serapeum/internal-definitions::expr
Initargs: :init
Readers: binding-init.
Writers: This slot is read-only.

Class: float-vector ¶

Package: serapeum/vector=.
Source: vector=.lisp.
Direct superclasses: numeric-vector.

Class: fun ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.
Direct superclasses: %binding.

Class: internal-definitions-env ¶

Package

internal-definitions.lisp.

Source

Direct methods

Direct Default Initargs

Initarg	Value
`:env`	`nil`
`:decls`	`nil`

Direct slots

Slot: vars ¶

Type: list

Slot: var-aliases ¶

Type: list

Slot: decls ¶

Type: list
Initargs: :decls

Slot: hoisted-vars ¶

Type: list

Slot: labels ¶

Package: common-lisp.
Type: list

Slot: exprs ¶

Type: list

Slot: global-symbol-macros ¶

Type: list

Slot: env ¶

The Lisp environment.

Initargs: :env

Class: macro ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.
Direct superclasses: %binding.

Class: numeric-vector ¶

Package

Source

Direct superclasses

vector-wrapper.

Direct subclasses

float-vector.
rat-vector.

Direct methods

compare-elements.

Class: op-env ¶

Package

serapeum/op.

Source

op.lisp.

Direct methods

op-env-lambda.

Direct slots

Slot: body ¶

Type: list
Initargs: :body, :body

Slot: vars ¶

Type: list
Initargs: :vars

Slot: rest-op? ¶

Type: symbol
Initargs: :rest-op?

Class: rat-vector ¶

Package: serapeum/vector=.
Source: vector=.lisp.
Direct superclasses: numeric-vector.
Direct methods: compare-elements.

Class: symbol-macro ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.
Direct superclasses: %binding.

Class: test/= ¶

Package

Source

Direct superclasses

test/rat=.

Direct subclasses

test/equalp.

Direct methods

compare-elements.
test.fn.

Class: test/char-equal ¶

Package

Source

Direct superclasses

test/char=.

Direct subclasses

test/equalp.

Direct methods

compare-elements.
compare-elements.
test.fn.

Class: test/char= ¶

Package

Source

Direct subclasses

test/char-equal.
test/eql.

Direct methods

compare-elements.
compare-elements.
test.fn.

Class: test/eq ¶

Package: serapeum/vector=.
Source: vector=.lisp.
Direct subclasses: test/eql.
Direct methods: test.fn.

Class: test/eql ¶

Package

Source

Direct superclasses

test/char=.
test/eq.
test/rat=.

Direct subclasses

test/equal.

Direct methods

test.fn.

Class: test/equal ¶

Package: serapeum/vector=.
Source: vector=.lisp.
Direct superclasses: test/eql.
Direct subclasses: test/equalp.
Direct methods: test.fn.

Class: test/equalp ¶

Package

Source

Direct superclasses

test/=.
test/char-equal.
test/equal.

Direct methods

compare-elements.
test.fn.

Class: test/rat= ¶

Package

Source

Direct subclasses

test/=.
test/eql.

Direct methods

compare-elements.
compare-elements.
compare-elements.
compare-elements.
compare-elements.

Class: var ¶

Package: serapeum/internal-definitions.
Source: internal-definitions.lisp.
Direct superclasses: %binding.

Class: vector-wrapper ¶

Package

Source