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.1, generated automatically by Declt version 2.4 patchlevel 1 "Will Decker" on Mon Apr 08 14:07:36 2019 GMT+0.


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

1 Introduction

GENERIC-CL

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 the 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.

Table of Contents

  1. GENERIC-CL
    1. Usage
    2. Generic Interfaces
      1. Equality
      2. Comparison
      3. Arithmetic
      4. Objects
      5. Iterator
      6. Collector
      7. Sequences
      8. Generic Hash-Tables
      9. Set Operations
      10. Math Functions
    3. Optimization

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. The GENERIC-CL additionally reexports the remaining non-shadowed symbols in COMMON-LISP.

The GENERIC-CL-USER 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 consists of the following functions divided into the following categories:

Equality

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

EQUALP 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:

=

Function: = X &REST XS

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

/=

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.

LESSP, LESS-EQUAL-P, GREATERP, GREATER-EQUAL-P 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 function 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.

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:

LESS-EQUAL-P

Generic Function: LESS-EQUAL-P A B

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

Methods:

GREATERP

Generic Function: GREATERP A B

Returns true if object A is greater than object B.

Methods:

GREATER-EQUAL-P

Generic Function: GREATER-EQUAL-P A B

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

Methods:

COMPARE

Generic Function: COMPARE A B

Returns:

The default T T method returns:

<

Function: < X &REST XS

Returns true if each argument is less than (by LESSP) than the following argument.

<=

Function: <= X &REST XS

Returns true if each argument is less than or equal to (by LESS-EQUAL-P) than the following argument.

>

Function: > X &REST XS

Returns true if each argument is greater than (by GREATERP) than the following argument.

>=

Function: >= X &REST XS

Returns true if each argument is greater than or equal to (by GREATER-EQUAL-P) than the following argument.

MIN

Function: MIN X &REST XS

Returns the minimum argument.

The comparisons are performed by LESSP. 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 GREATERP. 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.

ADD, SUBTRACT, MULTIPLY, DIVIDE are the generic binary arithmetic functions, and NEGATE 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:

SUBTRACT

Generic Function: SUBTRACT A B

Returns the difference of A and B.

Methods:

MULTIPLY

Generic Function: MULTIPLY A B

Returns the product of A and B.

Methods:

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:

NEGATE

Generic Function: NEGATE A

Returns the negation of A.

Methods:

+

Function: + X &REST XS

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

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

-

Function: - X &REST XS

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

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

*

Function: * X &REST XS

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

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

/

Function: / X &REST XS

Returns the quotient of all the arguments, computed by reducing over the argument list with the DIVIDE 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:

1-

Generic Function: 1- A

Returns A - 1.

Methods:

INCF

Macro: INCF PLACE &OPTIONAL (DELTA 1)

Increments the value of PLACE by DELTA, which defaults to 1, using the ADD function.

Effectively:

