The generic-cl Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The generic-cl Reference Manual

This is the generic-cl Reference Manual, version 0.3, generated automatically by Declt version 2.4 patchlevel 1 "Will Decker" on Mon Jul 29 15:44:14 2019 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

= GENERIC-CL =
:AUTHOR: Alexander Gutev
:EMAIL: 
:toc: preamble
:toclevels: 4
:icons: font
:idprefix:

ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:caution-caption: :fire:
:important-caption: :exclamation:
:warning-caption: :warning:
endif::[]


GENERIC-CL provides a generic function wrapper over various functions
in the Common Lisp standard, such as equality predicates and sequence
operations. The goal of this wrapper is to provide a standard
interface to common operations, such as testing for the equality of
two objects, which is extensible to user-defined types.


== Usage ==

The generic function interface is contained in the `GENERIC-CL`
package. This package should be used rather than `COMMON-LISP`, as it
shadows the symbols, in the `COMMON-LISP` package, which name a
function for which there is a generic function wrapper. `GENERIC-CL`
additionally reexports the remaining non-shadowed symbols in
`COMMON-LISP`.

TIP: The `GENERIC-CL-USER` package is also provided, which contains
all the symbols in the `CL-USER` package and `GENERIC-CL`. This
package is intended to be used only at the REPL.


== Generic Interfaces ==

The generic function interface is divided into the following
categories:


=== Equality ===

The equality interface provides functions for testing for equality of
objects.

<> is the generic binary equality predicate function to
implement for user-defined types. <> and
<> are the n-ary equality predicates similar to the
functions with the same names in the `COMMON-LISP` package.


==== EQUALP ====

Generic Function: `EQUALP A B`

Returns true if object `A` is equal to object `B`.

Methods:

* `NUMBER NUMBER`
+
Returns true if `A` and `B` represent the same numeric value, by
`CL:=`.

* `CHARACTER CHARACTER`
+
Returns true if `A` and `B` represent the same character, by
`CL:CHAR=`.

* `CONS CONS`
+
Returns true if the `CAR` of `A` is equal (by `EQUALP`) to the
`CAR` of `B` and if the `CDR` of `A` is equal (by `EQUALP`) to
the `CDR` of `B`.

* `VECTOR VECTOR`
+
Returns true if `A` and `B` are vectors of the same length and
each element of `A` is equal (by `EQUALP`) to the corresponding
element of `B`.

* `ARRAY ARRAY`
+
Multi-dimensional arrays.
+
Returns true if `A` and `B` have the same dimensions and each
element of `A` is equal (by `EQUALP`) to the corresponding
element of `B`.

* `STRING STRING`
+
Returns true if both strings are equal, by `CL:STRING=`.

* `PATHNAME PATHNAME`
+
Returns true if both `PATHNAME` objects are functionally equivalent,
by `UIOP:PATHNAME-EQUAL`.

* `T T`
+
Default method.
+
Returns true if `A` and `B` are the same object, by `CL:EQ`.


[[equalp-nary, =]]
==== = ====

Function: `= X &REST XS`

Returns true if all objects in `XS` are equal (by `EQUALP`) to `X`.


[[not-equalp-nary, /=]]
==== /= ====

Function: `= X &REST XS`

Returns true if at least one object in `XS` is not equal (by `EQUALP`)
to `X`.


=== Comparison ===

The comparison interface provides functions for comparing objects in
terms of greater than, less than, greater than or equal to and less
than or equal to relations.

<>, <>, <>, <> are the
generic binary comparison functions to implement for user-defined
types. It is sufficient to just implement `LESSP` as the remaining
functions have default methods that are implemented in terms of
`LESSP`.

<>, <>, <>,
<> are the n-ary comparison functions similar to
the functions with the same names in the `COMMON-LISP` package.


==== LESSP ====

Generic Function: `LESSP A B`

Returns true if object `A` is less than object `B`.

TIP: It is sufficient to just implement this function, for
user-defined types, as the rest of the comparison functions have
default (`T T`) methods which are implemented in terms of `LESSP`.

Methods:

* `NUMBER NUMBER`
+
Returns true if the numeric value of `A` is less than the numeric
value of `B`, by `CL:<`.

* `CHARACTER CHARACTER`
+
Returns true if the character code of `A` is less than the
character code of `B`, by `CL:CHAR<`.

* `STRING STRING`
+
Returns true if the string `A` is lexicographically less than
`B`, by `CL:STRING<`.


==== LESS-EQUAL-P ====

Generic Function: `LESS-EQUAL-P A B`

Returns true if object `A` is less than or equal to object `B`.

Methods:

* `NUMBER NUMBER`
+
Returns true if the numeric value of `A` is less than or equal to
the numeric value of `B`, by `+CL:<=+`.

* `CHARACTER CHARACTER`
+
Returns true if the character code of `A` is less than or equal
to the character code of `B`, by `+CL:CHAR<=+`.

* `STRING STRING`
+
Returns true if the string `A` is lexicographically less than or
equal to `B`, by `+CL:STRING<=+`.

* `T T`
+
Returns true if either `A` is less than `B` (by <>) or `A`
is equal to `B` (by <>).
+
[source,lisp]
----
(or (lessp a b) (equalp a b))
----


==== GREATERP ====

Generic Function: `GREATERP A B`

Returns true if object `A` is greater than object `B`.

Methods:

* `NUMBER NUMBER`
+
Returns true if the numeric value of `A` is greater than the
numeric value of `B`, by `CL:>`.

* `CHARACTER CHARACTER`
+
Returns true if the character code of `A` is greater than the
character code of `B`, by `CL:CHAR>`.

* `STRING STRING`
+
Returns true if the string `A` is lexicographically greater than
`B`, by `CL:STRING>`.

* `T T`
+
Returns true if `A` is not less than or equal to `B`, by <>.
+
[source,lisp]
----
(not (less-equal-p a b))
----


==== GREATER-EQUAL-P ====

Generic Function: `GREATER-EQUAL-P A B`

Returns true if object `A` is greater than or equal to object `B`.

Methods:

* `NUMBER NUMBER`
+
Returns true if the numeric value of `A` is greater than or equal
to the numeric value of `B`, by `CL:>=`.

* `CHARACTER CHARACTER`
+
Returns true if the character code of `A` is greater than or
equal to the character code of `B`, by `CL:CHAR>=`.

* `STRING STRING`
+
Returns true if the string `A` is lexicographically greater than
or equal to `B`, by `CL:STRING>=`.

* `T T`
+
Returns true if `A` is not less than `B`, by <>.
+
[source,lisp]
----
(not (lessp a b))
----


==== COMPARE ====

Generic Function: `COMPARE A B`

Returns:

`:LESS`:: if `A` is less than `B`.
`:EQUAL`:: if `A` is equal to `B`.
`:GREATER`:: if `A` is greater than `B`.

The default `T T` method returns:

`:LESS`:: if `(LESSP A B)` is true.
`:EQUAL`:: if `(EQUALP A B)` is true.
`:GREATER`:: otherwise.


[[lessp-nary, <]]
==== < ====

Function: `< X &REST XS`

Returns true if each argument is less than the following argument, by
<>.


[[less-equal-p-nary, \<=]]
==== +<=+ ====

Function: `+<= X &REST XS+`

Returns true if each argument is less than or equal to the following
argument, by <>.


[[greaterp-nary, >]]
==== > ====

Function: `> X &REST XS`

Returns true if each argument is greater than the following argument,
by <>.


[[greater-equal-p-nary, >=]]
==== >= ====

Function: `>= X &REST XS`

Returns true if each argument is greater than or equal to the
following argument, by <>.


==== MIN ====

Function: `MIN X &REST XS`

Returns the minimum argument.

The comparisons are performed by <>. Any one of the arguments which
is less than or equal to the other arguments may be returned.


==== MAX ====

Function: `MAX X &REST XS`

Returns the maximum argument.

The comparisons are performed by <>. Any one of the arguments
which is greater than or equal to the other arguments may be returned.


=== Arithmetic ===

The arithmetic interface provides generic functions for arithmetic
operations.

<>, <>, <>, <> are the generic binary
arithmetic functions, and <> is the generic unary negation
function, to implement for user-defined types.

<>, <>, <>, <>
are the n-ary arithmetic functions similar to the functions with the
same names in the `COMMON-LISP` package.


==== ADD ====

Generic Function: `ADD A B`

Returns the sum of `A` and `B`.

Methods:

* `NUMBER NUMBER`
+
Returns `(CL:+ A B)`.


==== SUBTRACT ====

Generic Function: `SUBTRACT A B`

Returns the difference of `A` and `B`.

Methods:

* `NUMBER NUMBER`
+
Returns `(CL:- A B)`.


==== MULTIPLY ====

Generic Function: `MULTIPLY A B`

Returns the product of `A` and `B`.

Methods:

* `NUMBER NUMBER`
+
Returns `(CL:* A B)`.


==== DIVIDE ====

Generic Function: `DIVIDE A B`

Returns the quotient of `A` and `B`. If `A` is the constant `1`, the
result should be the reciprocal of `B`.

Methods:

* `NUMBER NUMBER`
+
Returns `(CL:/ A B)`.


==== NEGATE ====

Generic Function: `NEGATE A`

Returns the negation of `A`.

Methods:

* `NUMBER`
+
Returns `(CL:- A)`.


[[add-nary, +]]
==== + ====

Function: `+ X &REST XS`

Returns the sum of all the arguments, computed by reducing over the
argument list with the <> function.

If no arguments are provided, `0` is returned. If a single argument is
provided it is returned.


[[subtract-nary, -]]
==== - ====

Function: `- X &REST XS`

Returns the difference of all the arguments, computed by reducing over
the argument list with the <> function.

If only a single argument is provided the negation of that argument is
returned, by the <> function.


[[multiply-nary, *]]
==== * ====

Function: `* X &REST XS`

Returns the product of all the arguments, computed by reducing over
the argument list with the <> function.

If no arguments are provided, `1` is returned. If a single argument is
provided it is returned.


[[divide-nary, /]]
==== / ====

Function: `/ X &REST XS`

Returns the quotient of all the arguments, computed by reducing over
the argument list with the <> function.

If only a single argument is provided, the reciprocal of the argument,
`(DIVIDE 1 X)`, is returned.


==== 1+ ====

Generic Function: `1+ A`

Returns `A + 1`.

Methods:

* `NUMBER`
+
Returns `(CL:1+ A)`.

* `T`
+
Returns `(ADD A 1)`.


==== 1- ====

Generic Function: `1- A`

Returns `A - 1`.

Methods:

* `NUMBER`
+
Returns `(CL:1- A)`.

* `T`
+
Returns `(SUBTRACT A 1)`.


==== INCF ====

Macro: `INCF PLACE &OPTIONAL (DELTA 1)`

Increments the value of `PLACE` by `DELTA`, which defaults to `1`,
using the <> function.

Effectively:

[source,lisp]
----
(setf place (add place delta))
----


==== DECF ====

Macro: `DECF PLACE &OPTIONAL (DELTA 1)`

Decrements the value of `PLACE` by `DELTA`, which defaults to `1`,
using the <> function.

Effectively:

[source,lisp]
----
(setf place (subtract place delta))
----


==== MINUSP ====

Generic Function: `MINUSP A`

Returns true if `A` is less than zero.

Methods:

* `NUMBER`
+
Returns `(CL:MINUSP A)`.

* `T`
+
Returns true if `A` compares less than `0`, by <>.
+
[source,lisp]
----
(lessp a 0)
----


==== PLUSP ====

Generic Function: `PLUSP A`

Returns true if `A` is greater than zero.

Methods:

* `NUMBER`
+
Returns `(CL:PLUSP A)`.

* `T`
+
Returns true if `A` compares greater than `0`, by <>.
+
[source,lisp]
----
(greaterp a 0)
----


==== ZEROP ====

Generic Function: `ZEROP A`

Returns true if `A` is equal to zero.

Methods:

* `NUMBER`
+
Returns `(CL:ZEROP A)`.

* `T`
+
Returns true if `A` is equal to `0`, by <>.
+
[source,lisp]
----
(equalp a 0)
----


==== SIGNUM ====

Generic Function: `SIGNUM A`

Returns `-1`, `0` or `1` depending on whether `A` is negative, is
equal to zero or is positive.

Methods:

* `SIGNUM`
+
Returns `(CL:SIGNUM A)`.

* `T`
+
Returns `-1` if `(MINUSP A)` is true, `0` if `(ZEROP A)` is true,
`1` otherwise.


==== ABS ====

Generic Function: `ABS A`

Returns the absolute value of `A`.

Methods:

* `NUMBER`
+
Returns `(CL:ABS A)`.

* `T`
+
If `(MINUSP A)` is true, returns `(NEGATE A)` otherwise returns
`A`.
+
[source,lisp]
----
(if (minusp a)
    (negate a)
    a)
----


==== EVENP ====

Generic Function: `EVENP A`

Returns true if `A` is even.

Methods:

* `NUMBER`
+
Returns `(CL:EVENP A)`

* `T`
+
Returns `(ZEROP (MOD A 2))`


==== ODDP ====

Generic Function: `ODDP A`

Returns true if `A` is odd.

Methods:

* `NUMBER`
+
Returns `(CL:ODDP A)`

* `T`
+
Returns `(NOT (EVENP A))`


==== FLOOR ====

Generic Function: `FLOOR N D`

Performs the division `N/D` if `D` is provided, otherwise equivalent
to `N/1`, and returns the result rounded towards negative infinity as
the first value, and the remainder `N - result * D` as the second return
value.

Methods:

* `NUMBER`
+
Returns `(CL:FLOOR N D)` if `D` is provided otherwise returns
`(CL:FLOOR N)`.


==== CEILING ====

Generic Function: `CEILING N D`

Performs the division `N/D` if `D` is provided, otherwise equivalent
to `N/1`, and returns the result rounded towards positive infinity as
the first value, and the `N - result * D` as the second return value.

Methods:

* `NUMBER`
+
Returns `(CL:CEILING N D)` if `D` is provided otherwise returns
`(CL:CEILING N)`.


==== TRUNCATE ====

Generic Function: `TRUNCATE N D`

Performs the division `N/D` if `D` is provided, otherwise equivalent
to `N/1`, and returns the result rounded towards zero as the first
value, and the remainder `N - result * D` as the second return value.

Methods:

* `NUMBER`
+
Returns `(CL:TRUNCATE N D)` if `D` is provided otherwise returns
`(CL:TRUNCATE N)`.


==== ROUND ====

Generic Function: `ROUND N D`

Performs the division `N/D` if `D` is provided, otherwise equivalent
to `N/1`, and returns the result rounded towards the nearest integer
as the first value, and the remainder `N - result * D` as the second
return value.

If the result lies exactly halfway between two integers, it is rounded
to the nearest even integer.

Methods:

* `NUMBER`
+
Returns `(CL:ROUND N D)` if `D` is provided otherwise returns
`(CL:ROUND N)`.


==== MOD ====

Generic Function: `MOD N D`

Returns the remainder of the <> operation on `N` and `D`.

Methods:

* `NUMBER`
+
Returns `(CL:MOD N D)`.

* `T`
+
Returns the second return value of `(FLOOR N D)`.


==== REM ====

Generic Function: `REM N D`

Returns the remainder of the <> operation on `N` and `D`.

Methods:

* `NUMBER`
+
Returns `(CL:REM N D)`.

* `T`
+
Returns the second return value of `(TRUNCATE N D)`.


=== Objects ===

The object interface provides miscellaneous functions for manipulating
objects.


==== COPY ====

Generic Function: `COPY OBJECT &KEY &ALLOW-OTHER-KEYS`

Returns a copy of `OBJECT`. If `OBJECT` is mutable, by some other
functions, then the returned object should be distinct (not `EQ`) from
`OBJECT`, otherwise the return value may be identical (`EQ`) to
`OBJECT`.

IMPORTANT: This function may accept additional keyword arguments which
specify certain options as to how the object should be copied. Methods
specialized on sequences accept a `:DEEP` keyword parameter, which if
provided and is true a deep copy is returned otherwise a shallow copy
is returned. If a user-defined type acts as a container or sequence
then the `COPY` method for that type should also accept the `DEEP`
keyword parameter.

Methods:

* `CONS`
+
Returns a new list which contains all the elements in
`OBJECT`. If `:DEEP` is provided and is true, the list returned
contains a copy of the elements, copied using `(COPY ELEM :DEEP
     T)`.

* `VECTOR`
+
Returns a new vector which contains all the elements in
`OBJECT`. If `:DEEP` is provided and is true, the vector returned
contains a copy of the elements, copied using `(COPY ELEM :DEEP
     T)`.

* `ARRAY`
+
Multi-Dimensional Arrays.
+
Returns a new array, of the same dimensions as `OBJECT`, which
contains all the elements in `OBJECT`. If `:DEEP` is provided and
is true, the array returned contains a copy of the elements,
copied using `(COPY ELEM :DEEP T)`.

* `T`
+
Simply returns `OBJECT`.
+
This method is provided to allow sequences containing arbitrary
objects to be copied safely, without signaling a condition, and
to avoid having to write simple pass-through methods for each
user-defined type.
+
However this means that if the object, for which there is no
specialized copy method, can be mutated, the constraints of the
`COPY` function are violated.


==== DEFSTRUCT ====

Macro: `DEFSTRUCT OPTIONS &REST SLOTS`

This is the same as `CL:DEFSTRUCT` however a <> method for the
structure type is automatically generated, which simply calls the
structure's copier function. If the `(:COPIER NIL)` option is
provided, the `COPY` method is not generated.


==== COERCE ====

Generic Function: `COERCE OBJECT TYPE`

Coerces `OBJECT` to the type `TYPE`.

The default (`T T`) method simply calls `CL:COERCE`.


=== Iterator ===

The iterator interface is a generic interface for iterating over the
elements of sequences and containers.

Implemented for lists, vectors, multi-dimensional arrays and
<>'s.

.Basic Usage
[source,lisp]
----
(loop
   with it = (iterator sequence) ; Create iterator for SEQUENCE
   until (endp it) ; Loop until the iterator's end position is reach
   do
     (pprint (at it)) ; Print element at iterator's position
     (advance it)) ; Advance iterator to next position
----


[[iterator-struct, ITERATOR]]
==== Base Iterator Type ====

Structure: `ITERATOR`

This structure serves as the base iterator type and is used by certain
methods of generic functions to specialize on iterators.

All iterators should inherit from (include) `ITERATOR`, in order for
methods which specialize on iterators to be invoked.

IMPORTANT: A <> method should be implemented for user-defined
iterators.


==== Iterator Creation ====

<> is the high-level function for creating iterators,
whereas <> AND <> are the
generic iterator creation functions to implement for user-defined
sequence types.


===== MAKE-ITERATOR =====

Generic Function: `MAKE-ITERATOR SEQUENCE START END`

Returns an iterator for the sub-sequence of `SEQUENCE`, identified by
the range `[START, END)`.

`START` is the index of the first element to iterate over. `0`
indicates the first element of the sequence.

`END` is the index of the element at which to terminate the iteration,
i.e.  1 + the index of the last element to be iterated over. `NIL`
indicates iterate till the end of the sequence.


===== MAKE-REVERSE-ITERATOR =====

Generic Function: `MAKE-REVERSE-ITERATOR SEQUENCE START END`

Returns an iterator for the sub-sequence of `SEQUENCE`, identified by
the range `[START, END)`, in which the elements are iterated over in
reverse order.

IMPORTANT: Even though the elements are iterated over in reverse order,
`START` and `END` are still relative to the start of the sequence, as
in `MAKE-ITERATOR`.

`START` is the index of the last element to visit.

`END` is the index of the element following the first element to be
iterated over.


[[iterator-func, ITERATOR]]
===== ITERATOR =====

Function: `ITERATOR SEQUENCE &KEY (START 0) END FROM-END`

Returns an iterator for the sub-sequence of `SEQUENCE` identified by
the range `[START, END)`.

`START` (defaults to `0` - the start of the sequence) and `END`
(defaults to `NIL` - the end of the sequence) are the start and end
indices of the sub-sequence to iterate over (see <> and
<> for more a detailed description).

If `FROM-END` is true a reverse iterator is created (by
<>) otherwise a normal iterator is created (by
<>).


==== Mandatory Functions ====

These functions have to be implemented for all user-defined iterators.


===== AT =====

Generic Function: `AT ITERATOR`

Returns the value of the element at the current position of the
iterator `ITERATOR`.

WARNING: The effects of calling this method, after the iterator has
reached the end of the subsequence are unspecified.


===== ENDP =====

Generic Function: `ENDP ITERATOR`

Returns true if the iterator is at the end of the subsequence, false
otherwise.

The end of the subsequence is defined as the position past the last
element of the subsequence, that is the position of the iterator after
advancing it (by <>) from the position of the last element.

If the subsequence is empty `ENDP` should immediately return true.

NOTE: The default `T` method calls `CL:ENDP` since this function
shadows the `CL:ENDP` function.


===== ADVANCE =====

Generic Function: `ADVANCE ITERATOR`

Advances the iterator to the next element in the subsequence. After
this method is called, subsequent calls to <> should return the
next element in the sequence or if the last element has already been
iterated over, <> should return true.


==== Optional Functions ====

Implementing the following functions for user-defined iterators is
optional either because a default method is provided, which is
implemented using the mandatory functions, or the function is only
used by a select few sequence operations.


===== START =====

Generic Function: `START ITERATOR`

Returns the element at the current position of the iterator, if the
iterator is not at the end of the sequence, otherwise returns `NIL`.

The default method first checks whether the end of the iterator has
been reached, using `ENDP`, and if not returns the current element
using `AT`.

The default method is equivalent to the following:

[source,lisp]
----
(unless (endp iterator)
  (at iterator))
----

[[setf-at, (SETF AT)]]
===== (SETF AT) =====

Generic Function: `(SETF AT) VALUE ITERATOR`

Sets the value of the element at the position, in the sequence,
specified by the iterator.

WARNING: The effects of calling this function when, the iterator is
past the end of the subsequence are unspecified.

IMPORTANT: Implementing this function is only mandatory if destructive
sequence operations will be used.


===== ADVANCE-N =====

Generic Function: `ADVANCE-N ITERATOR N`

Advances the iterator by `N` elements.

IMPORTANT: The position of the iterator, after calling this function,
should be equivalent to the positioned obtained by calling <>
`N` times.

The default method simply calls <>, on `ITERATOR`, `N` times.


==== Macros ====

Macros for iteratoring over a generic sequence. Analogous to
`CL:DOLIST`.


===== DOITERS =====

Macro: `DOITERS (&REST ITERS) &BODY BODY`

Iterates over one or more sequences with the sequence iterators bound
to variables.

Each element of `ITERS` is a list of the form `(IT-VAR
SEQUENCE . ARGS)`, where `IT-VAR` is the variable to which the
iterator is bound, `SEQUENCE` is the sequence which will be iterated
over and `ARGS` are the remaining arguments passed to the
<> function.

The bindings to the `IT-VAR`'s are visible to the forms in `BODY`,
which are executed once for each element in the sequence. After each
iteration the sequence iterators are <>'d. The loop
terminates when the end of a sequence is reached.


===== DOITER =====

Macro: `DOITER (ITER &REST ARGS) &BODY BODY`

The is the same as <> except only a single sequence is
iterated over.


===== DOSEQ =====

Macro: `DOSEQ (ELEMENT SEQUENCE &REST ARGS) &BODY BODY`

Iterates over the elements of `SEQUENCE`. `ARGS` are the remaining
arguments passed to the <> function.

The forms in `BODY` are executed once for each element, with the value
of the element bound to `ELEMENT`. If `ELEMENT` is a list, the
sequence element is destructured, as if by `DESTRUCTURING-BIND`
according to the pattern specified by `ELEMENT`.


=== Collector ===

The collector interface is a generic interface for accumulating items
in a sequence/container.

Implemented for lists, vectors and <>'s.