(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 SUBTRACT function.

Effectively:

(setf place (subtract place delta))

MINUSP

Generic Function: MINUSP A

Returns true if A is less than zero.

Methods:

PLUSP

Generic Function: PLUSP A

Returns true if A is greater than zero.

Methods:

ZEROP

Generic Function: ZEROP A

Returns true if A is equal to zero.

Methods:

SIGNUM

Generic Function: SIGNUM A

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

Methods:

ABS

Generic Function: ABS A

Returns the absolute value of A.

Methods:

EVENP

Generic Function: EVENP A

Returns true if A is even.

Methods:

ODDP

Generic Function: ODDP A

Returns true if A is odd.

Methods:

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:

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:

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:

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:

MOD

Generic Function: MOD N D

Returns the remainder of the FLOOR operation on N and D.

Methods:

REM

Generic Function: REM N D

Returns the remainder of the TRUNCATE operation on N and D.

Methods:

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.

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:

DEFSTRUCT

Macro: DEFSTRUCT OPTIONS &REST SLOTS

This is the same as CL:DEFSTRUCT however a COPY 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 HASH-MAP's.

Basic Usage:

(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

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.

Note: A COPY method should be implemented for user-defined iterators.

Iterator Creation

ITERATOR is the high-level function for creating iterators, whereas MAKE-ITERATOR AND MAKE-REVERSE-ITERATOR 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.

Note: 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

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 iterated over (see MAKE-ITERATOR and MAKE-REVERSE-ITERATOR for more a detailed description).

If FROM-END is true a reverse iterator is created (by MAKE-REVERSE-ITERATOR) otherwise a normal iterator is created (by MAKE-ITERATOR).

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.

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 ADVANCE) 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 AT should return the next element in the sequence or if the last element has already been iterated over, ENDP 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 selected 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:

(unless (endp iterator)
  (at iterator))

(SETF AT)

Generic Function: (SETF AT) VALUE ITERATOR

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

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

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. This position should be equivalent to the positioned obtained by calling ADVANCE N times.

The default method simply calls ADVANCE, on ITERATOR, N times.

Macros

Macros for iterator 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 ITERATOR 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 ADVANCE'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 DOITERS 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 ITERATOR function.

The forms in BODY are executed once for each element, with the value of the element bound to ELEMENT.

Collector

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

Implemented for lists, vectors and HASH-MAP's.

Basic Usage:

;; 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.

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.

No items should be accumulated, by ACCUMULATE or EXTEND, after this function is called.

The sequence returned might not be the same object passed to MAKE-COLLECTOR.

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 ENDP returns true) should be accumulated.

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

Methods:

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.

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

Methods:

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:

(make-sequence (cons type args) 0)

SEQUENCE-OF-TYPE

Function: SEQUENCE-OF-TYPE TYPE

Creates a new sequence of type TYPE, using MAKE-SEQUENCE-OF-TYPE.

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:

(SETF ELT)

Generic Function: (SETF ELT) VALUE SEQUENCE INDEX

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

Methods:

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 GENERIC-CL:ELT, i.e. is equivalent to:

(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:

(row-major-aref sequence (- (array-total-size array) 1 n))

The default method is implemented using GENERIC-CL:ELT, i.e. is equivalent to:

(elt sequence (- (length sequence) 1 n))

Note: 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 LASTCDR 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:

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.

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 HASH-MAP's / hash tables, returning the total number of elements in the map/table.

The following default methods are 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 HASH-MAP's.

The default returns true if ENDP 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 HASH-MAP'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 ADVANCE'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 ADVANCE'd till the end position is reached.

Methods:

(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 SUBSEQ for more details of how the START and END arguments are interpreted.

Methods:

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:

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

The default value of the :TEST keyword arguments is GENERIC-CL:EQUALP, 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.

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.

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 GENERIC-CL:LESSP by default.

Unlike CL:SORT this function is non-destructive.

For the default method to be efficient, efficient ADVANCE-N, SUBSEQ and LENGTH 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. TEST is GENERIC-CL:LESSP by default.

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

For the default method to be efficient, efficient ADVANCE-N, SUBSEQ and LENGTH 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

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.

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

NCONCATENATE

Function: NCONCATENATE RESULT &REST SEQUENCES

Destructively concatenates each sequence in SEQUENCES to the sequence RESULT.

MAP

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.

This 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

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.

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.

MAP-INTO

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 Collector interface.

MAP-TO

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 SEQUENCE-OF-TYPE). Returns the sequence in which the results of applying the function are stored.

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 FOREACH for that.

FOREACH

Function: FOREACH &REST SEQUENCES

Applies FUNCTION on each element of each sequence in SEQUENCES.

Returns NIL.

Generic Hash-Tables

This interface provides a hash-table data structure with the generic function HASH as the hash function and the generic function GENERIC-CL:EQUALP 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 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 HASH-MAP 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 MAKE-HASH-MAP, rather than built-in hash-tables. If a hash-table is obtained from an external source, use HASH-MAP or ENSURE-HASH-MAP to convert it to a HASH-MAP.

Standard Hash-Table Analogues:

| 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 (SETF AT) 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 ACCUMULATE method expects a CONS where the CAR is the key of the entry to create and the CDR is the corresponding value.

An EQUALP 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. Note: if the two maps have different test functions, the EQUALP is not necessarily symmetric i.e. (EQUALP A B) does not imply (EQUALP B A).

A COPY 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) 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 HASH and comparison function GENERIC-CL:EQUALP 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 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.

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 GENERIC-CL:EQUALP) 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)).

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 all EQUALP methods specialize on the same types for both their arguments, however will likely be inefficient.

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 EQUALP 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.

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

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 HASH-MAP containing all entries in the association list ALIST. ARGS are the additional arguments passed to MAKE-HASH-MAP.

COERCE Methods

The following COERCE methods are provided for HASH-MAPS:

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:

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

HASH-MAP'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. The values in the maps 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.

This function is non-destructive. A new set is always returned even if SET is a HASH-MAP / HASH-SET.

Accepts all keyword arguments accepted by CL:ADJOIN however they are ignored by the HASH-MAP method.

NADJOIN

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

Same as ADJOIN however is permitted to destructively modify SET.

The set returned is EQ to SET in the case of SET being a HASH-MAP however is not EQ if SET is a list, and is not required to be EQ. Thus this function should not be relied upon for its side effects.

Implemented for both lists and HASH-MAP's.

MEMBERP

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

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

Implemented for both lists and HASH-MAP'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 HASH-MAP however it is used to indicate that only the keys are important. This allows the EQUALP and COPY methods, specialized on HASH-SET's to be implemented more efficiently, as the keys are not compared/copied, than the methods specialized on HASH-MAPS.

The set operations work on both HASH-MAPS and HASH-SETS.

HASH-TABLE-SET

Function: HASH-TABLE-SET TABLE

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

HASH-SET

Function: HASH-SET &REST ELEMENTS

Returns a HASH-SET with elements ELEMENTS.

MAKE-HASH-SET

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

Returns a new empty HASH-SET.

Accepts the same keyword arguments as MAKE-HASH-MAP. The default TEST function is GENERIC-CL:EQUALP.

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:

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 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:

(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:

(let ((x 1))
  (declare (inline equalp)
	   (type number x))

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

Note: STATIC-DISPATCH requires the ability to extract TYPE and INLINE declarations from implementation specific environment objects. This is provided by the 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 STATIC-DISPATCH and 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.1

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

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

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

4.1.15 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.math

Source

package.lisp (file)

Use List

generic-cl

Exported Definitions

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

5.2 generic-cl.impl

Source

package.lisp (file)

Use List
Exported Definitions
Internal 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: 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.

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: 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)


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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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-20190202-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: 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

generic-sequences.lisp (file)

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

generic-sequences.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-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: 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: 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

generic-sequences.lisp (file)

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

generic-sequences.lisp (file)

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

generic-sequences.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: nconcatenate RESULT &rest SEQUENCES

Destructively concatenates each sequence in SEQUENCES to the sequence RESULT.

Package

generic-cl.impl

Source

generic-sequences.lisp (file)

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

generic-sequences.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: 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 (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 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 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 (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 (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: 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 (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 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 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 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 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 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 (IT iterator)
Method: extend COLLECTOR SEQ
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 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 (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 (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 (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 ARGS
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: 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: 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 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 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 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 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 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

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)


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-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-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-iterator INSTANCE
Package

generic-cl.impl

Source

iterator.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 the hash map contains. 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-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: iterator-p OBJECT
Package

generic-cl.impl

Source

iterator.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-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-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: 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: 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: 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-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: 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/math.lisp: The generic-cl/src/math<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/math.lisp: The generic-cl/src/math<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: The generic-cl/src/generic-sequences<dot>lisp file
Lisp File, generic-cl/src/hash-tables.lisp: The generic-cl/src/hash-tables<dot>lisp file
Lisp File, generic-cl/src/iterator.lisp: The generic-cl/src/iterator<dot>lisp file
Lisp File, generic-cl/src/math.lisp: The generic-cl/src/math<dot>lisp file
Lisp File, generic-cl/src/object.lisp: The generic-cl/src/object<dot>lisp file
Lisp File, generic-cl/src/package.lisp: The generic-cl/src/package<dot>lisp file
Lisp File, generic-cl/src/sequences.lisp: The generic-cl/src/sequences<dot>lisp file
Lisp File, generic-cl/src/sets.lisp: The generic-cl/src/sets<dot>lisp file
Lisp File, generic-cl/src/util.lisp: The generic-cl/src/util<dot>lisp file

M
Module, generic-cl/src: The generic-cl/src module

Jump to:   F   G   L   M  

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

A.2 Functions

Jump to:   (   *   +   -   /   1   <   =   >  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   U   V   Z  
Index Entry  Section

(
(setf array-iterator-array): Internal functions
(setf array-iterator-end): Internal functions
(setf array-iterator-index): Internal functions
(setf at): Exported generic functions
(setf at): Exported generic functions
(setf at): Exported generic functions
(setf at): Exported generic functions
(setf at): Exported generic functions
(setf at): Exported generic functions
(setf at): Exported generic functions
(setf at): Exported generic functions
(setf bound-list-iterator-cons): Internal functions
(setf bound-list-iterator-end): Internal functions
(setf elt): Exported generic functions
(setf elt): Exported generic functions
(setf elt): Exported generic functions
(setf elt): Exported generic functions
(setf elt): Exported generic functions
(setf front-list-collector-cons): Internal functions
(setf front-vector-collector-vector): Internal functions
(setf get): Exported generic functions
(setf get): Exported generic functions
(setf get): Exported generic functions
(setf hash-map-table): Exported functions
(setf hash-set-table): Exported functions
(setf hash-table-iterator-cons): Internal functions
(setf hash-table-iterator-table): Internal functions
(setf list-collector-head): Internal functions
(setf list-collector-tail): Internal functions
(setf list-iterator-cons): Internal functions
(setf reverse-array-iterator-array): Internal functions
(setf reverse-array-iterator-end): Internal functions
(setf reverse-array-iterator-index): Internal functions
(setf reverse-list-iterator-cons): Internal functions
(setf reverse-vector-iterator-array): Internal functions
(setf reverse-vector-iterator-end): Internal functions
(setf reverse-vector-iterator-index): Internal functions
(setf sub-iterator-end): Internal functions
(setf sub-iterator-iter): Internal functions
(setf subseq): Exported generic functions
(setf subseq): Exported generic functions
(setf subseq): Exported generic functions
(setf vector-iterator-array): Internal functions
(setf vector-iterator-end): Internal functions
(setf vector-iterator-index): Internal functions

*
*: Exported compiler macros
*: Exported functions

+
+: Exported compiler macros
+: Exported functions

-
-: Exported compiler macros
-: Exported functions

/
/: Exported compiler macros
/: Exported functions
/=: Exported compiler macros
/=: Exported functions

1
1+: Exported compiler macros
1+: Exported generic functions
1+: Exported generic functions
1+: Exported generic functions
1-: Exported compiler macros
1-: Exported generic functions
1-: Exported generic functions
1-: Exported generic functions

<
<: Exported compiler macros
<: Exported functions
<=: Exported compiler macros
<=: Exported functions

=
=: Exported compiler macros
=: Exported functions

>
>: Exported compiler macros
>: Exported functions
>=: Exported compiler macros
>=: Exported functions

A
abs: Exported compiler macros
abs: Exported generic functions
abs: Exported generic functions
abs: Exported generic functions
accumulate: Exported compiler macros
accumulate: Exported generic functions
accumulate: Exported generic functions
accumulate: Exported generic functions
accumulate: Exported generic functions
accumulate: Exported generic functions
accumulate: Exported generic functions
acos: Exported compiler macros
acos: Exported generic functions
acos: Exported generic functions
acosh: Exported compiler macros
acosh: Exported generic functions
acosh: Exported generic functions
add: Exported compiler macros
add: Exported generic functions
add: Exported generic functions
add: Exported generic functions
adjoin: Exported compiler macros
adjoin: Exported generic functions
adjoin: Exported generic functions
adjoin: Exported generic functions
advance: Exported compiler macros
advance: Exported generic functions
advance: Exported generic functions
advance: Exported generic functions
advance: Exported generic functions
advance: Exported generic functions
advance: Exported generic functions
advance-all: Internal functions
advance-n: Exported compiler macros
advance-n: Exported generic functions
advance-n: Exported generic functions
advance-n: Exported generic functions
advance-n: Exported generic functions
advance-n: Exported generic functions
alist-hash-map: Exported functions
array-iterator-array: Internal functions
array-iterator-end: Internal functions
array-iterator-index: Internal functions
array-iterator-p: Internal functions
asin: Exported compiler macros
asin: Exported generic functions
asin: Exported generic functions
asinh: Exported compiler macros
asinh: Exported generic functions
asinh: Exported generic functions
at: Exported compiler macros
at: Exported generic functions
at: Exported generic functions
at: Exported generic functions
at: Exported generic functions
at: Exported generic functions
at: Exported generic functions
at: Exported generic functions
atan: Exported compiler macros
atan: Exported generic functions
atan: Exported generic functions
atanh: Exported compiler macros
atanh: Exported generic functions
atanh: Exported generic functions

B
bound-list-iterator-cons: Internal functions
bound-list-iterator-end: Internal functions
bound-list-iterator-p: Internal functions

C
ceiling: Exported compiler macros
ceiling: Exported generic functions
ceiling: Exported generic functions
cis: Exported compiler macros
cis: Exported generic functions
cis: Exported generic functions
cis: Exported generic functions
clear: Exported compiler macros
clear: Exported generic functions
clear: Exported generic functions
clear: Exported generic functions
clear: Exported generic functions
cleared: Exported compiler macros
cleared: Exported generic functions
cleared: Exported generic functions
cleared: Exported generic functions
cleared: Exported generic functions
coerce: Exported compiler macros
coerce: Exported generic functions
coerce: Exported generic functions
coerce: Exported generic functions
coerce: Exported generic functions
collect-perform-op: Internal functions
collector-sequence: Exported compiler macros
collector-sequence: Exported generic functions
collector-sequence: Exported generic functions
collector-sequence: Exported generic functions
collector-sequence: Exported generic functions
collector-sequence: Exported generic functions
collector-sequence: Exported generic functions
compare: Exported compiler macros
compare: Exported generic functions
compare: Exported generic functions
compare: Exported generic functions
Compiler Macro, *: Exported compiler macros
Compiler Macro, +: Exported compiler macros
Compiler Macro, -: Exported compiler macros
Compiler Macro, /: Exported compiler macros
Compiler Macro, /=: Exported compiler macros
Compiler Macro, 1+: Exported compiler macros
Compiler Macro, 1-: Exported compiler macros
Compiler Macro, <: Exported compiler macros
Compiler Macro, <=: Exported compiler macros
Compiler Macro, =: Exported compiler macros
Compiler Macro, >: Exported compiler macros
Compiler Macro, >=: Exported compiler macros
Compiler Macro, abs: Exported compiler macros
Compiler Macro, accumulate: Exported compiler macros
Compiler Macro, acos: Exported compiler macros
Compiler Macro, acosh: Exported compiler macros
Compiler Macro, add: Exported compiler macros
Compiler Macro, adjoin: Exported compiler macros
Compiler Macro, advance: Exported compiler macros
Compiler Macro, advance-n: Exported compiler macros
Compiler Macro, asin: Exported compiler macros
Compiler Macro, asinh: Exported compiler macros
Compiler Macro, at: Exported compiler macros
Compiler Macro, atan: Exported compiler macros
Compiler Macro, atanh: Exported compiler macros
Compiler Macro, ceiling: Exported compiler macros
Compiler Macro, cis: Exported compiler macros
Compiler Macro, clear: Exported compiler macros
Compiler Macro, cleared: Exported compiler macros
Compiler Macro, coerce: Exported compiler macros
Compiler Macro, collector-sequence: Exported compiler macros
Compiler Macro, compare: Exported compiler macros
Compiler Macro, conjugate: Exported compiler macros
Compiler Macro, copy: Exported compiler macros
Compiler Macro, cos: Exported compiler macros
Compiler Macro, cosh: Exported compiler macros
Compiler Macro, count: Exported compiler macros
Compiler Macro, count-if: Exported compiler macros
Compiler Macro, count-if-not: Exported compiler macros
Compiler Macro, delete: Exported compiler macros
Compiler Macro, delete-duplicates: Exported compiler macros
Compiler Macro, delete-if: Exported compiler macros
Compiler Macro, delete-if-not: Exported compiler macros
Compiler Macro, denominator: Exported compiler macros
Compiler Macro, divide: Exported compiler macros
Compiler Macro, elt: Exported compiler macros
Compiler Macro, emptyp: Exported compiler macros
Compiler Macro, endp: Exported compiler macros
Compiler Macro, equalp: Exported compiler macros
Compiler Macro, erase: Exported compiler macros
Compiler Macro, evenp: Exported compiler macros
Compiler Macro, exp: Exported compiler macros
Compiler Macro, expt: Exported compiler macros
Compiler Macro, extend: Exported compiler macros
Compiler Macro, fill: Exported compiler macros
Compiler Macro, find: Exported compiler macros
Compiler Macro, find-if: Exported compiler macros
Compiler Macro, find-if-not: Exported compiler macros
Compiler Macro, first: Exported compiler macros
Compiler Macro, floor: Exported compiler macros
Compiler Macro, get: Exported compiler macros
Compiler Macro, greater-equal-p: Exported compiler macros
Compiler Macro, greaterp: Exported compiler macros
Compiler Macro, hash: Exported compiler macros
Compiler Macro, imagpart: Exported compiler macros
Compiler Macro, intersection: Exported compiler macros
Compiler Macro, isqrt: Exported compiler macros
Compiler Macro, last: Exported compiler macros
Compiler Macro, length: Exported compiler macros
Compiler Macro, less-equal-p: Exported compiler macros
Compiler Macro, lessp: Exported compiler macros
Compiler Macro, log: Exported compiler macros
Compiler Macro, make-collector: Exported compiler macros
Compiler Macro, make-iterator: Exported compiler macros
Compiler Macro, make-reverse-iterator: Exported compiler macros
Compiler Macro, make-sequence-of-type: Exported compiler macros
Compiler Macro, max: Exported compiler macros
Compiler Macro, memberp: Exported compiler macros
Compiler Macro, merge: Exported compiler macros
Compiler Macro, min: Exported compiler macros
Compiler Macro, minusp: Exported compiler macros
Compiler Macro, mismatch: Exported compiler macros
Compiler Macro, mod: Exported compiler macros
Compiler Macro, multiply: Exported compiler macros
Compiler Macro, nadjoin: Exported compiler macros
Compiler Macro, negate: Exported compiler macros
Compiler Macro, nintersection: Exported compiler macros
Compiler Macro, nmerge: Exported compiler macros
Compiler Macro, nreverse: Exported compiler macros
Compiler Macro, nset-difference: Exported compiler macros
Compiler Macro, nset-exclusive-or: Exported compiler macros
Compiler Macro, nsort: Exported compiler macros
Compiler Macro, nsubstitute: Exported compiler macros
Compiler Macro, nsubstitute-if: Exported compiler macros
Compiler Macro, nsubstitute-if-not: Exported compiler macros
Compiler Macro, numerator: Exported compiler macros
Compiler Macro, nunion: Exported compiler macros
Compiler Macro, oddp: Exported compiler macros
Compiler Macro, phase: Exported compiler macros
Compiler Macro, plusp: Exported compiler macros
Compiler Macro, position: Exported compiler macros
Compiler Macro, position-if: Exported compiler macros
Compiler Macro, position-if-not: Exported compiler macros
Compiler Macro, rational: Exported compiler macros
Compiler Macro, rationalize: Exported compiler macros
Compiler Macro, realpart: Exported compiler macros
Compiler Macro, reduce: Exported compiler macros
Compiler Macro, rem: Exported compiler macros
Compiler Macro, remove: Exported compiler macros
Compiler Macro, remove-duplicates: Exported compiler macros
Compiler Macro, remove-if: Exported compiler macros
Compiler Macro, remove-if-not: Exported compiler macros
Compiler Macro, replace: Exported compiler macros
Compiler Macro, reverse: Exported compiler macros
Compiler Macro, round: Exported compiler macros
Compiler Macro, search: Exported compiler macros
Compiler Macro, set-difference: Exported compiler macros
Compiler Macro, set-exclusive-or: Exported compiler macros
Compiler Macro, signum: Exported compiler macros
Compiler Macro, sin: Exported compiler macros
Compiler Macro, sinh: Exported compiler macros
Compiler Macro, sort: Exported compiler macros
Compiler Macro, sqrt: Exported compiler macros
Compiler Macro, stable-nsort: Exported compiler macros
Compiler Macro, stable-sort: Exported compiler macros
Compiler Macro, start: Exported compiler macros
Compiler Macro, subseq: Exported compiler macros
Compiler Macro, subsetp: Exported compiler macros
Compiler Macro, substitute: Exported compiler macros
Compiler Macro, substitute-if: Exported compiler macros
Compiler Macro, substitute-if-not: Exported compiler macros
Compiler Macro, subtract: Exported compiler macros
Compiler Macro, tan: Exported compiler macros
Compiler Macro, tanh: Exported compiler macros
Compiler Macro, truncate: Exported compiler macros
Compiler Macro, union: Exported compiler macros
Compiler Macro, zerop: Exported compiler macros
concatenate: Exported functions
concatenate-to: Exported functions
conjugate: Exported compiler macros
conjugate: Exported generic functions
conjugate: Exported generic functions
conjugate: Exported generic functions
copy: Exported compiler macros
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy-array-iterator: Internal functions
copy-bound-list-iterator: Internal functions
copy-front-list-collector: Internal functions
copy-front-vector-collector: Internal functions
copy-generic-hash-table: Internal functions
copy-hash-table-iterator: Internal functions
copy-iterator: Internal functions
copy-list-collector: Internal functions
copy-list-iterator: Internal functions
copy-reverse-array-iterator: Internal functions
copy-reverse-list-iterator: Internal functions
copy-reverse-vector-iterator: Internal functions
copy-vector-iterator: Internal functions
cos: Exported compiler macros
cos: Exported generic functions
cos: Exported generic functions
cosh: Exported compiler macros
cosh: Exported generic functions
cosh: Exported generic functions
count: Exported compiler macros
count: Exported generic functions
count: Exported generic functions
count: Exported generic functions
count-if: Exported compiler macros
count-if: Exported generic functions
count-if: Exported generic functions
count-if: Exported generic functions
count-if-not: Exported compiler macros
count-if-not: Exported generic functions
count-if-not: Exported generic functions
count-if-not: Exported generic functions

D
decf: Exported macros
deep-copy-array: Internal functions
deep-copy-list: Internal functions
deep-copy-vector: Internal functions
defstruct: Exported macros
delete: Exported compiler macros
delete: Exported generic functions
delete: Exported generic functions
delete: Exported generic functions
delete-duplicates: Exported compiler macros
delete-duplicates: Exported generic functions
delete-duplicates: Exported generic functions
delete-duplicates: Exported generic functions
delete-if: Exported compiler macros
delete-if: Exported generic functions
delete-if: Exported generic functions
delete-if: Exported generic functions
delete-if-not: Exported compiler macros
delete-if-not: Exported generic functions
delete-if-not: Exported generic functions
delete-if-not: Exported generic functions
denominator: Exported compiler macros
denominator: Exported generic functions
denominator: Exported generic functions
divide: Exported compiler macros
divide: Exported generic functions
divide: Exported generic functions
do-generic-map: Internal macros
doiter: Exported macros
doiters: Exported macros
doseq: Exported macros

E
elt: Exported compiler macros
elt: Exported generic functions
elt: Exported generic functions
elt: Exported generic functions
elt: Exported generic functions
elt: Exported generic functions
emptyp: Exported compiler macros
emptyp: Exported generic functions
emptyp: Exported generic functions
emptyp: Exported generic functions
emptyp: Exported generic functions
emptyp: Exported generic functions
emptyp: Exported generic functions
emptyp: Exported generic functions
endp: Exported compiler macros
endp: Exported generic functions
endp: Exported generic functions
endp: Exported generic functions
endp: Exported generic functions
endp: Exported generic functions
endp: Exported generic functions
endp: Exported generic functions
ensure-hash-map: Exported functions
equalp: Exported compiler macros
equalp: Exported generic functions
equalp: Exported generic functions
equalp: Exported generic functions
equalp: Exported generic functions
equalp: Exported generic functions
equalp: Exported generic functions
equalp: Exported generic functions
equalp: Exported generic functions
equalp: Exported generic functions
equalp: Exported generic functions
equalp: Exported generic functions
erase: Exported compiler macros
erase: Exported generic functions
erase: Exported generic functions
erase: Exported generic functions
erase: Exported generic functions
evenp: Exported compiler macros
evenp: Exported generic functions
evenp: Exported generic functions
evenp: Exported generic functions
every: Exported functions
exp: Exported compiler macros
exp: Exported generic functions
exp: Exported generic functions
expt: Exported compiler macros
expt: Exported generic functions
expt: Exported generic functions
extend: Exported compiler macros
extend: Exported generic functions
extend: Exported generic functions
extend: Exported generic functions
extend: Exported generic functions

F
fill: Exported compiler macros
fill: Exported generic functions
fill: Exported generic functions
fill: Exported generic functions
find: Exported compiler macros
find: Exported generic functions
find: Exported generic functions
find: Exported generic functions
find-if: Exported compiler macros
find-if: Exported generic functions
find-if: Exported generic functions
find-if: Exported generic functions
find-if-not: Exported compiler macros
find-if-not: Exported generic functions
find-if-not: Exported generic functions
find-if-not: Exported generic functions
first: Exported compiler macros
first: Exported generic functions
first: Exported generic functions
first: Exported generic functions
first: Exported generic functions
first: Exported generic functions
floor: Exported compiler macros
floor: Exported generic functions
floor: Exported generic functions
foreach: Exported functions
front-list-collector-cons: Internal functions
front-list-collector-p: Internal functions
front-vector-collector-p: Internal functions
front-vector-collector-vector: Internal functions
Function, (setf array-iterator-array): Internal functions
Function, (setf array-iterator-end): Internal functions
Function, (setf array-iterator-index): Internal functions
Function, (setf bound-list-iterator-cons): Internal functions
Function, (setf bound-list-iterator-end): Internal functions
Function, (setf front-list-collector-cons): Internal functions
Function, (setf front-vector-collector-vector): Internal functions
Function, (setf hash-map-table): Exported functions
Function, (setf hash-set-table): Exported functions
Function, (setf hash-table-iterator-cons): Internal functions
Function, (setf hash-table-iterator-table): Internal functions
Function, (setf list-collector-head): Internal functions
Function, (setf list-collector-tail): Internal functions
Function, (setf list-iterator-cons): Internal functions
Function, (setf reverse-array-iterator-array): Internal functions
Function, (setf reverse-array-iterator-end): Internal functions
Function, (setf reverse-array-iterator-index): Internal functions
Function, (setf reverse-list-iterator-cons): Internal functions
Function, (setf reverse-vector-iterator-array): Internal functions
Function, (setf reverse-vector-iterator-end): Internal functions
Function, (setf reverse-vector-iterator-index): Internal functions
</