.Basic Usage
[source,lisp]
----
;; Create collector for the sequence, in this case an empty list
(let ((c (make-collector nil)))
  (accumulate c 1) ; Collect 1 into the sequence
  (accumulate c 2) ; Collect 2 into the sequence
  (extend c '(3 4 5)) ; Collect 3 4 5 into the sequence
  (collector-sequence c)) ; Get the resulting sequence => '(1 2 3 4 5)
----


==== MAKE-COLLECTOR ====

Generic Function: `MAKE-COLLECTOR SEQUENCE &KEY FRONT`

Returns a collector for accumulating items to the end of the sequence
`SEQUENCE`. If `:FRONT` is provided and is true, the items are
accumulated to the front of the sequence rather than end.

IMPORTANT: The collector may destructively modify `SEQUENCE` however
it is not mandatory and may accumulate items into a copy of `SEQUENCE`
instead.


==== ACCUMULATE ====

Generic Function: `ACCUMULATE COLLECTOR ITEM`

Accumulates `ITEM` into the sequence associated with the collector
`COLLECTOR`.


==== COLLECTOR-SEQUENCE ====

Generic Function: `COLLECTOR-SEQUENCE COLLECTOR`

Returns the underlying sequence associated with the collector
`COLLECTOR`. The sequence should contain all items accumulated up to
the call to this function.

WARNING: The effects of accumulating items into the sequence, by
<> or <>, after this function is
called, are unspecified.

CAUTION: The sequence returned might not be the same object passed to
<>.


==== EXTEND ====

Generic Function: `EXTEND COLLECTOR SEQUENCE`

Accumulates all elements of the sequence `SEQUENCE` into the sequence
associated with the collector `COLLECTOR`.

If `SEQUENCE` is an iterator all elements up-to the end of the
iterator (till <> returns true) should be accumulated.

NOTE: Implementing this method is optional as default methods are
provided for iterators and sequences, which simply accumulate each
element one by one using <>.

Methods:

* `T ITERATOR`
+
Accumulates all elements returned by the iterator `SEQUENCE`
(till `(ENDP SEQUENCE)` returns true), into the sequence
associated with the collector. The elements are accumulated one
by one using <>.
+
NOTE: The iterator is copied thus the position of the iterator passed
as an argument is not modified.

* `T T`
+
Accumulates all elements of `SEQUENCE`, into the sequence
associated with the collector. The elements are accumulated one
by one using <>.
+
NOTE: The sequence iteration is done using the <> interface.


=== Sequences ===

Generic sequence functions.


==== Creation ====

The following functions are for creating a sequence into which items
will be accumulated using the collector interface.


===== CLEARED =====

Generic Function: `CLEARED SEQUENCE &KEY &ALLOW-OTHER-KEYS`

Returns a new empty sequence, of the same type and with the same
properties as `SEQUENCE`, suitable for accumulating items into it
using the collector interface.

NOTE: Individual methods may accept keyword parameters which specify
certain options of the sequence which is to be created.

Methods:

* `LIST`
+
Returns `NIL`.

* `VECTOR`
+
Returns an adjustable vector of the same length as `SEQUENCE`,
with the fill-pointer set to `0`.
+
If the `:KEEP-ELEMENT-TYPE` argument is provided and is true, the
element type of the new vector is the same as the element type of
`SEQUENCE`.


===== MAKE-SEQUENCE-OF-TYPE =====

Generic Function: `MAKE-SEQUENCE-OF-TYPE TYPE ARGS`

Returns a new empty sequence of type `TYPE`. `ARGS` are the type
arguments, if any.

The default method creates a built-in sequence of the same type as
that returned by:

[source,lisp]
----
(make-sequence (cons type args) 0)
----


===== SEQUENCE-OF-TYPE =====

Function: `SEQUENCE-OF-TYPE TYPE`

Creates a new sequence of type `TYPE`, using
<>.

If `TYPE` is a list the `CAR` of the list is passed as the first
argument, to `MAKE-SEQUENCE-OF-TYPE`, and the `CDR` is passed as the
second argument. Otherwise, if `TYPE` is not a list, it is passed as
the first argument and `NIL` is passed as the second argument.


==== Sequence Elements ====

===== ELT =====

Generic Function: `ELT SEQUENCE INDEX`

Returns the element at position `INDEX` in the sequence `SEQUENCE`.

Methods:

* `SEQUENCE T` and `VECTOR T`
+
Returns `(CL:ELT SEQUENCE INDEX)`.

* `ARRAY T`
+
Multi-Dimensional Arrays.
+
Returns `(ROW-MAJOR-AREF SEQUENCE INDEX)`.

* `T T`
+
Creates an iterator for `SEQUENCE`, with start position `INDEX`,
and returns the first element returned by the iterator.


===== (SETF ELT) =====

Generic Function: `(SETF ELT) VALUE SEQUENCE INDEX`

Sets the value of the element at position `INDEX` in the sequence
`SEQUENCE`.

Methods:

* `T SEQUENCE T` and `T VECTOR T`
+
Returns `(SETF (CL:ELT SEQUENCE INDEX) VALUE)`.

* `T ARRAY T`
+
Multi-Dimensional Arrays.
+
Returns `(SETF (ROW-MAJOR-AREF SEQUENCE INDEX) VALUE)`

* `T T T`
+
Creates an iterator for `SEQUENCE`, with start position `INDEX`,
and sets the value of the element at the starting position of the
iterator.


===== FIRST =====

Generic Function: `FIRST SEQUENCE`

Returns the first element in the sequence `SEQUENCE`.

Implemented for lists, vectors and multi-dimensional arrays. For
multi-dimensional arrays, the first element is obtained by
`ROW-MAJOR-AREF`.

The default method is implemented using <>, i.e. is
equivalent to:

[source,lisp]
----
(elt sequence index)
----


===== LAST =====

Generic Function: `LAST SEQUENCE &OPTIONAL (N 0)`

Returns the `N`'th element from the last element of the sequence
`SEQUENCE`. `N` defaults to `0` which indicates the last element. `1`
indicates the second to last element, `2` the third to last and so on.

Implemented for lists, vectors and multi-dimensional arrays. For
multi-dimensional arrays, the last element is obtained by:

[source,lisp]
----
(row-major-aref sequence (- (array-total-size array) 1 n))
----

The default method is implemented using <>, i.e. is
equivalent to:

[source,lisp]
----
(elt sequence (- (length sequence) 1 n))
----

CAUTION: The behaviour of this function differs from `CL:LAST` when
called on lists, it returns the last element rather than the last
`CONS` cell. The <> function performs the same function as
`CL:LAST`.


===== LASTCDR =====

Function: `LASTCDR LIST &OPTIONAL (N 1)`

This function is equivalent to `CL:LAST` list function.

Returns the `CDR` of the `N`'th `CONS` cell from the end of the list.


===== ERASE =====

Generic Function: `ERASE SEQUENCE INDEX`

Removes the element at index `INDEX` from the sequence `SEQUENCE`.

Destructively modifies `SEQUENCE`.

Methods:

* `VECTOR T`
+
Shifts the elements following `INDEX` one element towards the
front of the vector and shrinks the vector by one element.
+
CAUTION: Signals a `TYPE-ERROR` if the vector is not adjustable.

NOTE: This method is not implemented for lists as removing the first
element of a list cannot be implemented (efficiently) as a side effect
alone.


==== Sequence Length ====

===== LENGTH =====

Generic Function: `LENGTH SEQUENCE`

Returns the number of elements in the sequence `SEQUENCE`. If
`SEQUENCE` is an iterator, returns the number of remaining elements to
be iterated over.

This function is implemented for all Common Lisp sequences, returning
the length of the sequence (by `CL:LENGTH`), multi-dimensional arrays,
returning the total number of elements in the array (by
`ARRAY-TOTAL-SIZE`), and <>'s / hash tables, returning the
total number of elements in the map/table.

The following default methods are implemented:

* `ITERATOR`
+
Returns the number of elements between the iterator's current
position (inclusive) and the end of the iterator's subsequence.
+
This is implemented by advancing the iterator (by <>) till
<> returns true, thus is a linear `O(n)` time operation.
+
More efficient specialized methods are provided for iterators to
sequences for which the size is known.

* `T`
+
Returns the length of the generic sequence by creating an iterator to
the sequence and calling the <> specialized
method. Thus this is a linear `O(n)`, in time, operation unless a more
efficient method, which is specialized on the sequence's iterator
type, is implemented.


===== EMPTYP =====

Generic Function: `EMPTYP SEQUENCE`

Returns true if the sequence `SEQUENCE` is empty.

Implemented for lists, vectors, multi-dimensional arrays (always
returns `NIL`) and <>'s.

The default returns true if <> returns true for a newly created
iterator for `SEQUENCE`.


===== CLEAR =====

Generic Function: `CLEAR SEQUENCE`

Destructively removes all elements from the sequence `SEQUENCE`.

Implemented for vectors and <>'s.


==== Subsequences ====


===== SUBSEQ =====

Generic Function: `SUBSEQ SEQUENCE START &OPTIONAL END`

Returns a new sequence that contains the elements of `SEQUENCE` at the
positions in the range `[START, END)`. If `SEQUENCE` is an iterator,
an iterator for the sub-sequence relative to the current position of
the iterator is returned.

`START` is the index of the first element of the subsequence, with `0`
indicating the start of the sequence. if `SEQUENCE` is an iterator,
`START` is the number of times the iterator should be <>'d to
reach the first element of the subsequence.

`END` is the index of the element following the last element of the
subsequence. `NIL` (the default) indicates the end of the sequence. If
`SEQUENCE` is an iterator, `END` is the number of times the iterator
should be <>'d till the end position is reached.

Methods:

* `SEQUENCE T`
+
Returns the subsequence using `CL:SUBSEQ`.

* `ITERATOR T`
+
Returns a subsequence iterator which wraps a copy of the original
iterator.

* `T T`
+
Returns the subsequence of the generic sequence. This requires that
the <> method, the <> interface and <>
interface are implemented for the generic sequence type.


===== (SETF SUBSEQ) =====

Generic Function: `(SETF SUBSEQ) NEW-SEQUENCE SEQUENCE START &OPTIONAL END`

Replaces the elements of `SEQUENCE` at the positions in the range
`[START, END)`, with the elements of `NEW-SEQUENCE`. The shorter
length of `NEW-SEQUENCE` and the number of elements between `START`
and `END` determines how many elements of `SEQUENCE` are actually
modified.

See <> for more details of how the `START` and `END` arguments are
interpreted.

Methods:

* `SEQEUNCE SEQUENCE T`
+
Sets the elements of the subsequence using `(SETF CL:SUBSEQ)`.

* `T T T`
+
Sets the elements of the generic sequence using the <>
interface, which should be implemented for both the types of
`SEQUENCE` and `NEW-SEQUENCE`. This method requires that the
<> method is implemented for the iterator type of `SEQUENCE`.


==== Sequence Operations ====

Generic function wrappers, which are identical in behavior to their
counterparts in the `COMMON-LISP` package, are provided for the
following sequence operations:

* `FILL`
* `REPLACE`
* `REDUCE`
* `COUNT`
* `COUNT-IF`
* `COUNT-IF-NOT`
* `FIND`
* `FIND-IF`
* `FIND-IF-NOT`
* `POSITION`
* `POSITION-IF`
* `POSITION-IF-NOT`
* `SEARCH`
* `MISMATCH`
* `REVERSE`
* `NREVERSE`
* `SUBSTITUTE`
* `NSUBSTITUTE`
* `SUBSTITUTE-IF`
* `NSUBSTITUTE-IF`
* `SUBSTITUTE-IF-NOT`
* `NSUBSTITUTE-IF-NOT`
* `REMOVE`
* `DELETE`
* `REMOVE-IF`
* `DELETE-IF`
* `REMOVE-IF-NOT`
* `DELETE-IF-NOT`
* `REMOVE-DUPLICATES`
* `DELETE-DUPLICATES`

Two methods are implemented, for all functions, which are specialized
on the following types:

* `CL:SEQUENCE`
+
Simply calls the corresponding function in the `COMMON-LISP`
package.

* `T`
+
Implements the sequence operation for generic sequences using the
iterator interface.
+
The non-destructive functions only require that the
<>, the
<> interface and <> method are
implemented for the sequence's type.
+
The destructive versions may additionally require that the optional
<> method is implemented as well.

IMPORTANT: The default value of the `:TEST` keyword arguments is
<>. This should be the default value when
implementing methods for user-defined sequence types. The `:TEST-NOT`
keyword arguments have been removed.

The following functions are identical in behavior to their `CL`
counterparts, however are re-implemented using the iterator
interface. Unlike the functions in the previous list, these are not
generic functions since they take an arbitrary number of sequences as
arguments.

* `EVERY`
* `SOME`
* `NOTEVERY`
* `NOTANY`

The following functions either have no `CL` counterparts or differ
slightly in behavior from their `CL` counterparts:


===== MERGE =====

Generic Function: `MERGE SEQUENCE1 SEQUENCE2 PREDICATE &KEY`

Returns a new sequence, of the same type as `SEQUENCE1`, containing
the elements of `SEQUENCE1` and `SEQUENCE2`. The elements are ordered
according to the function `PREDICATE`.

IMPORTANT: Unlike `CL:MERGE` this function is non-destructive.


===== NMERGE =====

Generic Function: `MERGE SEQUENCE1 SEQUENCE2 PREDICATE &KEY`

Same as `MERGE` however is permitted to destructively modify either
`SEQUENCE1` or `SEQUENCE2`.


===== SORT =====

Generic Function: `SORT SEQUENCE &KEY TEST KEY`

Returns a new sequence of the same type as `SEQUENCE`, with the same
elements sorted according to the order determined by the function
`TEST`. `TEST` is <> by default.

IMPORTANT: Unlike `CL:SORT` this function is non-destructive.

TIP: For the default method to be efficient, efficient <>
<> and <> methods should be implemented for the
iterator type of `SEQUENCE`.


===== STABLE-SORT =====

Generic Function: `STABLE-SORT SEQUENCE &KEY TEST KEY`

Same as `SORT` however the sort operation is guaranteed to be
stable. `TEST` is <> by default.

IMPORTANT: Unlike `CL:STABLE-SORT` this function is non-destructive.

TIP: For the default method to be efficient, efficient <>
<> and <> methods should be implemented for the
iterator type of `SEQUENCE`.


===== NSORT =====

Generic Function: `NSORT SEQUENCE &KEY TEST KEY`

Same as `SORT` however is permitted to destructively modify
`SEQUENCE`.


===== STABLE-NSORT =====

Generic Function: `STABLE-NSORT SEQUENCE &KEY TEST KEY`

Same as `STABLE-SORT` however is permitted to destructively modify
`SEQUENCE`.


===== CONCATENATE =====

Generic Function: `CONCATENATE SEQUENCE &REST SEQUENCES`

Returns a new sequence, of the same type as `SEQUENCE`, containing all
the elements of `SEQUENCE` and of each sequence in `SEQUENCES`, in the
order they are supplied.

IMPORTANT: Unlike `CL:CONCATENATE` does not take a result type
argument.


===== NCONCATENATE =====

Generic Function: `NCONCATENATE RESULT &REST SEQUENCES`

Destructively concatenates each sequence in `SEQUENCES` to the
sequence `RESULT`.

Returns the result of the concatenation.

CAUTION: Whilst this function is permitted to destructively modify
`RESULT` and `SEQUENCES`, it is not required and may return a new
sequence instead. Thus do not rely on this function for its side
effects.


===== MAP =====

Generic Function: `MAP FUNCTION SEQUENCE &REST SEQUENCES`

Creates a new sequence, of the same type as `SEQUENCE` (by
<>), containing the result of applying `FUNCTION` to each
element of SEQUENCE and each element of each `SEQUENCE` in
`SEQUENCES`.

IMPORTANT: This function is equivalent (in behavior) to the `CL:MAP`
function except the resulting sequence is always of the same type as
the first sequence passed as an argument, rather than being determined
by a type argument.


===== NMAP =====

Generic Function: `NMAP RESULT FUNCTION &REST SEQUENCES`

Destructively replaces each element of `RESULT` with the result of
applying `FUNCTION` to each element of `RESULT` and each element of
each sequence in SEQUENCES.

Returns the resulting sequence.

IMPORTANT: This function is similar in behavior to `CL:MAP-INTO` with
the exception that if `RESULT` is a vector, then `FUNCTION` is only
applied on the elements up-to the fill pointer i.e. the fill-pointer
is not ignored.

CAUTION: Whilst this function is permitted to modify `RESULT`, it is
not required and may return the result in a new sequence instead. Thus
do not rely on this function for its side effects.


===== MAP-INTO =====

Generic Function: `MAP-INTO RESULT FUNCTION &REST SEQUENCES`

Applies `FUNCTION` on each element of each sequence in `SEQUENCES` and
accumulates the result in RESULT, using the <> interface.

Returns the resulting sequence.

CAUTION: Whilst this function is permitted to modify `RESULT`, it is
not required and may return the result in a new sequence instead. Thus
do not rely on this function for its side effects.


===== MAP-TO =====

Generic Function: `MAP-TO TYPE FUNCTION &REST SEQUENCES`

Applies `FUNCTION` to each element of each sequence in `SEQUENCES` and
stores the result in a new sequence of type `TYPE` (created using
<>).  Returns the sequence in which the results of
applying the function are stored.

IMPORTANT: This function is equivalent in arguments, and almost
equivalent in behavior, to `CL:MAP`. The only difference is that if
`TYPE` is a subtype of vector, the vector returned is adjustable with
a fill-pointer. A `NIL` type argument is not interpreted as do not
accumulate the results, use <> for that.


===== FOREACH =====

Function: `FOREACH &REST SEQUENCES`

Applies `FUNCTION` on each element of each sequence in `SEQUENCES`.

Returns `NIL`.

=== Lazy Sequences ===

Lazy sequences are sequences in which the elements are only computed
when they are actually referenced, rather than being computed
immediately.

Lazy sequences are implemented with `LAZY-SEQ` structure which is
similar to a `CONS` cell, however the `CDR`, the `TAIL` slot of the
`LAZY-SEQ` structure, stores a function which computes and returns the
remainder of the sequence, rather than storing the sequence directly.

==== LAZY-SEQ Structure ====

Structure: `LAZY-SEQ`

Lazy sequence analogous to a `CONS`.

.*Slots:*
`HEAD`:: The first element of the sequence. _Can be accessed with
the `LAZY-SEQ-HEAD` accessor function._

`TAIL`:: A function of zero arguments which returns a `LAZY-SEQ`
containing the remaining elements in the sequence. If there are no
more elements the function returns `NIL`. _Can be accessed with the
`LAZY-SEQ-TAIL` accessor function_.

.*Implemented Interfaces:*
* <<_equalp,`EQUALP`>> function.

* <<_copy,`COPY`>> function. Accepts the `:DEEP` keyword parameter
      which indicates whether the elements should also be copied.

* <<_coerce,`COERCE`>> function.

* <<_mandatory_functions,Mandatory Functions>>, of the
<<_iterator,Iterator>> interface.

* <<_make_collector,`MAKE-COLLECTOR`>> function of the
<<_collector,Collector>> interface.
+
--
NOTE: The method specialized on ``LAZY-SEQ``'s returns a collector
for a `LIST` since it does not make sense to be collecting items,
which have already been evaluated, into a `LAZY-SEQ`.
--

* <<_subseq,SUBSEQ>> function which returns the subsequence as a
`LAZY-SEQ`.

* Methods, specialized on `LAZY-SEQ`, are implemented for the
following <<_sequence_operations,Sequence Operations>> and their
destructive counterparts:
+
--
** `REMOVE`
** `REMOVE-IF`
** `REMOVE-IF-NOT`
** `SUBSTITUTE`
** `SUBSTITUTE-IF`
** `SUBSTITUTE-IF-NOT`
** `REMOVE-DUPLICATES`


These methods return a `LAZY-SEQ` with the sequence operation
'lazily' applied to the sequence.

NOTE: The destructive versions are identical to the
non-destructive versions.
--


==== MAKE-LAZY-SEQ ====

Function: `MAKE-LAZY-SEQ HEAD TAIL`

Creates a `LAZY-SEQ` with the `HEAD` slot initialized to `HEAD` and
the `TAIL` slot initialized to `TAIL`.

IMPORTANT: `TAIL` must be a function of zero arguments that returns
either a `LAZY-SEQ` containing the remaining elements in the sequence
or `NIL` indicating there are no more elements.

NOTE: For efficiency the function in `TAIL` should only compute the
remainder of the sequence the first time it is called. Remaining calls
to the function should simply return the previously computed result.

TIP: The <<_lazy_seq_macro,`LAZY-SEQ`>> macro automatically wraps the
form, which returns the remainder of the sequence, in a function.

==== LAZY-SEQ Macro ====

Macro: `LAZY-SEQ HEAD &OPTIONAL TAIL`

Creates a `LAZY-SEQ` instance with the `HEAD` slot initialized to
`HEAD` and the `TAIL` slot initialized to a function which evaluates
the form `TAIL`.

NOTE: The function only evaluates `TAIL` the first time it is
call. Subsequent calls will simply return the previously computed
result.


==== COERCE Methods ====

The following `COERCE` methods are provided which specialize on
``LAZY-SEQ``'s.

- `LAZY-SEQ (EQL 'LIST)`
+
--
Returns a list containing all the elements in the `LAZY-SEQ`.

WARNING: If the `LAZY-SEQ` is an infinite sequence, this function
will never terminate.
--


==== CONCATENATE Methods ====

Method: `CONCATENATE LAZY-SEQ &REST SEQUENCES` +
Method: `NCONCATENATE LAZY-SEQ &REST SEQUENCES` +
Method: `CONCATENATE-TO (EQL 'LAZY-SEQ) &REST SEQUENCES`

Concatenates sequences to a lazy sequence.

The concatenation is done lazily, that is the elements of the
sequences, in `SEQUENCES`, are only added to the lazy sequence when
elements past the end of the `LAZY-SEQ`, passed in the first argument,
are referenced.

The `CONCATENATE-TO` method returns a lazy sequence containing the
concatenation of `SEQUENCES`. Like `CONCATENATE` and `NCONCATENATE`
the concatenation is done lazily.

NOTE: `NCONCATENATE` is identical to `CONCATENATE`, that is the
`LAZY-SEQ` is not destructively modified.


==== MAP Methods ====

Method: `MAP FUNCTION LAZY-SEQ &REST SEQUENCES` +
Method: `NMAP FUNCTION LAZY-SEQ &REST SEQUENCES` +
Method: `MAP-INTO LAZY-SEQ FUNCTION &REST SEQUENCES` +
Method: `MAP-TO (EQL 'LAZY-SEQ) FUNCTION &REST SEQUENCES`

Applies a function on each element of the `LAZY-SEQ` and of each
sequence in `SEQUENCES`.

The result is a `LAZY-SEQ` with the function applied lazily to each
element, that is it is only applied when that element is referenced.

The `MAP-TO` method returns the result, of lazily applying the
function on each element of each sequence in `SEQUENCES`, in a
`LAZY-SEQ`.

NOTE: `NMAP` and `MAP-INTO` do not destructively modify the `LAZY-SEQ`
but return a new sequence instead.


==== Utilities ====

===== RANGE =====

Function: `RANGE START &OPTIONAL END STEP`

Returns a `LAZY-SEQ` containing all numbers in the range `[START,
END)`.

If `END` is `NIL`, an infinite sequence, without an upper bound, is
returned.

`STEP`, defaults to `1`, is the delta by which each number is incremented
to obtain the next successive number in the sequence.


=== Generic Hash-Tables ===

This interface provides a hash-table data structure with the generic
function <> as the hash function and the generic function
<> as the key comparison function. This
allows the hash-tables to utilize keys of user-defined types, whereas
the keys of standard hash tables are limited to numbers, characters,
lists and strings.

The generic hash-tables are implemented using
https://github.com/metawilm/cl-custom-hash-table[CL-CUSTOM-HASH-TABLE]. If
the Common Lisp implementation supports creating hash-tables with
user-defined hash and comparison functions, standard hash-tables are
used. However if the implementation does not support user-defined hash
and comparison functions, a fallback solution is used, which is a
custom hash-table implementation on top of standard hash-tables. The
<> structure wraps the custom hash-table which allows
methods methods to be specialized on a single type `HASH-MAP`
regardless of whether standard or custom hash-tables are used. If the
`HASH-MAP` wrapper were not used, two identical methods would have to
be implemented, one specializing on standard hash-tables and one
specializing on custom hash-tables. More identical methods would have
to be implemented if the method has hash-table specializers for more
than one arguments, leading to a combinatorial explosion.

The functions in this interface are specialized on the `HASH-MAP`
type, due to the issue described above, thus use this type, created
with <>, rather than built-in hash-tables. If a
hash-table is obtained from an external source, use <> or
<> to convert it to a `HASH-MAP`.

*Standard Hash-Table Analogues:*

[width="80%",options="header"]
|====
| `CL:HASH-TABLE`| `HASH-MAP`

| GETHASH| GET
| HASH-TABLE-COUNT| LENGTH
| REMHASH| ERASE
| CLRHASH| CLEAR
|====



==== HASH-MAP ====

Structure: `HASH-MAP` with slots: `TABLE`

Function: `HASH-MAP TABLE`

The `HASH-MAP` structure wraps a standard `HASH-TABLE` or
`CUSTOM-HASH-TABLE`. The `TABLE` slot, accessed with `HASH-MAP-TABLE`,
stores the underlying hash-table.

The `HASH-MAP` function creates a hash-map wrapping a hash table
passed as its only argument.


===== Implemented Interfaces =====

The iterator interface is implemented for ``HASH-MAP``'s. Each element
returned by the iterator is a `CONS` with the key in the `CAR` and the
corresponding value in the `CDR`. The order in which the entries are
iterated over is unspecified. Likewise it is unspecified which entries
will be iterated over if `START` is non-zero and/or `END` is non-NIL,
the only guarantee being that `END - START` entries are iterated
over. The reverse iterator iterates over the entries in the same order
as the normal iterator due to the order of iteration being
unspecified.

The <> method for the `HASH-MAP` iterator sets the value
corresponding to the key of the current entry, being iterated over, to
the value passed as the argument to `SETF`.

The collector interface is implemented for ``HASH-MAP``'s. The
<> method expects a `CONS` where the `CAR` is the key of
the entry to create and the `CDR` is the corresponding value.

An <> method is implemented for ``HASH-MAP``'s which returns
true if both maps contain the same number of entries and each key in
the first map is present in the second map, with the corresponding
value in the first map equal (by `EQUALP`) to the corresponding value
in the second
map.

WARNING: if the two maps have different test functions, the `EQUALP`
method is not necessarily symmetric i.e. `(EQUALP A B)` does not imply
`(EQUALP B A)`.

A <> method is implemented for ``HASH-MAP``'s which by default
creates a new map with the same entries as the original map. If `:DEEP
T` is provided the values (but not the keys as they should be
immutable) are copied by `(COPY VALUE :DEEP T)`.


==== MAKE-HASH-MAP ====

Function: `MAKE-HASH-MAP &KEY TEST &ALLOW-OTHER-KEYS`

Creates a `HASH-MAP` wrapping a hash table with test function `TEST`,
which defaults to `#'GENERIC-CL:EQUALP`.

If `TEST` is either the symbol or function `GENERIC-CL:EQUALP`, then a
generic hash-table with hash function <> and comparison function
<> is created. Otherwise `TEST` may be any
of the standard hash-table test specifiers.

The function accepts all additional arguments (including
implementation specific arguments) accepted by `CL:MAKE-HASH-TABLE`.


==== ENSURE-HASH-MAP ====

Function: `ENSURE-HASH-MAP THING`

If `MAP` is a <> returns it, otherwise if `MAP` is a
`HASH-TABLE` or `CUSTOM-HASH-TABLE` returns a `HASH-MAP` which wraps
it. Signals an error if `MAP` is not of the aforementioned types.


==== HASH-MAP-TEST ====

Function: `HASH-MAP-TEST MAP`

Returns the test function, as a symbol, of the underlying hash table.

CAUTION: On some implementations the return value is not
`GENERIC-CL:EQUALP`, even if the hash table has `HASH` and
`GENERIC-CL:EQUALP` as its hash and comparison functions.


==== HASH ====

Generic Function: `HASH OBJECT`

Hash function for hash tables with the `GENERIC-CL:EQUALP` test
specifier.

Returns a hash code for `OBJECT`, which is a non-negative fixnum. If
two objects are equal (under <>) then the hash
codes, for the two objects, returned by `HASH` should be equal.

The default method calls `CL:SXHASH` which satisfies the constraint
that `(CL:EQUAL X Y)` implies `(= (CL:SXHASH X) (CL:SXHASH
Y))`.

IMPORTANT: Currently no specialized method is provided for
container/sequence objects such as lists. The default method does not
violate the constraint for lists (but does violate the constraints for
non-string vectors) as keys, provided they only contain numbers,
characters, symbols, strings and other lists as elements.


==== GET ====

Generic Function: `GET KEY MAP &OPTIONAL DEFAULT`

Returns the value of the entry corresponding to the key `KEY` in the
map `MAP`. If the `MAP` does not contain any entry with that key,
`DEFAULT` is returned. The second return value is true if an entry
with key `KEY` was found in the map, false otherwise.

Methods are provided for ``HASH-MAP``'s, standard ``HASH-TABLE``'s,
association lists (`ALISTS`) and property lists (`PLISTS`). For
`ALISTS` the <> key comparison function is used. For `PLISTS`
the `EQ` key comparison function is used.


==== (SETF GET) ====

Generic Function: `(SETF GET) VALUE KEY MAP &OPTIONAL DEFAULT`

Sets the value of the entry corresponding to the key `KEY` in the map
`MAP`. `DEFAULT` is ignored.

IMPORTANT: Only a method for `HASH-MAPS` and `HASH-TABLES` is
provided.


==== ENSURE-GET ====

Macro: `ENSURE-GET KEY MAP &OPTIONAL DEFAULT`

Like `GET` however if `KEY` is not found in `MAP` it is added, by
`(SETF GET)` with the value `DEFAULT`.

The first return value is the value corresponding to the key `KEY`, or
`DEFAULT` if `KEY` is not found in `MAP`. The second return value is
true if `KEY` was found in `MAP`, false otherwise.


==== ERASE Method ====

Method: `ERASE (MAP HASH-MAP) KEY`

Removes the entry with key `KEY` from `MAP`.

Returns true if the map contained an entry with key `KEY`.


==== HASH-MAP-ALIST ====

Function: `HASH-MAP-ALIST MAP`

Returns an association list (`ALIST`) containing all the entries in
the map `MAP`.


==== ALIST-HASH-MAP ====

Function: `ALIST-HASH-MAP ALIST &REST ARGS`

Returns a <> containing all entries in the association list
`ALIST`. `ARGS` are the additional arguments passed to
<>.


==== MAP-KEYS ====

Generic Function: `MAP-KEYS MAP`

Returns a sequence containing all the keys in the map `MAP`.

NOTE: Specialized only on ``HASH-MAP``'s and ``CL:HASH-TABLE``'s.


==== MAP-VALUES ====

Generic Function: `MAP-VALUES MAP`

Returns a sequence containing all the values in the map `MAP`.

NOTE: Specialized only on ``HASH-MAP``'s and ``CL:HASH-TABLE``'s.


==== COERCE Methods ====

The following `COERCE` methods are provided for `HASH-MAPS`:

* `HASH-MAP (EQL 'ALIST)`
+
Returns an association list (`ALIST`) containing all the entries in
the map. Equivalent to <>.

* `HASH-MAP (EQL 'PLIST)`
+
Returns a property list (`PLIST`) containing all the entries in
the map.


=== Set Operations ===

The set interface provides generic functions for performing set
operations and implementations of those operations for a hash-set data
structure.

Generic function wrappers are provided over the following Common Lisp
set operation functions:

* `SUBSETP`
* `ADJOIN`
* `INTERSECTION`
* `NINTERSECTION`
* `SET-DIFFERENCE`
* `NSET-DIFFERENCE`
* `SET-EXCLUSIVE-OR`
* `NSET-EXCLUSIVE-OR`
* `UNION`
* `NUNION`

For each function, methods specializing on `LISTS`, which simply call
the corresponding function in the `CL` package, and <>'s are
implemented. Each function accepts all keyword arguments accepted by
the corresponding `CL` functions however they are ignored by the
`HASH-MAP` methods.

NOTE: <>'s may be used as sets, in which case the set
elements are stored in the keys. The values of the map's entries are
ignored by the set operations, thus the map values of the sets
returned, by the set operation functions, are unspecified.


==== ADJOIN ====

Generic Function: `ADJOIN ITEM SET &KEY &ALLOW-OTHER-KEYS`

Returns a new set, of the same type as `SET`, which contains `ITEM`
and all elements in `SET`.

IMPORTANT: This function is non-destructive. A new set is always returned even if
`SET` is a <> / <>.

NOTE: Accepts all keyword arguments accepted by `CL:ADJOIN` however
they are ignored by the <> method.


==== NADJOIN ====

Generic Function: `ADJOIN ITEM SET &KEY &ALLOW-OTHER-KEYS`

Same as <> however is permitted to destructively modify `SET`.

IMPORTANT: The set returned is `EQ` to `SET` in the case of `SET`
being a <> however is note required to be `EQ` and is not
`EQ` if `SET` is a list. Thus this function should not be relied upon
for its side effects.

NOTE: Implemented for both lists and  <>'s.


==== MEMBERP ====

Generic Function: `MEMBERP ITEM SET &KEY &ALLOW-OTHER-KEYS`

Returns true if `ITEM` is an element of the set `SET`.

NOTE: Implemented for both lists and <>'s. All keyword arguments
accepted by `CL:MEMBER` are accepted, however are ignored by the
`HASH-MAP` method.


==== HASH-SET ====

Structure: `HASH-SET`

A hash-set is a <> however it is used to indicate that only
the keys are important. This allows the <> and <>
methods, specialized on `HASH-SET`'s to be implemented more
efficiently, than the methods specialized on ``HASH-MAP``'s, as the
map values are not compared/copied.

The implementation of the <> interface for `HASH-SETS` differs
from the implementation for `HASH-MAPS` in that only the set elements,
i.e. the keys of the underlying hash table, are returned rather than
the key-value pairs.

NOTE: The set operations are implemented both for ``HASH-MAP``'s and
``HASH-SET``'s.


==== HASH-TABLE-SET ====

Function: `HASH-TABLE-SET TABLE`

Returns a `HASH-SET` structure wrapping the standard `HASH-TABLE` or
`CUSTOM-HASH-TABLE`.


==== HASH-SET ====

Function: `HASH-SET &REST ELEMENTS`

Returns a <> with elements `ELEMENTS`.


==== MAKE-HASH-SET ====

Function: `MAKE-HASH-SET &KEY &ALLOW-OTHER-KEYS`

Returns a new empty <>.

Accepts the same keyword arguments as <>. The default
`TEST` function is <>.


==== COERCE Methods ====

The following `COERCE` Methods are provided:

* `LIST (EQL 'HASH-SET)`
+
Returns a `HASH-SET` containing the elements in the list.


=== Math Functions ===

Generic function wrappers are provided over a number of math
functions. Methods specialized on `NUMBER` are provided, which simply
call the corresponding functions in the `CL` package. The idea of this
interface is to allow the mathematical functions to be extended to
vectors and matrices. This interface might not used as often as the
previous interfaces, thus is contained in a separate package
`GENERIC-MATH-CL` which exports all symbols exported by `GENERIC-CL`
and shadows the math functions.

Generic function wrappers are provided for the following functions:

* `SIN`
* `COS`
* `TAN`
* `ASIN`
* `ACOS`
* `ATAN`
* `SINH`
* `COSH`
* `TANH`
* `ASINH`
* `ACOSH`
* `ATANH`
* `EXP`
* `EXPT`
* `LOG`
* `SQRT`
* `ISQRT`
* `REALPART`
* `IMAGPART`
* `CIS`
* `CONJUGATE`
* `PHASE`
* `NUMERATOR`
* `DENOMINATOR`
* `RATIONAL`
* `RATIONALIZE`


=== Miscellaneous ===

==== DEFCONSTANT ====

Macro: `DEFCONSTANT SYMBOL VALUE &OPTIONAL DOCUMENTATION`

Ensures that `SYMBOL` is a constant with a value that is equal, by
`GENERIC-CL:EQUALP` to `VALUE`. This means that if `SYMBOL` already
names a constant, which occurs when the `DEFCONSTANT` form is
reevaluated, no condition will be signalled if its value is equal (by
`GENERIC-CL:EQUALP`) to `VALUE`.

NOTE: Implemented using `ALEXANDRIA:DEFINE-CONSTANT`


== Optimization ==

There is an overhead associated with generic functions. Code making
use of the generic function interface will be slower than code which
calls the `CL` functions directly, due to the cost of dynamic method
dispatch. For most cases this will not result in a noticeable decrease
in performance, however for those cases where it does there is an
optimization.

This library is built on top of
https://github.com/alex-gutev/static-dispatch[STATIC-DISPATCH], which
is a library that allows generic-function dispatch to be performed
statically, at compile-time, rather than dynamically, at runtime. The
library allows a call to a generic function to be replaced with the
body of the appropriate method, which is selected based on the type
declarations of its arguments.

For a generic function call to be inlined, the generic function has to
be declared inline (either locally or globally), and the arguments
must either have type declarations (if they are variables), or be
surrounded in a `THE` form.

.Example
[source,lisp]
----
(let ((x 1))
  (declare (inline equalp)
	   (type number x))

  (equalp x (the number (+ 3 4))))
----

This will result in the call to the `EQUALP` function being replaced
with the body of the `NUMBER NUMBER` method.

The n-argument equality, comparison and arithmetic functions also have
associated compiler-macros which replace the calls to the n-argument
functions with multiple inline calls to the binary functions, e.g. `(=
1 2 3)` is replaced with `(and (equalp 1 2) (equalp 1 3))`.

Thus the following should also result in the `EQUALP` function calls
being statically dispatched, though this has not yet been tested:

[source,lisp]
----
(let ((x 1))
  (declare (inline equalp)
	   (type number x))

  (= x (the number (+ 3 4))))
----

IMPORTANT: STATIC-DISPATCH requires the ability to extract `TYPE` and
 `INLINE` declarations from implementation specific environment
 objects. This is provided by the
 https://github.com/alex-gutev/cl-environments[CL-ENVIRONMENTS]
 library however in order for it to work on all supported
 implementations, the `ENABLE-HOOK` function (exported by
 `GENERIC-CL`) has to be called at some point before the generic
 function call is compiled.

See https://github.com/alex-gutev/static-dispatch[STATIC-DISPATCH] and
https://github.com/alex-gutev/cl-environments[CL-ENVIRONMENTS] for
more information about these optimizations and the current
limitations.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 generic-cl

Author

Alexander Gutev

License

MIT

Description

Standard Common Lisp functions implemented using generic functions.

Version

0.3

Dependencies
Source

generic-cl.asd (file)

Component

src (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 generic-cl/src

Parent

generic-cl (system)

Location

src/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 generic-cl.asd

Location

generic-cl.asd

Systems

generic-cl (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 generic-cl/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 generic-cl/src/util.lisp

Parent

src (module)

Location

src/util.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 generic-cl/src/object.lisp

Parent

src (module)

Location

src/object.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 generic-cl/src/equality.lisp

Parent

src (module)

Location

src/equality.lisp

Exported Definitions
Internal Definitions

numbers? (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 generic-cl/src/comparison.lisp

Parent

src (module)

Location

src/comparison.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 generic-cl/src/arithmetic.lisp

Parent

src (module)

Location

src/arithmetic.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.8 generic-cl/src/sequences.lisp

Parent

src (module)

Location

src/sequences.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.9 generic-cl/src/iterator.lisp

Parent

src (module)

Location

src/iterator.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.10 generic-cl/src/collector.lisp

Parent

src (module)

Location

src/collector.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.11 generic-cl/src/cl-sequences.lisp

Parent

src (module)

Location

src/cl-sequences.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.12 generic-cl/src/hash-tables.lisp

Parent

src (module)

Location

src/hash-tables.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.13 generic-cl/src/sets.lisp

Parent

src (module)

Location

src/sets.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.14 generic-cl/src/generic-sequences.lisp

Parent

src (module)

Location

src/generic-sequences.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.15 generic-cl/src/lazy-seq.lisp

Parent

src (module)

Location

src/lazy-seq.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.16 generic-cl/src/misc.lisp

Parent

src (module)

Location

src/misc.lisp

Exported Definitions

defconstant (macro)


Previous: , Up: Lisp files   [Contents][Index]

4.1.17 generic-cl/src/math.lisp

Parent

src (module)

Location

src/math.lisp

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 generic-cl.impl

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

5.2 generic-cl.math

Source

package.lisp (file)

Use List

generic-cl

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Symbol macros

Symbol Macro: *
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Expansion

*

Symbol Macro: +
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Expansion

+

Symbol Macro: -
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Expansion

-

Symbol Macro: /
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Expansion

/


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: decf PLACE &optional DELTA

Decrements the place by DELTA (defaults to 1) using the generic SUBTRACT function.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Macro: defconstant SYMBOL VALUE &optional DOCUMENTATION

Ensures that SYMBOL is a constant with a value that is equal by GENERIC-CL:EQUALP to VALUE. Implemented using ALEXANDRIA:DEFINE-CONSTANT.

DOCUMENTATION is an optional documentation string.

Package

generic-cl.impl

Source

misc.lisp (file)

Macro: defstruct OPTIONS &rest SLOTS

Sames as CL:DEFSTRUCT except that a COPY method, for the struct, is automatically generated which invokes the structure’s copier function. If a NIL :COPIER option is provided, the COPY method is not automatically generated.

Package

generic-cl.impl

Source

object.lisp (file)

Macro: doiter (ITER &rest ARGS) &body BODY

Sames as DOITERS however for the special case of iterating over a single sequence.

ITER is the variable to which the iterator is bound. ARGS are the arguments passed to the ITERATOR function.

Package

generic-cl.impl

Source

iterator.lisp (file)

Macro: doiters (&rest ITERS) &body BODY

Iterates over one or more sequences and binds the iterator of each sequence to a variable.

Each element of ITERS is a list of the form (IT-VAR SEQUENCE
. ARGS) where IT-VAR is the variable to which the iterator for SEQUENCE is bound. Args are the remaining arguments passed to the ITERATOR function (if any).

The forms in BODY are evaluated, with the iterator variable bindings visible to the forms, after which each iterator is advanced by one position, by the ADVANCE function. The forms are evaluated repeatedly until at least one iterator reaches the end of its sequence (ENDP returns true).

Package

generic-cl.impl

Source

iterator.lisp (file)

Macro: doseq (ELEMENT O!SEQUENCE &rest ARGS) &body BODY

Iterates over the elements of the sequence SEQUENCE. For each element the forms in BODY are evaluated with the symbol named by ELEMENT bound to the current element of the sequence. If ELEMENT is a list, destructuring is performed (as if by DESTRUCTURING-BIND) on the sequence element.

ARGS are additional arguments passed to the ITERATOR function.

The forms in BODY are surrounded in an implicit (BLOCK NIL ...) thus RETURN may be used to terminate the loop early. The return value of the DOSEQ form is NIL, unless it is terminated early by RETURN.

Package

generic-cl.impl

Source

iterator.lisp (file)

Macro: ensure-get O!KEY O!MAP &optional DEFAULT
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Macro: incf PLACE &optional DELTA

Increments the place by DELTA (defaults to 1) using the generic ADD function.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Macro: lazy-seq HEAD &optional TAIL

Creates a ‘LAZY-SEQ’ where HEAD is the first element in the sequence and TAIL is a form which computes the remainder of the sequence. TAIL is wrapped in a function that stores the result of evaluating FORM, the first time it is invoked, and returns the stored result in future invocations.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Compiler macros

Compiler Macro: * &rest XS
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Compiler Macro: + &rest XS
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Compiler Macro: - X &rest XS
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Compiler Macro: / X &rest XS
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Compiler Macro: /= FIRST &rest REST
Package

generic-cl.impl

Source

equality.lisp (file)

Compiler Macro: 1+ WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: 1- WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: < X1 &rest XS
Package

generic-cl.impl

Source

comparison.lisp (file)

Compiler Macro: <= X1 &rest XS
Package

generic-cl.impl

Source

comparison.lisp (file)

Compiler Macro: = FIRST &rest REST
Package

generic-cl.impl

Source

equality.lisp (file)

Compiler Macro: > X1 &rest XS
Package

generic-cl.impl

Source

comparison.lisp (file)

Compiler Macro: >= X1 &rest XS
Package

generic-cl.impl

Source

comparison.lisp (file)

Compiler Macro: abs WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: accumulate WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: acos WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: acosh WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: add WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: adjoin WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: advance WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: advance-n WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: asin WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: asinh WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: at WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: atan WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: atanh WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: ceiling WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: cis WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: clear WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: cleared WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: coerce WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: collector-sequence WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: compare WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: concatenate WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: concatenate-to WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: conjugate WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: copy WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: cos WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: cosh WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: count WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: count-if WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: count-if-not WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: delete WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: delete-duplicates WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: delete-if WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: delete-if-not WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: denominator WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: divide WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: elt WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: emptyp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: endp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: equalp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: erase WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: evenp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: exp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: expt WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: extend WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: fill WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: find WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: find-if WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: find-if-not WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: first WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: floor WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: get WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: greater-equal-p WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: greaterp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: hash WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: imagpart WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: intersection WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: isqrt WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: last WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: length WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: less-equal-p WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: lessp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: log WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: make-collector WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: make-iterator WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: make-reverse-iterator WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: make-sequence-of-type WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: map WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: map-into WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: map-keys WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: map-to WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: map-values WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: max X &rest XS
Package

generic-cl.impl

Source

comparison.lisp (file)

Compiler Macro: memberp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: merge WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: min X &rest XS
Package

generic-cl.impl

Source

comparison.lisp (file)

Compiler Macro: minusp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: mismatch WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: mod WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: multiply WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nadjoin WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nconcatenate WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: negate WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nintersection WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nmap WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nmerge WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nreverse WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nset-difference WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nset-exclusive-or WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nsort WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nsubstitute WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nsubstitute-if WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nsubstitute-if-not WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: numerator WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: nunion WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: oddp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: phase WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: plusp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: position WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: position-if WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: position-if-not WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: rational WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: rationalize WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: realpart WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: reduce WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: rem WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: remove WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: remove-duplicates WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: remove-if WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: remove-if-not WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: replace WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: reverse WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: round WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: set-difference WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: set-exclusive-or WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: signum WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: sin WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: sinh WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: sort WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: sqrt WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: stable-nsort WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: stable-sort WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: start WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: subseq WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: subsetp WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: substitute WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: substitute-if WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: substitute-if-not WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: subtract WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: tan WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: tanh WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.math

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: truncate WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: union WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp

Compiler Macro: zerop WHOLE &optional ENV

Compiler macro function for statically dispatched generic functions.

Package

generic-cl.impl

Source

/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20190710-git/static-dispatch.lisp


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Functions

Function: * &rest XS
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Function: + &rest XS
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Function: - X &rest XS
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Function: / X &rest XS
Package

generic-cl.impl

Source

arithmetic.lisp (file)

Function: /= FIRST &rest REST

Returns true if at least one object in REST is not equal, by EQUALP, to FIRST.

Package

generic-cl.impl

Source

equality.lisp (file)

Function: < X &rest XS
Package

generic-cl.impl

Source

comparison.lisp (file)

Function: <= X &rest XS
Package

generic-cl.impl

Source

comparison.lisp (file)

Function: = FIRST &rest REST

Returns true if each object in REST is equal, by EQUALP, to FIRST.

Package

generic-cl.impl

Source

equality.lisp (file)

Function: > X &rest XS
Package

generic-cl.impl

Source

comparison.lisp (file)

Function: >= X &rest XS
Package

generic-cl.impl

Source

comparison.lisp (file)

Function: alist-hash-map ALIST &rest ARGS

Returns an hash map containing all entries in the association list ALIST. ARGS are the additional arguments passed to MAKE-HASH-MAP.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: ensure-hash-map MAP

If MAP is a ‘HASH-MAP’ returns it, otherwise if MAP is a ‘HASH-TABLE’ or ‘CUSTOM-HASH-TABLE’ returns a ‘HASH-MAP’ which wraps it. Signals an error if MAP is not of the aforementioned types.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: every TEST &rest SEQS

Same as CL:EVERY except it can be applied to any sequence for which there the iterator interface is implemented.

Package

generic-cl.impl

Source

generic-sequences.lisp (file)

Function: foreach FUNCTION &rest SEQUENCES

Applies FUNCTION on each element of each sequence in SEQUENCES.

Package

generic-cl.impl

Source

generic-sequences.lisp (file)

Function: hash-map TABLE
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: hash-map-alist MAP

Returns an ALIST containing all the entries (key-value pairs) in the hash-map MAP.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: hash-map-p OBJECT
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: hash-map-table INSTANCE
Function: (setf hash-map-table) VALUE INSTANCE
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: hash-map-test MAP

Returns the TEST function (as a symbol) of the underlying hash-table of the ‘HASH-MAP’ MAP.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: hash-set &rest ELEMENTS

Returns a ‘HASH-SET’ with elements ELEMENTS.

Package

generic-cl.impl

Source

sets.lisp (file)

Function: hash-set-p OBJECT
Package

generic-cl.impl

Source

sets.lisp (file)

Function: hash-set-table INSTANCE
Function: (setf hash-set-table) VALUE INSTANCE
Package

generic-cl.impl

Source

sets.lisp (file)

Function: hash-table-set TABLE
Package

generic-cl.impl

Source

sets.lisp (file)

Function: iterator SEQUENCE &key START END FROM-END

Returns an iterator for the sub-sequence of SEQUENCE bounded by the range [START, END).

START is the index of the first element to iterate over. Defaults to 0.

END is the index of the element at which to terminate the iteration, the element itself is not visited. If END is NIL then the iteration continues till the end of the sequence. Defaults to NIL.

If FROM-END is T the elements are iterated in reverse
order. Defaults to NIL.

Package

generic-cl.impl

Source

iterator.lisp (file)

Function: lastcdr LIST &optional N

Equivalent to CL:LAST. Returns the CDR of the N’th CONS cell from the last CONS cell in LIST.

Package

generic-cl.impl

Source

cl-sequences.lisp (file)

Function: lazy-seq-head INSTANCE
Function: (setf lazy-seq-head) VALUE INSTANCE
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: lazy-seq-p OBJECT
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: lazy-seq-tail INSTANCE
Function: (setf lazy-seq-tail) VALUE INSTANCE
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: make-hash-map &rest ARGS &key &allow-other-keys

Creates a hash map. If TEST is GENERIC-CL:EQUALP (the default), a generic hash-table, with GENERIC-CL:HASH as the hash function and GENERIC-CL:EQUALP as the comparison function. If another value for test (the available options are specified in the documentation for CL:MAKE-HASH-TABLE) is given, the native hash function is used.

The remaining keyword arguments accepted by CL:MAKE-HASH-TABLE, are also accepted by this function.

The return value is always a HASH-MAP which wraps either the generic or Common Lisp hash-table.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: make-hash-set &rest ARGS &key &allow-other-keys

Creates a ‘HASH-SET’. The keyword arguments accepted by MAKE-HASH-MAP are accepted by MAKE-HASH-SET.

Package

generic-cl.impl

Source

sets.lisp (file)

Function: make-lazy-seq &key (HEAD HEAD) (TAIL TAIL)
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: max FIRST &rest XS

Returns the maximum argument, the argument that is greater than or equal to all the other arguments, the actual comparisons are done using GREATERP. Any argument which satisfies this condition may be returned.

Package

generic-cl.impl

Source

comparison.lisp (file)

Function: min FIRST &rest XS

Returns the minimum argument, the argument that is less than or equal to all the other arguments, the actual comparisons are done using LESSP. Any argument which satisfies this condition may be returned.

Package

generic-cl.impl

Source

comparison.lisp (file)

Function: notany TEST &rest SEQS

Same as CL:NOTANY except it can be applied to any sequence for which there the iterator interface is implemented.

Package

generic-cl.impl

Source

generic-sequences.lisp (file)

Function: notevery TEST &rest SEQS

Same as CL:NOTEVERY except it can be applied to any sequence for which there the iterator interface is implemented.

Package

generic-cl.impl

Source

generic-sequences.lisp (file)

Function: range START &optional END STEP

Returns a ‘LAZY-SEQ’ containing all numbers in the range [START, END). If END is NIL then an infinite sequence, without an upper bound is returned. STEP is the delta by which each number is incremented to obtain the next successive number.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: sequence-of-type TYPE

Creates a sequence of the type TYPE by calling MAKE-SEQUENCE-OF-TYPE.

If TYPE is a list, MAKE-SEQUENCE-OF-TYPE is called with the CAR of the list as the first argument, and the CDR of the list as the second argument. Otherwise MAKE-SEQUENCE-OF-TYPE is called with TYPE as the first argument and NIL as the second argument.

Package

generic-cl.impl

Source

collector.lisp (file)

Function: some TEST &rest SEQS

Same as CL:SOME except it can be applied to any sequence for which there the iterator interface is implemented.

Package

generic-cl.impl

Source

generic-sequences.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Generic functions

Generic Function: 1+ A

Returns A + 1.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: 1+ A
Method: 1+ (A number)
Generic Function: 1- A

Returns A - 1.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: 1- A
Method: 1- (A number)
Generic Function: abs A

Returns the absolute value of A.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: abs A
Method: abs (A number)
Generic Function: accumulate COLLECTOR ITEM

Adds ITEM to the sequence with collector COLLECTOR.

Package

generic-cl.impl

Source

collector.lisp (file)

Methods
Method: accumulate (SET hash-set) ITEM
Source

sets.lisp (file)

Method: accumulate (MAP hash-map) ITEM
Source

hash-tables.lisp (file)

Method: accumulate (C front-vector-collector) ITEM
Method: accumulate (VEC vector) ITEM
Method: accumulate (C front-list-collector) ITEM
Method: accumulate (C list-collector) ITEM
Generic Function: acos A

Returns the arc cosine of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: acos (A number)
Generic Function: acosh A

Returns the hyperbolic arc cosine of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: acosh (A number)
Generic Function: add A B

Returns the sum of A and B.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: add (A hash-map) (B hash-map)

Returns the union of set A and set B.

Source

sets.lisp (file)

Method: add (A number) (B number)
Generic Function: adjoin ITEM SET &key TEST KEY &allow-other-keys

Returns a new set which contains ITEM and all elements in set SET.

Methods specialized on lists also accept TEST and KEY keyword parameters. These parameters are ignored by other methods.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: adjoin ITEM (SET list) &key TEST KEY
Method: adjoin ITEM (SET hash-map) &key
Generic Function: advance ITERATOR

Advances ITERATOR to the next element of the sequence.

Package

generic-cl.impl

Source

iterator.lisp (file)

Methods
Method: advance (IT bound-lazy-seq-iterator)
Source

lazy-seq.lisp (file)

Method: advance (IT lazy-seq-iterator)
Source

lazy-seq.lisp (file)

Method: advance (IT sub-iterator)
Method: advance (ITER reverse-vector-iterator)
Method: advance (ITER vector-iterator)
Method: advance (ITER bound-list-iterator)
Method: advance (ITER list-iterator)
Generic Function: advance-n ITERATOR N

Advances the iterator ITERATOR N positions, advances to the position that the iterator would be at after calling ADVANCE N times.

Package

generic-cl.impl

Source

iterator.lisp (file)

Methods
Method: advance-n (IT sub-iterator) N
Method: advance-n (ITER reverse-vector-iterator) N
Method: advance-n (ITER vector-iterator) N
Method: advance-n (IT iterator) N
Generic Function: asin A

Returns the arc sine of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: asin (A number)
Generic Function: asinh A

Returns the hyperbolic arc sine of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: asinh (A number)
Generic Function: at ITERATOR

Returns the element at the position specified by ITERATOR. Is not guaranteed to check whether the end of the sequence has been reached.

Package

generic-cl.impl

Source

iterator.lisp (file)

Writer

(setf at) (generic function)

Methods
Method: at (IT lazy-seq-iterator)
Source

lazy-seq.lisp (file)

Method: at (IT sub-iterator)
Method: at (ITER reverse-array-iterator)

Access the element of the array at the current position using ROW-MAJOR-AREF.

Method: at (ITER array-iterator)

Access the element of the array at the current position using ROW-MAJOR-AREF.

Method: at (ITER vector-iterator)
Method: at (ITER reverse-list-iterator)
Method: at (ITER list-iterator)
Generic Function: (setf at) VALUE ITERATOR

Sets the value at the position of the sequence at which ITERATOR is currently at.

Package

generic-cl.impl

Source

iterator.lisp (file)

Reader

at (generic function)

Methods
Method: (setf at) VALUE (IT sub-iterator)
Method: (setf at) VALUE (ITER reverse-array-iterator)
Method: (setf at) VALUE (ITER array-iterator)
Method: (setf at) VALUE (ITER vector-iterator)
Method: (setf at) VALUE (ITER reverse-list-iterator)
Method: (setf at) VALUE (ITER list-iterator)
Method: (setf at) VALUE (ITER hash-table-iterator)

Sets the value corresponding to the current key being iterator (CAR (AT ITER)) to VALUE.

Source

hash-tables.lisp (file)

Generic Function: atan A &optional B

Returns the arc tangent of A. If B is supplied, returns the arc tangent of A/B.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: atan (A number) &optional B
Generic Function: atanh A

Returns the hyperbolic arc tangent of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: atanh (A number)
Generic Function: ceiling N &optional D

Returns N, or N/D if D is provided, rounded towards positive infinity, and the remainder of the division if any.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: ceiling (N number) &optional D
Generic Function: cis A

Returns a complex number equal to cos(A) + i*sin(A) where A is in radians.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: cis A
Method: cis (A number)
Generic Function: clear SEQUENCE

Destructively removes all elements from SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: clear (MAP hash-table)
Source

hash-tables.lisp (file)

Method: clear (MAP hash-map)

Removes all entries from the hash-map MAP.

Source

hash-tables.lisp (file)

Method: clear (VEC vector)
Source

cl-sequences.lisp (file)

Generic Function: cleared SEQUENCE &key KEEP-ELEMENT-TYPE &allow-other-keys

Creates a new sequence of the same type and with the same properties as SEQUENCE however without any elements.

Package

generic-cl.impl

Source

collector.lisp (file)

Methods
Method: cleared (SEQ lazy-seq) &key

Returns the empty list NIL.

Source

lazy-seq.lisp (file)

Method: cleared (SET hash-set) &key
Source

sets.lisp (file)

Method: cleared (MAP hash-map) &key
Source

hash-tables.lisp (file)

Method: cleared (VEC vector) &key KEEP-ELEMENT-TYPE
Method: cleared (SEQUENCE list) &key

Returns NIL the empty list.

Generic Function: coerce OBJECT RESULT-TYPE

Coerces the OBJECT to the type RESULT-TYPE.

Package

generic-cl.impl

Source

object.lisp (file)

Methods
Method: coerce (SEQ lazy-seq) (TYPE (eql list))
Source

lazy-seq.lisp (file)

Method: coerce (LIST list) (TYPE (eql hash-set))
Source

sets.lisp (file)

Method: coerce (MAP hash-map) (TYPE (eql plist))

Returns a PLIST containing all the entries (key-value pairs) in the hash-map MAP.

Source

hash-tables.lisp (file)

Method: coerce (MAP hash-map) (TYPE (eql alist))

Returns an ALIST containing all the entries (key-value pairs) in the hash-map MAP.

Source

hash-tables.lisp (file)

Method: coerce OBJECT TYPE
Generic Function: collector-sequence COLLECTOR

Returns the sequence associated with the collector COLLECTOR.

Calling this method is necessary, when no more items will be added to the sequence, as the original sequence passed to MAKE-COLLECTOR might not have been destructively modified.

Package

generic-cl.impl

Source

collector.lisp (file)

Methods
Method: collector-sequence (MAP hash-map)
Source

hash-tables.lisp (file)

Method: collector-sequence (C front-vector-collector)
Method: collector-sequence (VEC vector)
Method: collector-sequence (C front-list-collector)
Method: collector-sequence (C list-collector)
Generic Function: compare A B

Returns :LESS if A is less than B (LESSP A B), :GREATER if A is greater than B (GREATERP A B) or :EQUAL if A is equal to B (EQUALP A B).

Package

generic-cl.impl

Source

comparison.lisp (file)

Methods
Method: compare (A number) (B number)
Method: compare A B
Generic Function: concatenate SEQUENCE &rest SEQUENCES

Returns a new sequence, of the same type as SEQUENCE, containing all the elements of SEQUENCE and of each sequence in SEQUENCES, in the order they are supplied.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: concatenate (SEQUENCE lazy-seq) &rest SEQUENCES

Lazily concatenates SEQUENCES to SEQUENCE.

Source

lazy-seq.lisp (file)

Method: concatenate SEQUENCE &rest SEQUENCES
Source

generic-sequences.lisp (file)

Generic Function: concatenate-to TYPE &rest SEQUENCES

Returns a sequence of type TYPE containing all the elements of each sequence in SEQUENCES, in the order they are supplied.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: concatenate-to (TYPE (eql lazy-seq)) &rest SEQUENCES

Lazily concatenates SEQUENCES

Source

lazy-seq.lisp (file)

Method: concatenate-to TYPE &rest SEQUENCES
Source

generic-sequences.lisp (file)

Generic Function: conjugate A

Returns the complex conjugate of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: conjugate A
Method: conjugate (A number)
Generic Function: copy OBJECT &key DEEP &allow-other-keys

Returns a copy of OBJECT. Some methods may accept additional keyword arguments which allow options, on how the object is to be copied, to be specified.

Methods specialized on sequences or collections should accept the :DEEP keyword argument which if provided and is true, the objects contained in the sequence/collection should be copied as well otherwise (if not provided or is NIL) only the sequence/collection itself should be copied.

Package

generic-cl.impl

Source

object.lisp (file)

Methods
Method: copy (SEQ lazy-seq) &key DEEP
Source

lazy-seq.lisp (file)

Method: copy (ARG0 bound-lazy-seq-iterator) &key
Source

lazy-seq.lisp (file)

Method: copy (ARG0 lazy-seq-iterator) &key
Source

lazy-seq.lisp (file)

Method: copy (SET hash-set) &key
Source

sets.lisp (file)

Method: copy (ARG0 hash-table-iterator) &key
Source

hash-tables.lisp (file)

Method: copy (TABLE hash-table) &key DEEP
Source

hash-tables.lisp (file)

Method: copy (MAP hash-map) &key DEEP
Source

hash-tables.lisp (file)

Method: copy (ARG0 front-vector-collector) &key
Source

collector.lisp (file)

Method: copy (ARG0 front-list-collector) &key
Source

collector.lisp (file)

Method: copy (ARG0 list-collector) &key
Source

collector.lisp (file)

Method: copy (IT sub-iterator) &key

Returns a copy of a ‘SUB-ITERATOR’ which contains a copy of the sequence’s iterator stored in the ITER slot.

Source

iterator.lisp (file)

Method: copy (ARG0 reverse-array-iterator) &key
Source

iterator.lisp (file)

Method: copy (ARG0 array-iterator) &key
Source

iterator.lisp (file)

Method: copy (ARG0 reverse-vector-iterator) &key
Source

iterator.lisp (file)

Method: copy (ARG0 vector-iterator) &key
Source

iterator.lisp (file)

Method: copy (ARG0 reverse-list-iterator) &key
Source

iterator.lisp (file)

Method: copy (ARG0 bound-list-iterator) &key
Source

iterator.lisp (file)

Method: copy (ARG0 list-iterator) &key
Source

iterator.lisp (file)

Method: copy (ARG0 iterator) &key
Source

iterator.lisp (file)

Method: copy OBJECT &key

Default method, does not copy OBJECT.

Method: copy (ARRAY array) &key DEEP
Method: copy (ARRAY vector) &key DEEP
Method: copy (LIST cons) &key DEEP
Generic Function: cos A

Returns the cosine of A (radians).

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: cos (A number)
Generic Function: cosh A

Returns the hyperbolic cosine of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: cosh (A number)
Generic Function: count ITEM SEQUENCE &key FROM-END START END TEST KEY

Same as CL:COUNT however is extensible to other sequence types besides CL:SEQUENCE.

The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: count ITEM SEQUENCE &key FROM-END START END KEY TEST
Source

generic-sequences.lisp (file)

Method: count ITEM (SEQUENCE sequence) &key FROM-END START END TEST KEY
Source

cl-sequences.lisp (file)

Generic Function: count-if PREDICATE SEQUENCE &key FROM-END START END KEY

Same as CL:COUNT-IF however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: count-if TEST SEQUENCE &key FROM-END START END KEY
Source

generic-sequences.lisp (file)

Method: count-if PREDICATE (SEQUENCE sequence) &key FROM-END START END KEY
Source

cl-sequences.lisp (file)

Generic Function: count-if-not PREDICATE SEQUENCE &key FROM-END START END KEY

Same as CL:COUNT-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: count-if-not TEST SEQUENCE &key FROM-END START END KEY
Source

generic-sequences.lisp (file)

Method: count-if-not PREDICATE (SEQUENCE sequence) &key FROM-END START END KEY
Source

cl-sequences.lisp (file)

Generic Function: delete ITEM SEQUENCE &key FROM-END TEST START END COUNT KEY

Same as CL:DELETE however is extensible to other sequence types besides CL:SEQUENCE.

The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: delete ITEM SEQUENCE &key FROM-END TEST START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: delete ITEM (SEQUENCE sequence) &key FROM-END TEST END START COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: delete-duplicates SEQUENCE &key FROM-END TEST START END KEY

Same as CL:DELETE-DUPLICATES however is extensible to other sequence types besides CL:SEQUENCE.

The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: delete-duplicates (SEQ lazy-seq) &key FROM-END TEST START END KEY

Same as the REMOVE-DUPLICATES method specialized on ‘LAZY-SEQ’.

Source

lazy-seq.lisp (file)

Method: delete-duplicates SEQUENCE &key FROM-END TEST START END KEY
Source

generic-sequences.lisp (file)

Method: delete-duplicates (SEQ sequence) &key FROM-END TEST START END KEY
Source

cl-sequences.lisp (file)

Generic Function: delete-if TEST SEQUENCE &key FROM-END START END COUNT KEY

Same as CL:DELETE-IF however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: delete-if TEST (SEQ lazy-seq) &key FROM-END START END COUNT KEY

Same as the REMOVE-IF method specialized on ‘LAZY-SEQ’

Source

lazy-seq.lisp (file)

Method: delete-if TEST SEQUENCE &key FROM-END START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: delete-if TEST (SEQUENCE sequence) &key FROM-END END START COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: delete-if-not TEST SEQUENCE &key FROM-END START END COUNT KEY

Same as CL:DELETE-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: delete-if-not TEST SEQUENCE &key FROM-END START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: delete-if-not TEST (SEQUENCE sequence) &key FROM-END END START COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: denominator A

Returns the numerator of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: denominator (A number)
Generic Function: divide A B

Returns the quotient of A and B. If A is the constant 1, should return the reciprocal of B.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: divide (A number) (B number)
Generic Function: elt SEQUENCE INDEX

Returns the element at index INDEX of SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Writer

(setf elt) (generic function)

Methods
Method: elt SEQUENCE INDEX

Returns the element at index INDEX of the generic sequence SEQUENCE.

This is implemented by creating an iterator for sequence with start position INDEX, and returning the first element returned by the iterator.

Source

generic-sequences.lisp (file)

Method: elt (ARRAY array) INDEX
Source

cl-sequences.lisp (file)

Method: elt (VEC vector) INDEX
Source

cl-sequences.lisp (file)

Method: elt (SEQUENCE sequence) INDEX
Source

cl-sequences.lisp (file)

Generic Function: (setf elt) VALUE SEQUENCE INDEX

Sets the element at index INDEX of sequence SEQUENCE to VALUE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Reader

elt (generic function)

Methods
Method: (setf elt) VALUE SEQUENCE INDEX

Sets the value of the element at index INDEX of the generic sequence SEQUENCE.

This is implemented by creating an iterator for sequence with start position INDEX, and setting the value of the element at the iterator’s starting position.

Source

generic-sequences.lisp (file)

Method: (setf elt) VALUE (ARRAY array) INDEX
Source

cl-sequences.lisp (file)

Method: (setf elt) VALUE (VEC vector) INDEX
Source

cl-sequences.lisp (file)

Method: (setf elt) VALUE (SEQUENCE sequence) INDEX
Source

cl-sequences.lisp (file)

Generic Function: emptyp SEQUENCE

Returns true if SEQUENCE is empty.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: emptyp (SEQ lazy-seq)

Always returns NIL as NIL is used to indicate an empty ‘LAZY-SEQ’. a ‘LAZY-SEQ’ object always contains at least one element.

Source

lazy-seq.lisp (file)

Method: emptyp SEQUENCE

Returns true if an iterator created for SEQUENCE is immediately at its end position (ENDP returns true).

Source

generic-sequences.lisp (file)

Method: emptyp (MAP hash-table)
Source

hash-tables.lisp (file)

Method: emptyp (MAP hash-map)

Returns true if MAP has no entries.

Source

hash-tables.lisp (file)

Method: emptyp (ARRAY array)

Always returns false as a multi-dimensional array can never be empty.

Source

cl-sequences.lisp (file)

Method: emptyp (VEC vector)
Source

cl-sequences.lisp (file)

Method: emptyp (LIST list)
Source

cl-sequences.lisp (file)

Generic Function: endp ITERATOR

Returns true if ITERATOR points to the end of the sequence.

Package

generic-cl.impl

Source

iterator.lisp (file)

Methods
Method: endp (IT bound-lazy-seq-iterator)
Source

lazy-seq.lisp (file)

Method: endp (IT lazy-seq-iterator)
Source

lazy-seq.lisp (file)

Method: endp (IT sub-iterator)
Method: endp (ITER reverse-vector-iterator)
Method: endp (ITER vector-iterator)
Method: endp (ITER bound-list-iterator)
Method: endp (ITER list-iterator)
Method: endp ITER
Generic Function: equalp A B

Generic equality comparison function. Returns true if objects A and B are equal.

Package

generic-cl.impl

Source

equality.lisp (file)

Methods
Method: equalp (A lazy-seq) (B lazy-seq)
Source

lazy-seq.lisp (file)

Method: equalp (A hash-set) (B hash-set)

Returns true if the ‘HASH-SETS’ A and B have the same number of elements and each element of A is also an element of B.

Source

sets.lisp (file)

Method: equalp (A hash-map) (B hash-map)

Hash-table comparison method. Returns true if both hash-tables have the same number of entries, and the value corresponding to each key in A is equal (by EQUALP) to the value corresponding to the same key in B.

Issue: Hash-table equality is not necessarily symmetric if the test functions of the two hash-tables are different.

Source

hash-tables.lisp (file)

Method: equalp A B

Default equality comparison method. Returns true if objects A and B are the same object, compared using CL:EQ.

Method: equalp (A pathname) (B pathname)

Returns true if both ‘pathname’ objects are equal by CL-FAD:PATHNAME-EQUAL.

Method: equalp (A string) (B string)

Returns true if both strings are equal by CL:STRING=

Method: equalp (A array) (B array)

Multi-dimensional array equality comparison method. Returns true if both arrays have the same dimensions and each element of A is equal (by EQUALP) to the corresponding element of B.

Method: equalp (A vector) (B vector)

Array equality comparison method. Returns true if both arrays are of the same length and each element of A is equal (by EQUALP) to the corresponding element of B.

Method: equalp (A cons) (B cons)

CONS equality comparison method. Returns true if the CAR of A is equal to the CAR of B (compared using EQUALP) and the CDR of A is equal to the CDR of B (compared using EQUALP).

Method: equalp (A character) (B character)

Character equality comparison method. Returns true if A and B represent the same character, compared using CL:CHAR=.

Method: equalp (A number) (B number)

Numeric equality comparison method. Returns true if A and B represent the same numeric value, compared using CL:=.

Generic Function: erase SEQUENCE INDEX

Removes the element at index INDEX from the sequence SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: erase (TABLE hash-table) KEY
Source

hash-tables.lisp (file)

Method: erase (MAP hash-map) KEY

Removes the entry corresponding to the key KEY from the hash-map MAP.

Source

hash-tables.lisp (file)

Method: erase (VEC vector) INDEX
Source

cl-sequences.lisp (file)

Generic Function: evenp A

Returns true if A is even.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: evenp A
Method: evenp (A number)
Generic Function: exp POWER

Returns the natural exponent of power (e^POWER).

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: exp (A number)
Generic Function: expt BASE POWER

Returns BASE raised to the power POWER.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: expt (B number) (P number)
Generic Function: extend COLLECTOR SEQUENCE

Adds each item in SEQUENCE to the sequence with collector COLLECTOR.

Package

generic-cl.impl

Source

collector.lisp (file)

Methods
Method: extend (C list-collector) (LIST list)
Method: extend COLLECTOR SEQ
Method: extend COLLECTOR (IT iterator)
Generic Function: fill SEQUENCE ITEM &key START END

Destructively replaces the elements of SEQUENCE between START and END with ITEM. Returns SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: fill SEQ ITEM &key START END
Source

generic-sequences.lisp (file)

Method: fill (SEQ sequence) ITEM &key START END
Source

cl-sequences.lisp (file)

Generic Function: find ITEM SEQUENCE &key FROM-END START END TEST KEY

Same as CL:FIND however is extensible to other sequence types besides CL:SEQUENCE.

The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: find ITEM SEQUENCE &key FROM-END START END TEST KEY
Source

generic-sequences.lisp (file)

Method: find ITEM (SEQUENCE sequence) &key FROM-END START END TEST KEY
Source

cl-sequences.lisp (file)

Generic Function: find-if PREDICATE SEQUENCE &key FROM-END START END KEY

Same as CL:FIND-IF however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: find-if TEST SEQUENCE &key FROM-END START END KEY
Source

generic-sequences.lisp (file)

Method: find-if PREDICATE (SEQUENCE sequence) &key FROM-END START END KEY
Source

cl-sequences.lisp (file)

Generic Function: find-if-not PREDICATE SEQUENCE &key FROM-END START END KEY

Same as CL:FIND-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: find-if-not TEST SEQUENCE &key FROM-END START END KEY
Source

generic-sequences.lisp (file)

Method: find-if-not PREDICATE (SEQUENCE sequence) &key FROM-END START END KEY
Source

cl-sequences.lisp (file)

Generic Function: first SEQUENCE

Returns the first element of SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: first (SEQ lazy-seq)
Source

lazy-seq.lisp (file)

Method: first SEQUENCE

Returns the first element of the generic sequence. Implemented using ELT.

Source

generic-sequences.lisp (file)

Method: first (ARRAY array)
Source

cl-sequences.lisp (file)

Method: first (VEC vector)
Source

cl-sequences.lisp (file)

Method: first (LIST list)
Source

cl-sequences.lisp (file)

Generic Function: floor N &optional D

Returns N, or N/D if D is provided, rounded towards negative infinity, and the remainder of the division if any.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: floor (N number) &optional D
Generic Function: get KEY MAP &optional DEFAULT

Returns the value of the entry corresponding to the key KEY in the map MAP. If the map does not contain any entry with that key, DEFAULT is returned.

Returns two values: the value and true if an entry with the key KEY was found in the map, false otherwise.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Writer

(setf get) (generic function)

Methods
Method: get KEY (MAP list) &optional DEFAULT
Method: get KEY (TABLE hash-table) &optional DEFAULT
Method: get KEY (MAP hash-map) &optional DEFAULT
Generic Function: (setf get) VALUE KEY MAP &optional DEFAULT

Sets the value of the entry corresponding to the key KEY in the map MAP. DEFAULT is ignored.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Reader

get (generic function)

Methods
Method: (setf get) VALUE KEY (TABLE hash-table) &optional DEFAULT
Method: (setf get) VALUE KEY (MAP hash-map) &optional DEFAULT
Generic Function: greater-equal-p A B

Returns true if A compares greater than or equal to B.

Package

generic-cl.impl

Source

comparison.lisp (file)

Methods
Method: greater-equal-p (A string) (B string)
Method: greater-equal-p (A character) (B character)
Method: greater-equal-p (A number) (B number)
Method: greater-equal-p A B
Generic Function: greaterp A B

Returns true if A compares greater than B.

Package

generic-cl.impl

Source

comparison.lisp (file)

Methods
Method: greaterp (A string) (B string)
Method: greaterp (A character) (B character)
Method: greaterp (A number) (B number)
Method: greaterp A B
Generic Function: hash OBJECT

Should return a hash code for the object. For further details on the constraints of the hash code returned, see the documentation for CL:SXHASH.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Methods
Method: hash OBJ
Generic Function: imagpart A

Returns the imaginary part of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: imagpart (A number)
Generic Function: intersection SET1 SET2 &key TEST KEY &allow-other-keys

Returns the set intersection of SET1 and SET2. The set returned contains all elements that occur in both SET1 and SET2.

Methods specialized on lists also accept TEST, TEST-NOT and KEY keyword parameters. These parameters are ignored by other methods.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: intersection (SET1 list) (SET2 list) &key TEST KEY
Method: intersection (SET1 hash-map) (SET2 hash-map) &key &allow-other-keys
Generic Function: isqrt A

Returns the largest integer smaller than or equal to the positive square root of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: isqrt (A number)
Generic Function: last SEQUENCE &optional N

Returns the N’th (default 0) element from the last element of SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: last SEQUENCE &optional N

Returns the nth element from the last element of the generic sequence. Implemented using ELT and LENGTH.

Source

generic-sequences.lisp (file)

Method: last (ARRAY array) &optional N
Source

cl-sequences.lisp (file)

Method: last (VEC vector) &optional N
Source

cl-sequences.lisp (file)

Method: last (LIST list) &optional N
Source

cl-sequences.lisp (file)

Generic Function: length SEQUENCE

Returns the number of elements in SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: length (IT iterator)

Returns the number of elements between the current position of the iterator and its end. This is achieved by iterating until ENDP returns true using a copy of IT.

Source

generic-sequences.lisp (file)

Method: length SEQUENCE

Returns the number of elements in SEQUENCE, where SEQUENCE is of a type for which the iterator interface is implemented.

The type is computed by iterating through the entire sequence, thus this is a linear O(n) operation, in the number of elements in the sequence.

Source

generic-sequences.lisp (file)

Method: length (TABLE hash-table)
Source

hash-tables.lisp (file)

Method: length (MAP hash-map)

Returns the number of entries in the hash map MAP.

Source

hash-tables.lisp (file)

Method: length (ARRAY array)

Returns the total number of elements in the multi-dimensional array ARRAY.

Source

cl-sequences.lisp (file)

Method: length (VEC vector)

Returns the number of elements in the vector VEC.

Source

cl-sequences.lisp (file)

Method: length (SEQUENCE sequence)

Generic CL:SEQUENCE method, calls CL:LENGTH.

Source

cl-sequences.lisp (file)

Method: length (IT sub-iterator)
Source

iterator.lisp (file)

Method: length (ITER reverse-vector-iterator)
Source

iterator.lisp (file)

Method: length (ITER vector-iterator)
Source

iterator.lisp (file)

Method: length (ITER bound-list-iterator)
Source

iterator.lisp (file)

Generic Function: less-equal-p A B

Returns true if A compares less than or equal to B.

Package

generic-cl.impl

Source

comparison.lisp (file)

Methods
Method: less-equal-p (A string) (B string)
Method: less-equal-p (A character) (B character)
Method: less-equal-p (A number) (B number)
Method: less-equal-p A B
Generic Function: lessp A B

Returns true if A compares less than B.

Package

generic-cl.impl

Source

comparison.lisp (file)

Methods
Method: lessp (A string) (B string)
Method: lessp (A character) (B character)
Method: lessp (A number) (B number)
Generic Function: log N &optional BASE

Returns the logarithm of N in base BASE. If BASE is not supplied, the natural logarithm of N is returned.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: log (N number) &optional BASE
Generic Function: make-collector SEQUENCE &key FRONT

Returns a collector for adding items to SEQUENCE. If :FRONT is true the items will be added to the front of the sequence rather than the back.

Package

generic-cl.impl

Source

collector.lisp (file)

Methods
Method: make-collector (SEQ lazy-seq) &key FRONT

Returns a collector for collecting items onto a list containing the same elements as the sequence.

Source

lazy-seq.lisp (file)

Method: make-collector (MAP hash-map) &key FRONT
Source

hash-tables.lisp (file)

Method: make-collector (VEC vector) &key FRONT
Method: make-collector (LIST list) &key FRONT
Generic Function: make-iterator SEQUENCE START END

Returns an iterator for elements of the sub-sequence of SEQUENCE, bounded to the range [START, END).

START is the index of the first element to iterate over.

END is the index of the element at which to terminate the iteration, the element itself is not visited. If END is NIL then the iteration continues till the end of the sequence.

Package

generic-cl.impl

Source

iterator.lisp (file)

Methods
Method: make-iterator (SEQ lazy-seq) START (END number)
Source

lazy-seq.lisp (file)

Method: make-iterator (SEQ lazy-seq) START (END null)
Source

lazy-seq.lisp (file)

Method: make-iterator (SET hash-set) START END
Source

sets.lisp (file)

Method: make-iterator (TABLE hash-table) START END
Source

hash-tables.lisp (file)

Method: make-iterator (MAP hash-map) START END

Create an iterator for the elements of a ‘hash-map where each element is a CONS of the form (KEY . VALUE). The order in which the elements are iterated is unspecified, likewise there is no guarantee which elements will be iterated over if START is not 0 and END is not NIL.

Source

hash-tables.lisp (file)

Method: make-iterator (ARRAY array) START END
Method: make-iterator (VEC vector) START END
Method: make-iterator (LIST list) START (END number)
Method: make-iterator (LIST list) START (END null)
Generic Function: make-reverse-iterator SEQUENCE START END

Same as MAKE-ITERATOR except the elements should be iterate over in reverse order.

Package

generic-cl.impl

Source

iterator.lisp (file)

Methods
Method: make-reverse-iterator (SEQ lazy-seq) START END

Accumulates the elements of SEQ, between START and END, into a list, in reverse order, and returns an iterator for the list.

Source

lazy-seq.lisp (file)

Method: make-reverse-iterator (SET hash-set) START END
Source

sets.lisp (file)

Method: make-reverse-iterator (TABLE hash-table) START END
Source

hash-tables.lisp (file)

Method: make-reverse-iterator (HASH hash-map) START END

Create a reverse iterator for the elements of a ‘hash-table’. Since the order of iteration is unspecified this is identical to MAKE-ITERATOR.

Source

hash-tables.lisp (file)

Method: make-reverse-iterator (ARRAY array) START END
Method: make-reverse-iterator (VEC vector) START END
Method: make-reverse-iterator (LIST list) START END
Method: make-reverse-iterator (LIST list) START (END null)
Generic Function: make-sequence-of-type TYPE ARGS

Creates a sequence of the type TYPE. If the type was a list TYPE is the first element of the list and ARGS are the remaining elements. If the type was a symbol TYPE is the symbol and ARGS is NIL.

Package

generic-cl.impl

Source

collector.lisp (file)

Methods
Method: make-sequence-of-type (TYPE (eql hash-set)) (ARGS null)
Source

sets.lisp (file)

Method: make-sequence-of-type (TYPE (eql hash-map)) (ARGS null)
Source

hash-tables.lisp (file)

Method: make-sequence-of-type TYPE ARGS
Generic Function: map FUNCTION SEQUENCE &rest SEQUENCES

Creates a new sequence, of the same type as SEQUENCE (by CLEARED), containing the result of applying FUNCTION to each element of SEQUENCE and each element of each SEQUENCE in SEQUENCES.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: map FUNCTION (SEQUENCE lazy-seq) &rest SEQUENCES
Source

lazy-seq.lisp (file)

Method: map FUNCTION SEQUENCE &rest SEQUENCES
Source

generic-sequences.lisp (file)

Generic Function: map-into RESULT FUNCTION &rest SEQUENCES

Applies FUNCTION on each element of each sequence in SEQUENCES and stores the result in RESULT, using the collector interface.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: map-into (RESULT lazy-seq) FUNCTION &rest SEQUENCES
Source

lazy-seq.lisp (file)

Method: map-into RESULT FUNCTION &rest SEQUENCES
Source

generic-sequences.lisp (file)

Generic Function: map-keys MAP

Returns a sequence containing all the keys in MAP.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Methods
Method: map-keys (MAP hash-table)
Method: map-keys (MAP hash-map)
Generic Function: map-to TYPE FUNCTION &rest SEQUENCES

Applies FUNCTION to each element of each sequence in SEQUENCES and stores the result in a new sequence of type TYPE. Returns the sequence in which the results of applying function are stored.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: map-to (TYPE (eql lazy-seq)) FUNCTION &rest SEQUENCES
Source

lazy-seq.lisp (file)

Method: map-to TYPE FUNCTION &rest SEQUENCES
Source

generic-sequences.lisp (file)

Generic Function: map-values MAP

Returns a sequence containing all the values in MAP.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Methods
Method: map-values (MAP hash-table)
Method: map-values (MAP hash-map)
Generic Function: memberp ITEM SET &key TEST KEY &allow-other-keys

Returns true if ITEM is an element of the set SET.

Methods specialized on lists also accept TEST and KEY keyword parameters. These parameters are ignored by other methods.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: memberp ITEM (SET list) &key TEST KEY
Method: memberp ITEM (SET hash-map) &key
Generic Function: merge SEQUENCE1 SEQUENCE2 PREDICATE &key KEY

Returns a new sequence (of the same type as SEQUENCE1) containing the elements of SEQUENCE1 and SEQUENCE2. The elements are ordered according to the function PREDICATE.

PREDICATE is a function of two arguments (an element from SEQUENCE1 and an element from SEQUENCE2), which should return true if and only if the first argument is strictly less than the second argument.

KEY is a function of one argument, that is called (if it is non-NIL) on each element of SEQUENCE1 and SEQUENCE2 with the result passed on to the PREDICATE function.

Unlike CL:MERGE this function is non-destructive.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: merge SEQ1 SEQ2 TEST &key KEY
Source

generic-sequences.lisp (file)

Method: merge (SEQ1 sequence) (SEQ2 sequence) PREDICATE &key KEY
Source

cl-sequences.lisp (file)

Generic Function: minusp A

Returns true if A is less than 0.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: minusp A
Method: minusp (A number)
Generic Function: mismatch SEQUENCE-1 SEQUENCE-2 &key FROM-END TEST KEY START1 START2 END1 END2

Same as CL:MISMATCH however is extensible to other sequence types besides CL:SEQUENCE.

The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: mismatch SEQ1 SEQ2 &key FROM-END TEST KEY START1 START2 END1 END2
Source

generic-sequences.lisp (file)

Method: mismatch (SEQ1 sequence) (SEQ2 sequence) &key FROM-END TEST KEY START1 START2 END1 END2
Source

cl-sequences.lisp (file)

Generic Function: mod N D

Returns the remainder of the floor operation on N and D.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: mod N D
Method: mod (N number) (D number)
Generic Function: multiply A B

Returns the product of A and B.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: multiply (A number) (B number)
Generic Function: nadjoin ITEM SET &key TEST KEY &allow-other-keys

Same as ADJOIN however is permitted to destructively modify SET.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: nadjoin ITEM (SET list) &key TEST KEY
Method: nadjoin ITEM (SET hash-set) &key
Method: nadjoin ITEM (SET hash-map) &key
Generic Function: nconcatenate SEQUENCE &rest SEQUENCES

Destructively concatenates each sequence in SEQUENCES to the sequence RESULT.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: nconcatenate (SEQUENCE lazy-seq) &rest SEQUENCES

Lazily concatenates SEQUENCES to SEQUENCE.

Source

lazy-seq.lisp (file)

Method: nconcatenate RESULT &rest SEQUENCES
Source

generic-sequences.lisp (file)

Generic Function: negate A

Returns the negation of A.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: negate (A number)
Generic Function: nintersection SET1 SET2 &key TEST KEY &allow-other-keys

Same as INTERSECTION however is permitted to destructively modify SET1 or SET2.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: nintersection (SET1 list) (SET2 list) &key TEST KEY
Method: nintersection (SET1 hash-map) (SET2 hash-map) &key &allow-other-keys
Generic Function: nmap RESULT FUNCTION &rest SEQUENCES

Destructively replaces each element of RESULT with the result of applying FUNCTION to each element of RESULT and each element of each sequence in SEQUENCES.

The shortest sequence of RESULT and SEQUENCE determines how many times FUNCTION is applied and how many elements are in the resulting sequence. If RESULT is longer than any sequence in SEQUENCE the remaining elements are unmodified.

Unlike CL:MAP-INTO, if RESULT is a vector then FUNCTION is only applied on the elements up-to the fill-pointer, i.e. the fill-pointer is not ignored.

Returns RESULT.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: nmap FUNCTION (SEQUENCE lazy-seq) &rest SEQUENCES
Source

lazy-seq.lisp (file)

Method: nmap RESULT FUNCTION &rest SEQUENCES
Source

generic-sequences.lisp (file)

Generic Function: nmerge SEQUENCE1 SEQUENCE2 PREDICATE &key KEY

Same as MERGE however is permitted to destructively modify either SEQUENCE1 or SEQUENCE2.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: nmerge SEQ1 SEQ2 PREDICATE &key KEY
Source

generic-sequences.lisp (file)

Method: nmerge (SEQ1 sequence) (SEQ2 sequence) PREDICATE &key KEY
Source

cl-sequences.lisp (file)

Generic Function: nreverse SEQUENCE

Same as REVERSE however SEQUENCE may be modified.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: nreverse SEQ
Source

generic-sequences.lisp (file)

Method: nreverse (SEQ sequence)
Source

cl-sequences.lisp (file)

Generic Function: nset-difference SET1 SET2 &key TEST KEY &allow-other-keys

Same as SET-DIFFERENCE however is permitted to destructively modify SET1 or SET2.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: nset-difference (SET1 list) (SET2 list) &key TEST KEY
Method: nset-difference (SET1 hash-map) (SET2 hash-map) &key &allow-other-keys
Generic Function: nset-exclusive-or SET1 SET2 &key TEST KEY &allow-other-keys

Same as SET-EXCLUSIVE-OR however is permitted to destructively modify SET1 or SET2.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: nset-exclusive-or (SET1 list) (SET2 list) &key TEST KEY
Method: nset-exclusive-or (SET1 hash-map) (SET2 hash-map) &key &allow-other-keys
Generic Function: nsort SEQUENCE &key TEST KEY

Same as SORT however is permitted to destructively modify SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: nsort SEQ &key TEST KEY
Source

generic-sequences.lisp (file)

Method: nsort (SEQ sequence) &key TEST KEY
Source

cl-sequences.lisp (file)

Generic Function: nsubstitute NEW OLD SEQUENCE &key FROM-END TEST START END COUNT KEY

Same as CL:NSUBSTITUTE however is extensible to other sequence types besides CL:SEQUENCE.

The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: nsubstitute NEW OLD SEQUENCE &key FROM-END TEST START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: nsubstitute NEW OLD (SEQ sequence) &key FROM-END TEST START END COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: nsubstitute-if NEW PREDICATE SEQUENCE &key FROM-END START END COUNT KEY

Same as CL:NSUBSTITUTE-IF however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: nsubstitute-if NEW TEST (SEQ lazy-seq) &key FROM-END START END COUNT KEY

Same as the SUBSTITUTE-IF method specialized on ‘LAZY-SEQ’.

Source

lazy-seq.lisp (file)

Method: nsubstitute-if NEW TEST SEQUENCE &key FROM-END START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: nsubstitute-if NEW PREDICATE (SEQUENCE sequence) &key FROM-END START END COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: nsubstitute-if-not NEW PREDICATE SEQUENCE &key FROM-END START END COUNT KEY

Same as CL:NSUBSTITUTE-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: nsubstitute-if-not NEW TEST SEQUENCE &key FROM-END START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: nsubstitute-if-not NEW PREDICATE (SEQUENCE sequence) &key FROM-END START END COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: numerator A

Returns the numerator of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: numerator (A number)
Generic Function: nunion SET1 SET2 &key TEST KEY &allow-other-keys

Same as UNION however is permitted to destructively modify SET1 or SET2.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: nunion (SET1 list) (SET2 list) &key TEST KEY
Method: nunion (SET1 hash-map) (SET2 hash-map) &key &allow-other-keys
Generic Function: oddp A

Returns true if A is odd.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: oddp A
Method: oddp (A number)
Generic Function: phase A

Returns the phase of A (the angle of the polar representation of A).

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: phase A
Method: phase (A number)
Generic Function: plusp A

Returns true if A is greater than 0

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: plusp A
Method: plusp (A number)
Generic Function: position ITEM SEQUENCE &key FROM-END START END TEST KEY

Same as CL:POSITION however is extensible to other sequence types besides CL:SEQUENCE.

The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: position ITEM SEQUENCE &key FROM-END START END TEST KEY
Source

generic-sequences.lisp (file)

Method: position ITEM (SEQUENCE sequence) &key FROM-END START END TEST KEY
Source

cl-sequences.lisp (file)

Generic Function: position-if PREDICATE SEQUENCE &key FROM-END START END KEY

Same as CL:POSITION-IF however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: position-if TEST SEQUENCE &key FROM-END START END KEY
Source

generic-sequences.lisp (file)

Method: position-if PREDICATE (SEQUENCE sequence) &key FROM-END START END KEY
Source

cl-sequences.lisp (file)

Generic Function: position-if-not PREDICATE SEQUENCE &key FROM-END START END KEY

Same as CL:POSITION-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: position-if-not TEST SEQUENCE &key FROM-END START END KEY
Source

generic-sequences.lisp (file)

Method: position-if-not PREDICATE (SEQUENCE sequence) &key FROM-END START END KEY
Source

cl-sequences.lisp (file)

Generic Function: rational A

Returns a rational equivalent to A, assuming the floating point representation is completely accurate.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: rational (A number)
Generic Function: rationalize A

Returns a rational equivalent to A, assuming the floating point representation is accurate only to the floating-point precision.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: rationalize (A number)
Generic Function: realpart A

Returns the real part of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: realpart (A number)
Generic Function: reduce FUNCTION SEQUENCE &key KEY FROM-END START END INITIAL-VALUE

Same as CL:REDUCE however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: reduce FN SEQUENCE &key KEY FROM-END START END INITIAL-VALUE
Source

generic-sequences.lisp (file)

Method: reduce FUNCTION (SEQUENCE sequence) &rest ARGS &key KEY FROM-END START END INITIAL-VALUE
Source

cl-sequences.lisp (file)

Generic Function: rem N D

Returns the remainder of the truncate operation on N and D.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: rem N D
Method: rem (N number) (D number)
Generic Function: remove ITEM SEQUENCE &key FROM-END TEST START END COUNT KEY

Same as CL:REMOVE however is extensible to other sequence types besides CL:SEQUENCE.

The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: remove ITEM SEQUENCE &key FROM-END TEST START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: remove ITEM (SEQUENCE sequence) &key FROM-END TEST END START COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: remove-duplicates SEQUENCE &key FROM-END TEST START END KEY

Same as CL:REMOVE-DUPLICATES however is extensible to other sequence types besides CL:SEQUENCE.

The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: remove-duplicates (SEQ lazy-seq) &key FROM-END TEST START END KEY

Lazily removes duplicate items from a ‘LAZY-SEQ’. Only returns a ‘LAZY-SEQ’ if FROM-END is true.

Source

lazy-seq.lisp (file)

Method: remove-duplicates SEQUENCE &key FROM-END TEST START END KEY
Source

generic-sequences.lisp (file)

Method: remove-duplicates (SEQ sequence) &key FROM-END TEST START END KEY
Source

cl-sequences.lisp (file)

Generic Function: remove-if TEST SEQUENCE &key FROM-END START END COUNT KEY

Same as CL:REMOVE-IF however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: remove-if TEST (SEQ lazy-seq) &key FROM-END START END COUNT KEY

Lazily removes items from a ‘LAZY-SEQ’. A ‘LAZY-SEQ’ is only returned if either FROM-END or COUNT is FALSE.

Source

lazy-seq.lisp (file)

Method: remove-if TEST SEQUENCE &key FROM-END START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: remove-if TEST (SEQUENCE sequence) &key FROM-END END START COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: remove-if-not TEST SEQUENCE &key FROM-END START END COUNT KEY

Same as CL:REMOVE-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: remove-if-not TEST SEQUENCE &key FROM-END START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: remove-if-not TEST (SEQUENCE sequence) &key FROM-END END START COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: replace SEQUENCE1 SEQUENCE2 &key START1 END1 START2 END2

Destructively replaces the elements of SEQUENCE1, between START1 and END1, with the elements of SEQUENCE2, between START2 and END2.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: replace SEQ1 SEQ2 &key START1 END1 START2 END2
Source

generic-sequences.lisp (file)

Method: replace (SEQ1 sequence) (SEQ2 sequence) &key START1 START2 END1 END2
Source

cl-sequences.lisp (file)

Generic Function: reverse SEQUENCE

Returns a new sequence of the same type as SEQUENCE and with the same elements in reverse order.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: reverse SEQ
Source

generic-sequences.lisp (file)

Method: reverse (SEQ sequence)
Source

cl-sequences.lisp (file)

Generic Function: round N &optional D

Returns N, or N/D if D is provided, rounded towards the nearest integer. If the quotient lies exactly halfway between two integers it is rounded to the nearest even integer.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: round (N number) &optional D
Generic Function: search SEQUENCE-1 SEQUENCE-2 &key FROM-END TEST KEY START1 START2 END1 END2

Same as CL:SEARCH however is extensible to other sequence types besides CL:SEQUENCE.

The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: search SEQ1 SEQ2 &key FROM-END TEST KEY START1 START2 END1 END2
Source

generic-sequences.lisp (file)

Method: search (SEQ1 sequence) (SEQ2 sequence) &key FROM-END TEST KEY START1 START2 END1 END2
Source

cl-sequences.lisp (file)

Generic Function: set-difference SET1 SET2 &key TEST KEY &allow-other-keys

Returns the set difference of SET1 and SET2. The set returned contains all the elements of SET1 that do not appear in SET1.

Methods specialized on lists also accept TEST, TEST-NOT and KEY keyword parameters. These parameters are ignored by other methods.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: set-difference (SET1 list) (SET2 list) &key TEST KEY
Method: set-difference (SET1 hash-map) (SET2 hash-map) &key &allow-other-keys
Generic Function: set-exclusive-or SET1 SET2 &key TEST KEY &allow-other-keys

Returns a set containing all elements that appear in exactly one of SET1 and SET2.

Methods specialized on lists also accept TEST, TEST-NOT and KEY keyword parameters. These parameters are ignored by other methods.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: set-exclusive-or (SET1 list) (SET2 list) &key TEST KEY
Method: set-exclusive-or (SET1 hash-map) (SET2 hash-map) &key &allow-other-keys
Generic Function: signum A

Returns -1 - if A is negative, 0 - if A is zero or 1 if A is positive

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: signum A
Method: signum (A number)
Generic Function: sin A

Returns the sine of A (radians).

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: sin (A number)
Generic Function: sinh A

Returns the hyperbolic sine of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: sinh (A number)
Generic Function: sort SEQUENCE &key TEST KEY

Returns a new sequence of the same type as SEQUENCE, with the same elements sorted according to the order determined by the function TEST.

TEST is a function of two arguments, which should return true if and only if the first argument is strictly less than the second. By default, TEST is GENERIC-CL:LESSP.

If KEY is provided and is not NIL it is called on each element and the result returned by the function is passed on to TEST.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: sort SEQUENCE &key TEST KEY

Returns a sequence, of the same type as sequence, with the elements sorted, by the order of TEST, using the merge sort algorithm.

Source

generic-sequences.lisp (file)

Method: sort (SEQ sequence) &key TEST KEY
Source

cl-sequences.lisp (file)

Generic Function: sqrt A

Returns the square root of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: sqrt (A number)
Generic Function: stable-nsort SEQUENCE &key TEST KEY

Same as STABLE-SORT however is permitted to destructively modify SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: stable-nsort SEQ &key TEST KEY
Source

generic-sequences.lisp (file)

Method: stable-nsort (SEQ sequence) &key TEST KEY
Source

cl-sequences.lisp (file)

Generic Function: stable-sort SEQUENCE &key TEST KEY

Same as SORT however the sort operation is guaranteed to be stable, that is the order of elements which compare equal, under TEST, will be preserved.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: stable-sort SEQ &key TEST KEY

Simply calls SORT as the default method is a stable sort.

Source

generic-sequences.lisp (file)

Method: stable-sort (SEQ sequence) &key TEST KEY
Source

cl-sequences.lisp (file)

Generic Function: start ITERATOR

Returns the element at the position specified by ITERATOR or NIL if the ITERATOR points to the end of the sequence.

Package

generic-cl.impl

Source

iterator.lisp (file)

Methods
Method: start ITER
Generic Function: subseq SEQUENCE START &optional END

Returns a new sequence that is the sub-sequence of SEQUENCE between START and END.

Package

generic-cl.impl

Source

sequences.lisp (file)

Writer

(setf subseq) (generic function)

Methods
Method: subseq (SEQ lazy-seq) START &optional END
Source

lazy-seq.lisp (file)

Method: subseq (IT bound-lazy-seq-iterator) START &optional END
Source

lazy-seq.lisp (file)

Method: subseq (IT lazy-seq-iterator) START &optional END
Source

lazy-seq.lisp (file)

Method: subseq SEQ START &optional END
Source

generic-sequences.lisp (file)

Method: subseq (IT hash-table-iterator) START &optional END
Source

hash-tables.lisp (file)

Method: subseq (SEQ sequence) START &optional END
Source

cl-sequences.lisp (file)

Method: subseq (IT sub-iterator) START &optional END
Source

iterator.lisp (file)

Method: subseq (IT iterator) START &optional END

Returns an iterator for the subseqeunce [START, END) of the sequence with iterator IT. Both START and END are interpreted relative to the position of the iterator IT within its sequence.

Source

iterator.lisp (file)

Method: subseq (IT reverse-array-iterator) START &optional END
Source

iterator.lisp (file)

Method: subseq (IT array-iterator) START &optional END
Source

iterator.lisp (file)

Method: subseq (IT reverse-vector-iterator) START &optional END
Source

iterator.lisp (file)

Method: subseq (IT vector-iterator) START &optional END
Source

iterator.lisp (file)

Method: subseq (IT reverse-list-iterator) START &optional END
Source

iterator.lisp (file)

Method: subseq (IT bound-list-iterator) START &optional END
Source

iterator.lisp (file)

Method: subseq (IT list-iterator) START &optional END
Source

iterator.lisp (file)

Generic Function: (setf subseq) NEW-SEQUENCE SEQUENCE START &optional END

Replaces the elements of SEQUENCE between START and END with the elements of NEW-SEQUENCE. The shorter of the length of NEW-SEQUENCE and the number of elements between START and END determines how many elements of SEQUENCE are actually modified.

Package

generic-cl.impl

Source

sequences.lisp (file)

Reader

subseq (generic function)

Methods
Method: (setf subseq) NEW SEQ START &optional END
Source

generic-sequences.lisp (file)

Method: (setf subseq) VALUE (SEQ sequence) START &optional END
Source

cl-sequences.lisp (file)

Generic Function: subsetp SET1 SET2 &key TEST KEY &allow-other-keys

Returns true if the set SET1 is a subset of the set SET2.

Methods specialized on lists also accept TEST and KEY keyword parameters. These parameters are ignored by other methods.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: subsetp (SET1 list) (SET2 list) &key TEST KEY
Method: subsetp (SET1 hash-map) (SET2 hash-map) &key
Generic Function: substitute NEW OLD SEQUENCE &key FROM-END TEST START END COUNT KEY

Same as CL:SUBSTITUTE however is extensible to other sequence types besides CL:SEQUENCE.

The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: substitute NEW OLD SEQUENCE &key FROM-END TEST START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: substitute NEW OLD (SEQ sequence) &key FROM-END TEST START END COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: substitute-if NEW PREDICATE SEQUENCE &key FROM-END START END COUNT KEY

Same as CL:SUBSTITUTE-IF however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: substitute-if NEW TEST (SEQ lazy-seq) &key FROM-END START END COUNT KEY

Lazily substitutes elements, in a ‘LAZY-SEQ’ which satisfy TEST, with NEW.

Source

lazy-seq.lisp (file)

Method: substitute-if NEW TEST SEQUENCE &key FROM-END START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: substitute-if NEW PREDICATE (SEQUENCE sequence) &key FROM-END START END COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: substitute-if-not NEW PREDICATE SEQUENCE &key FROM-END START END COUNT KEY

Same as CL:SUBSTITUTE-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.

Package

generic-cl.impl

Source

sequences.lisp (file)

Methods
Method: substitute-if-not NEW TEST SEQUENCE &key FROM-END START END COUNT KEY
Source

generic-sequences.lisp (file)

Method: substitute-if-not NEW PREDICATE (SEQUENCE sequence) &key FROM-END START END COUNT KEY
Source

cl-sequences.lisp (file)

Generic Function: subtract A B

Returns the difference of A and B.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: subtract (A hash-map) (B hash-map)

Returns the set difference of set A and set B.

Source

sets.lisp (file)

Method: subtract (A number) (B number)
Generic Function: tan A

Returns the tangent of A (radians).

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: tan (A number)
Generic Function: tanh A

Returns the hyperbolic tangent of A.

Package

generic-cl.math

Source

math.lisp (file)

Methods
Method: tanh (A number)
Generic Function: truncate N &optional D

Returns N, or N/D if D is provided, rounded towards zero, and the remainder of the division if any.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: truncate (N number) &optional D
Generic Function: union SET1 SET2 &key TEST KEY &allow-other-keys

Returns the set union of SET1 and SET2. The set returned contains all elements of SET1 and SET2.

Methods specialized on lists also accept TEST, TEST-NOT and KEY keyword parameters. These parameters are ignored by other methods.

Package

generic-cl.impl

Source

sets.lisp (file)

Methods
Method: union (SET1 list) (SET2 list) &key TEST KEY
Method: union (SET1 hash-map) (SET2 hash-map) &key &allow-other-keys
Generic Function: zerop A

Returns true if A is zero.

Package

generic-cl.impl

Source

arithmetic.lisp (file)

Methods
Method: zerop A
Method: zerop (A number)

Previous: , Up: Exported definitions   [Contents][Index]

6.1.6 Structures

Structure: hash-map ()

Hash-table wrapper for Common Lisp hash-tables and generic hash tables.

The TABLE slot stores the actual hash-table which may either be a native hash table or a CL-CUSTOM-HASH-TABLE:CUSTOM-HASH-TABLE. On implementations which provide functionality for specifying a custom hash function, this slot always contains a CL:HASH-TABLE.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

hash-set (structure)

Direct methods
Direct slots
Slot: table
Readers

hash-map-table (function)

Writers

(setf hash-map-table) (function)

Structure: hash-set ()

Set data structure implemented using hash tables.

This structure is equivalent to the ‘HASH-MAP’ structure, in-fact all set methods also work on ‘HASH-MAP’s as well as ‘HASH-SET’s. However this structure should be used to indicate that the values stored in the hash table are unimportant. Some methods, specialized on ‘HASH-SET’, will ignore the hash-table values.

Package

generic-cl.impl

Source

sets.lisp (file)

Direct superclasses

hash-map (structure)

Direct methods
Structure: iterator ()

Base iterator type. All iterators should inherit (:INCLUDE) from this type in order for methods which specialize on iterators to be chosen.

Package

generic-cl.impl

Source

iterator.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct methods
Structure: lazy-seq ()

Lazy sequence where the elements are only computed when they are actually referenced. The first element of the sequence is stored in HEAD. TAIL stores a function which, when called, returns the ‘LAZY-SEQ’ containing the remaining elements in the sequence. If there are no remaining elements the function in TAIL returns NIL.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: head
Readers

lazy-seq-head (function)

Writers

(setf lazy-seq-head) (function)

Slot: tail
Readers

lazy-seq-tail (function)

Writers

(setf lazy-seq-tail) (function)


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

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Macros

Macro: do-generic-map (KEY VALUE O!HASH-MAP &optional RESULT) &body BODY
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Macro: thunk FORM

Creates a function, with no arguments, which, when called for the first time returns the result of evaluating FORM. This result is stored such that in future invocations of the function, it will be returned without re-evaluating FORM.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Functions

Function: advance-all ITERS

Advances each iterator in ITERS to its next position (by ADVANCE).

Package

generic-cl.impl

Source

generic-sequences.lisp (file)

Function: array-iterator-array INSTANCE
Function: (setf array-iterator-array) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: array-iterator-end INSTANCE
Function: (setf array-iterator-end) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: array-iterator-index INSTANCE
Function: (setf array-iterator-index) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: array-iterator-p OBJECT
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: bound-lazy-seq-iterator-end INSTANCE
Function: (setf bound-lazy-seq-iterator-end) VALUE INSTANCE
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: bound-lazy-seq-iterator-index INSTANCE
Function: (setf bound-lazy-seq-iterator-index) VALUE INSTANCE
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: bound-lazy-seq-iterator-p OBJECT
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: bound-lazy-seq-iterator-seq INSTANCE
Function: (setf bound-lazy-seq-iterator-seq) VALUE INSTANCE
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: bound-list-iterator-cons INSTANCE
Function: (setf bound-list-iterator-cons) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: bound-list-iterator-end INSTANCE
Function: (setf bound-list-iterator-end) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: bound-list-iterator-p OBJECT
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: collect-perform-op COLLECTOR SEQUENCE OP &key START END FROM-END

Collects the elements of SEQUENCE in the range [0, START), and from END till the end of the sequence. Calls OP to perform an operation on the remaining range.

If FROM-END is true COLLECTOR should be a collector to the front of a sequence.

Package

generic-cl.impl

Source

generic-sequences.lisp (file)

Function: copy-array-iterator INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: copy-bound-lazy-seq-iterator INSTANCE
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: copy-bound-list-iterator INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: copy-front-list-collector INSTANCE
Package

generic-cl.impl

Source

collector.lisp (file)

Function: copy-front-vector-collector INSTANCE
Package

generic-cl.impl

Source

collector.lisp (file)

Function: copy-generic-hash-table MAP DEEP
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: copy-hash-table-iterator INSTANCE
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: copy-initial-lazy-seq SEQ START OP

Returns a new ‘LAZY-SEQ’ which contains the first START elements of SEQ. The function OP is applied on the remaining sequence of elements, of SEQ, to obtain the remainder of the sequence that is returned.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: copy-iterator INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: copy-lazy-seq-iterator INSTANCE
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: copy-list-collector INSTANCE
Package

generic-cl.impl

Source

collector.lisp (file)

Function: copy-list-iterator INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: copy-reverse-array-iterator INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: copy-reverse-list-iterator INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: copy-reverse-vector-iterator INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: copy-vector-iterator INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: deep-copy-array ARRAY

Returns a copy of the multi-dimensional ARRAY which contains a copy (by COPY) of each object contained in it.

Package

generic-cl.impl

Source

object.lisp (file)

Function: deep-copy-list LIST

Returns a copy of LIST which contains a copy (by COPY) of each object contained in it.

Package

generic-cl.impl

Source

object.lisp (file)

Function: deep-copy-vector VEC

Returns a copy of the vector VEC which contains a copy (by COPY) of each object contained in it.

Package

generic-cl.impl

Source

object.lisp (file)

Function: front-list-collector-cons INSTANCE
Function: (setf front-list-collector-cons) VALUE INSTANCE
Package

generic-cl.impl

Source

collector.lisp (file)

Function: front-list-collector-p OBJECT
Package

generic-cl.impl

Source

collector.lisp (file)

Function: front-vector-collector-p OBJECT
Package

generic-cl.impl

Source

collector.lisp (file)

Function: front-vector-collector-vector INSTANCE
Function: (setf front-vector-collector-vector) VALUE INSTANCE
Package

generic-cl.impl

Source

collector.lisp (file)

Function: get-elements ITERS

Returns a list containing the elements at the positions of each iterator in ITERS (by AT).

Package

generic-cl.impl

Source

generic-sequences.lisp (file)

Function: hash-map->list MAP &optional START END

Returns an ALIST containing the elements of the hash map MAP. START and END determine the number of elements that will be returned. If START is zero and END is NIL all elements are included in the ALIST.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: hash-map-test-p TEST

Returns true if TEST is a valid hash-table test function.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: hash-set->list SET &optional START END

Returns a list containing the elements of the hash set SET,
i.e. the keys of the underlying hash table. START and END determine the number of elements that will be returned. If START is zero and END is NIL all elements are returned.

Package

generic-cl.impl

Source

sets.lisp (file)

Function: hash-table-iterator-cons INSTANCE
Function: (setf hash-table-iterator-cons) VALUE INSTANCE
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: hash-table-iterator-p OBJECT
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: hash-table-iterator-table INSTANCE
Function: (setf hash-table-iterator-table) VALUE INSTANCE
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: hashmap-keys TABLE

Returns a list containing the keys in the hash table TABLE.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: hashmap-values TABLE

Returns a list containing the values in the hash table TABLE.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: iterator-p OBJECT
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: lazy-seq->list SEQ COUNT

Accumulates COUNT elements of the ‘LAZY-SEQ’ SEQ into a list, in reverse order.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: lazy-seq-iterator-p OBJECT
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: lazy-seq-iterator-seq INSTANCE
Function: (setf lazy-seq-iterator-seq) VALUE INSTANCE
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: list->hash-set LIST

Returns a ‘HASH-SET’ containing all the elements in LIST.

Package

generic-cl.impl

Source

sets.lisp (file)

Function: list-collector-head INSTANCE
Function: (setf list-collector-head) VALUE INSTANCE
Package

generic-cl.impl

Source

collector.lisp (file)

Function: list-collector-p OBJECT
Package

generic-cl.impl

Source

collector.lisp (file)

Function: list-collector-tail INSTANCE
Function: (setf list-collector-tail) VALUE INSTANCE
Package

generic-cl.impl

Source

collector.lisp (file)

Function: list-iterator-cons INSTANCE
Function: (setf list-iterator-cons) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: list-iterator-p OBJECT
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: make-array-iterator &key (INDEX INDEX) (ARRAY ARRAY) (END END)
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: make-bound-lazy-seq-iterator &key (SEQ SEQ) (INDEX INDEX) (END END)
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: make-bound-list-iterator &key (CONS CONS) (END END)
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: make-empty-hash-table TABLE
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: make-front-list-collector &key (CONS CONS)
Package

generic-cl.impl

Source

collector.lisp (file)

Function: make-front-vector-collector &key (VECTOR VECTOR)
Package

generic-cl.impl

Source

collector.lisp (file)

Function: make-generic-hash-table &rest OPTIONS
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: make-hash-map-table &rest ARGS &key TEST &allow-other-keys

Creates either a native hash-table or generic hash-table depending on the TEST.

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: make-hash-table-iterator &key (CONS CONS) (TABLE TABLE)
Package

generic-cl.impl

Source

hash-tables.lisp (file)

Function: make-iters SEQS

Returns a list of iterators for each sequence in SEQS.

Package

generic-cl.impl

Source

generic-sequences.lisp (file)

Function: make-lazy-seq-iterator &key (SEQ SEQ)
Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: make-list-collector &key (HEAD HEAD) (TAIL TAIL)
Package

generic-cl.impl

Source

collector.lisp (file)

Function: make-list-iterator &key (CONS CONS)
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: make-reverse-array-iterator &key (INDEX INDEX) (ARRAY ARRAY) (END END)
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: make-reverse-list-iterator &key (CONS CONS)
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: make-reverse-vector-iterator &key (INDEX INDEX) (ARRAY ARRAY) (END END)
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: make-sub-iterator &key (ITER ITER) (END END)
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: make-vector-iterator &key (INDEX INDEX) (ARRAY ARRAY) (END END)
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: more? SEQ END COUNT

Returns true if there are more elements to be processed in the sequence SEQ. END is the index of the last element to process and COUNT is the maximum number of elements to be processed.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: numbers? ARGS ENV

Returns true if each form in ARGS evaluates (within the lexical environment ENV) to a type that is a subtype of NUMBER.

Package

generic-cl.impl

Source

equality.lisp (file)

Function: remove-dups-from-lazy-seq-hash SEQ END KEY ITEMS

Returns a ‘LAZY-SEQ’ containing all elements in SEQ with the elements in the ‘HASH-MAP’ ITEMS removed.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: remove-dups-from-lazy-seq-list SEQ END KEY TEST ITEMS

Returns a ‘LAZY-SEQ’ containing all elements in SEQ with the elements in the ‘LIST’ ITEMS removed.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: remove-from-lazy-seq SEQ END TEST KEY COUNT

Returns a ‘LAZY-SEQ’ that contains the elements of SEQ with the elements that satisfy TEST removed.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: reverse-array-iterator-array INSTANCE
Function: (setf reverse-array-iterator-array) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: reverse-array-iterator-end INSTANCE
Function: (setf reverse-array-iterator-end) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: reverse-array-iterator-index INSTANCE
Function: (setf reverse-array-iterator-index) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: reverse-array-iterator-p OBJECT
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: reverse-list-iterator-cons INSTANCE
Function: (setf reverse-list-iterator-cons) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: reverse-list-iterator-p OBJECT
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: reverse-vector-iterator-array INSTANCE
Function: (setf reverse-vector-iterator-array) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: reverse-vector-iterator-end INSTANCE
Function: (setf reverse-vector-iterator-end) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: reverse-vector-iterator-index INSTANCE
Function: (setf reverse-vector-iterator-index) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: reverse-vector-iterator-p OBJECT
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: some-endp ITERS

Returns true if at least one of the iterators in ITERS is at the end of its sequence (by ENDP.

Package

generic-cl.impl

Source

generic-sequences.lisp (file)

Function: sub-iterator-end INSTANCE
Function: (setf sub-iterator-end) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: sub-iterator-iter INSTANCE
Function: (setf sub-iterator-iter) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: sub-iterator-p OBJECT
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: sub-lazy-seq SEQ START

Returns the subsequence of SEQ beginning at the element at index START.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: substitue-in-lazy-seq SEQ END NEW TEST KEY COUNT

Returns a new ‘LAZY-SEQ’ containing all elements of ‘SEQ’ with the elements that satisfy TEST replaced with NEW.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Function: test-eq FN X

Returns a function of one argument Y which returns true if (FN X Y) returns true.

Package

generic-cl.impl

Source

util.lisp (file)

Function: test-not FN

Returns a function of one argument which returns the complement of applying FN on the argument.

Package

generic-cl.impl

Source

util.lisp (file)

Function: vector-iterator-array INSTANCE
Function: (setf vector-iterator-array) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: vector-iterator-end INSTANCE
Function: (setf vector-iterator-end) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: vector-iterator-index INSTANCE
Function: (setf vector-iterator-index) VALUE INSTANCE
Package

generic-cl.impl

Source

iterator.lisp (file)

Function: vector-iterator-p OBJECT
Package

generic-cl.impl

Source

iterator.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Structures

Structure: array-iterator ()

Multi-dimensional (non-vector) array iterator for iterator over each element of the flattened array. Does not have any additional slots over ‘vector-iterator’, as it is used only for generic dispatch.

Package

generic-cl.impl

Source

iterator.lisp (file)

Direct superclasses

vector-iterator (structure)

Direct methods
Structure: bound-lazy-seq-iterator ()

Lazy sequence iterator which iterates through the elements of the sequence up till the element at index END.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Direct superclasses

lazy-seq-iterator (structure)

Direct methods
Direct slots
Slot: index
Readers

bound-lazy-seq-iterator-index (function)

Writers

(setf bound-lazy-seq-iterator-index) (function)

Slot: end
Readers

bound-lazy-seq-iterator-end (function)

Writers

(setf bound-lazy-seq-iterator-end) (function)

Structure: bound-list-iterator ()

Bounded list iterator for iterator from a given starting position till a given end position.

END is the number of elements (to iterate over) between the current position and the end of the sublist.

Package

generic-cl.impl

Source

iterator.lisp (file)

Direct superclasses

list-iterator (structure)

Direct methods
Direct slots
Slot: end
Readers

bound-list-iterator-end (function)

Writers

(setf bound-list-iterator-end) (function)

Structure: front-list-collector ()

Collector object for adding items to the front of a list.

Package

generic-cl.impl

Source

collector.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: cons
Readers

front-list-collector-cons (function)

Writers

(setf front-list-collector-cons) (function)

Structure: front-vector-collector ()

Collector object for adding items to the front of a vector

Package

generic-cl.impl

Source

collector.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: vector
Readers

front-vector-collector-vector (function)

Writers

(setf front-vector-collector-vector) (function)

Structure: hash-table-iterator ()

Hash-table iterator. The actual hash-table is converted to an ALIST upon creation of the iterator, since closing over the iteration function provided by WITH-HASH-TABLE-ITERATOR is undefined, and assigned to the CONS slot. A reference to the hash-table is only kept to implement (SETF AT).

Package

generic-cl.impl

Source

hash-tables.lisp (file)

Direct superclasses

list-iterator (structure)

Direct methods
Direct slots
Slot: table
Readers

hash-table-iterator-table (function)

Writers

(setf hash-table-iterator-table) (function)

Structure: lazy-seq-iterator ()

Unbounded lazy sequence iterator. Iterates through all elements of the ‘LAZY-SEQ’ SEQ till the end of the sequence.

Package

generic-cl.impl

Source

lazy-seq.lisp (file)

Direct superclasses

iterator (structure)

Direct subclasses

bound-lazy-seq-iterator (structure)

Direct methods
Direct slots
Slot: seq
Readers

lazy-seq-iterator-seq (function)

Writers

(setf lazy-seq-iterator-seq) (function)

Structure: list-collector ()

Collector object for adding items to the back of a list.

Package

generic-cl.impl

Source

collector.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: head
Readers

list-collector-head (function)

Writers

(setf list-collector-head) (function)

Slot: tail
Readers

list-collector-tail (function)

Writers

(setf list-collector-tail) (function)

Structure: list-iterator ()

Unbounded list iterator for iterating from a given starting position till the end of the list.

CONS stores the CONS cell at the iterator’s current position.

Package

generic-cl.impl

Source

iterator.lisp (file)

Direct superclasses

iterator (structure)

Direct subclasses
Direct methods
Direct slots
Slot: cons
Readers

list-iterator-cons (function)

Writers

(setf list-iterator-cons) (function)

Structure: reverse-array-iterator ()

Multi-dimensional (non-vector) array iterator for iterating over the elements of the flattened array in reverse order. Does not have any additional slots over ‘reverse-vector-iterator’, as it is used only for generic dispatch.

Package

generic-cl.impl

Source

iterator.lisp (file)

Direct superclasses

reverse-vector-iterator (structure)

Direct methods
Structure: reverse-list-iterator ()

Reverse iterator for iterating over the elements of a list in reverse order. Does not have any additional slots over ‘list-iterator’, as it is only used for generic dispatch.

Package

generic-cl.impl

Source

iterator.lisp (file)

Direct superclasses

list-iterator (structure)

Direct methods
Structure: reverse-vector-iterator ()

Reverse iterator for iterating over the elements of a vector in reverse order. Does not have any additional slots over ‘vector-iterator’, as it is only used for generic dispatch.

Package

generic-cl.impl

Source

iterator.lisp (file)

Direct superclasses

vector-iterator (structure)

Direct subclasses

reverse-array-iterator (structure)

Direct methods
Structure: sub-iterator ()

Iterator for iterating over a sub-sequence given an iterator for the sequence.

ITER is the sequence’s iterator. END is the index of the end of the subsequence.

Package

generic-cl.impl

Source

iterator.lisp (file)

Direct superclasses

iterator (structure)

Direct methods
Direct slots
Slot: iter
Readers

sub-iterator-iter (function)

Writers

(setf sub-iterator-iter) (function)

Slot: end
Readers

sub-iterator-end (function)

Writers

(setf sub-iterator-end) (function)

Structure: vector-iterator ()
Package

generic-cl.impl

Source

iterator.lisp (file)

Direct superclasses

iterator (structure)

Direct subclasses
Direct methods
Direct slots
Slot: index
Initform

0

Readers

vector-iterator-index (function)

Writers

(setf vector-iterator-index) (function)

Slot: array
Readers

vector-iterator-array (function)

Writers

(setf vector-iterator-array) (function)

Slot: end
Readers

vector-iterator-end (function)

Writers

(setf vector-iterator-end) (function)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   G   L   M  
Index Entry  Section

F
File, Lisp, generic-cl.asd: The generic-cl<dot>asd file
File, Lisp, generic-cl/src/arithmetic.lisp: The generic-cl/src/arithmetic<dot>lisp file
File, Lisp, generic-cl/src/cl-sequences.lisp: The generic-cl/src/cl-sequences<dot>lisp file
File, Lisp, generic-cl/src/collector.lisp: The generic-cl/src/collector<dot>lisp file
File, Lisp, generic-cl/src/comparison.lisp: The generic-cl/src/comparison<dot>lisp file
File, Lisp, generic-cl/src/equality.lisp: The generic-cl/src/equality<dot>lisp file
File, Lisp, generic-cl/src/generic-sequences.lisp: The generic-cl/src/generic-sequences<dot>lisp file
File, Lisp, generic-cl/src/hash-tables.lisp: The generic-cl/src/hash-tables<dot>lisp file
File, Lisp, generic-cl/src/iterator.lisp: The generic-cl/src/iterator<dot>lisp file
File, Lisp, generic-cl/src/lazy-seq.lisp: The generic-cl/src/lazy-seq<dot>lisp file
File, Lisp, generic-cl/src/math.lisp: The generic-cl/src/math<dot>lisp file
File, Lisp, generic-cl/src/misc.lisp: The generic-cl/src/misc<dot>lisp file
File, Lisp, generic-cl/src/object.lisp: The generic-cl/src/object<dot>lisp file
File, Lisp, generic-cl/src/package.lisp: The generic-cl/src/package<dot>lisp file
File, Lisp, generic-cl/src/sequences.lisp: The generic-cl/src/sequences<dot>lisp file
File, Lisp, generic-cl/src/sets.lisp: The generic-cl/src/sets<dot>lisp file
File, Lisp, generic-cl/src/util.lisp: The generic-cl/src/util<dot>lisp file

G
generic-cl.asd: The generic-cl<dot>asd file
generic-cl/src: The generic-cl/src module
generic-cl/src/arithmetic.lisp: The generic-cl/src/arithmetic<dot>lisp file
generic-cl/src/cl-sequences.lisp: The generic-cl/src/cl-sequences<dot>lisp file
generic-cl/src/collector.lisp: The generic-cl/src/collector<dot>lisp file
generic-cl/src/comparison.lisp: The generic-cl/src/comparison<dot>lisp file
generic-cl/src/equality.lisp: The generic-cl/src/equality<dot>lisp file
generic-cl/src/generic-sequences.lisp: The generic-cl/src/generic-sequences<dot>lisp file
generic-cl/src/hash-tables.lisp: The generic-cl/src/hash-tables<dot>lisp file
generic-cl/src/iterator.lisp: The generic-cl/src/iterator<dot>lisp file
generic-cl/src/lazy-seq.lisp: The generic-cl/src/lazy-seq<dot>lisp file
generic-cl/src/math.lisp: The generic-cl/src/math<dot>lisp file
generic-cl/src/misc.lisp: The generic-cl/src/misc<dot>lisp file
generic-cl/src/object.lisp: The generic-cl/src/object<dot>lisp file
generic-cl/src/package.lisp: The generic-cl/src/package<dot>lisp file
generic-cl/src/sequences.lisp: The generic-cl/src/sequences<dot>lisp file
generic-cl/src/sets.lisp: The generic-cl/src/sets<dot>lisp file
generic-cl/src/util.lisp: The generic-cl/src/util<dot>lisp file

L
Lisp File, generic-cl.asd: The generic-cl<dot>asd file
Lisp File, generic-cl/src/arithmetic.lisp: The generic-cl/src/arithmetic<dot>lisp file
Lisp File, generic-cl/src/cl-sequences.lisp: The generic-cl/src/cl-sequences<dot>lisp file
Lisp File, generic-cl/src/collector.lisp: The generic-cl/src/collector<dot>lisp file
Lisp File, generic-cl/src/comparison.lisp: The generic-cl/src/comparison<dot>lisp file
Lisp File, generic-cl/src/equality.lisp: The generic-cl/src/equality<dot>lisp file
Lisp File, generic-cl/src/generic-sequences.lisp: