This package exports some utility & syntactic sugar functions and macros.
License:
AGPL3
Copyright Pascal J. Bourguignon 2003 - 2016
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program.
If not, see <http://www.gnu.org/licenses/>
|
(+epsilon float) |
function |
Returns the float incremented by the smallest increment possible.
|
(-epsilon float) |
function |
Returns the float incremented by the smallest increment possible.
/APPLY
/NTH-ARG
|
(compose &rest functions) |
macro |
RETURN: The functional composition of the FUNCTIONS.
EXAMPLE: (compose abs sin cos) = (lambda (&rest args) (abs (sin (apply (function cos) args))))
NOTE: (compose) = (function identity)
(compose foo) = (function foo)
|
(compose-and-call &rest functions-and-arg) |
macro |
DO: Call the functional composition of the functions, on the
argument.
EXAMPLE: (compose-and-call abs sin cos 0.234) --> 0.8264353
COMPUTE-CLOSURE
CONCAT
|
(copy-hash-table table) |
function |
TABLE: (OR NULL HASH-TABLE)
RETURN: If TABLE is NIL, then NIL,
else a new HASH-TABLE with the same TEST, SIZE, REHASH-THRESHOLD
REHASH-SIZE and KEY->VALUE associations than TABLE.
(Neither the keys nor the values are copied).
CURRY
|
(defenum name-and-options &rest constants) |
macro |
Define an named enumeration type, a set of constants with integer
values, and a label function to produce the name of the constants from
the numerical value.
NAME-AND-OPTIONS:
The name of the enum type, or a list containing the name
of the enum type and options (no option defined so far).
The label function defined is named <enum-type-name>-LABEL
CONSTANTS: The first element of CONSTANTS may be an optional docstring.
Each constant is either a symbol naming the constant of the enum,
(the value is then the successor of the previous value),
or a list containing the constant name and the constant value.
|
(define-if-undefined &rest definitions) |
macro |
Use this to conditionally define functions, variables, or macros that may or may not be pre-defined in this Lisp. This can be used to provide CLtL2 compatibility for older Lisps. WHO'S THE AUTHOR?
|
(define-structure-class name-and-options &rest doc-and-slots) |
macro |
DO: Define a class implementing the structure API.
This macro presents the same API as DEFSTRUCT, but instead of
defining a structure, it defines a class, and the same functions
as would be defined by DEFSTRUCT.
The option :TYPE accepts LIST, VECTOR or STRUCTURE.
When given, it falls back to CL:DEFSTRUCT.
The DEFSTRUCT option :INITIAL-OFFSET is only supported
when :TYPE is given.
|
(define-with-object class-name slots) |
macro |
DO: Define a macro: (WITH-{CLASS-NAME} object &body body)
expanding to: (with-slots ({slots}) object @body)
|
(define-with-structure name-and-options &rest slots) |
macro |
NAME-AND-OPTIONS: Either a structure name or a list (name . options).
Valid options are: (:conc-name prefix).
DO: Define a macro: (WITH-{NAME} object &body body)
expanding to a symbol-macrolet embedding body where
symbol macros are defined to access the slots.
|
(dichotomy matchp start end) |
function |
MATCHP: A function taking an integer between [START,END[, and
returning an order (signed integer).
START: The minimum integer.
END: The maximum integer+1.
RETURN: (values found index order)
POST: (<= start index (1- end))
+-------------------+----------+-------+----------+
| Case | found | index | order |
+-------------------+----------+-------+----------+
| x < a[i] | FALSE | start | less |
| a[i] < x < a[i+1] | FALSE | i | greater |
| x = a[i] | TRUE | i | equal |
| a[max] < x | FALSE | end-1 | greater |
+-------------------+----------+-------+----------+
|
(dichotomy-search vector value compare &key start end key) |
function |
PRE: entry is the element to be searched in the table.
(<= start end)
RETURN: (values found index order)
POST: (<= start index end)
+-------------------+----------+-------+----------+
| Case | found | index | order |
+-------------------+----------+-------+----------+
| x < a[min] | FALSE | min | less |
| a[i] < x < a[i+1] | FALSE | i | greater |
| x = a[i] | TRUE | i | equal |
| a[max] < x | FALSE | max | greater |
+-------------------+----------+-------+----------+
|
(distinct-float-types) |
function |
RETURN: a subset of (long-float double-float single-float short-float)
that represents the partition of the float type for this
implementation.
There can be fewer than four internal representations for floats. If
there are fewer distinct representations, the following rules apply:
• If there is only one, it is the type single-float. In this
representation, an object is simultaneously of types single-float,
double-float, short-float, and long-float.
• Two internal representations can be arranged in either of the
following ways:
□ Two types are provided: single-float and short-float. An
object is simultaneously of types single-float, double-float,
and long-float.
□ Two types are provided: single-float and double-float. An
object is simultaneously of types single-float and
short-float, or double-float and long-float.
• Three internal representations can be arranged in either of the
following ways:
□ Three types are provided: short-float, single-float, and
double-float. An object can simultaneously be of type
double-float and long-float.
□ Three types are provided: single-float, double-float, and
long-float. An object can simultaneously be of types
single-float and short-float.
|
(eighth-arg x x x x x x x x &rest x) |
function |
RETURN: The eighth argument.
|
(equiv a b) |
function |
Return A ⇔ B
|
(extract-slots object slots) |
generic-function |
RETURN: A plist slot values. OBJECT: A lisp object. SLOTS: A list of slot names.
|
(fifth-arg x x x x x &rest x) |
function |
RETURN: The fifth argument.
FIND-CYCLES
|
(find-shortest-path from to successors) |
function |
RETURN: The shortest path of length>0 from FROM to TO if it exists, or NIL.
|
(first-arg x &rest x) |
function |
RETURN: The first argument.
|
(float-ctypecase expression &body clauses) |
macro |
EXPRESSION: an expression evaluate to some value.
CLAUSES: ctypecase clauses where the type is one of the standard
FLOAT direct subtypes, ie. one of (SHORT-FLOAT
SINGLE-FLOAT DOUBLE-FLOAT LONG-FLOAT).
NOTE: Implementations may conflate the various subtypes of FLOAT.
When two float types are conflated, some implementation
will signal a warning on any typecase that have them in
separate clauses. Since they're the same type, we can as
well remove the duplicate clauses.
SEE: CLHS Type SHORT-FLOAT, SINGLE-FLOAT, DOUBLE-FLOAT, LONG-FLOAT
DO: Expands to a CTYPECASE where only the clauses with unique
float types are present.
|
(float-etypecase expression &body clauses) |
macro |
EXPRESSION: an expression evaluate to some value.
CLAUSES: etypecase clauses where the type is one of the standard
FLOAT direct subtypes, ie. one of (SHORT-FLOAT
SINGLE-FLOAT DOUBLE-FLOAT LONG-FLOAT).
NOTE: Implementations may conflate the various subtypes of FLOAT.
When two float types are conflated, some implementation
will signal a warning on any typecase that have them in
separate clauses. Since they're the same type, we can as
well remove the duplicate clauses.
SEE: CLHS Type SHORT-FLOAT, SINGLE-FLOAT, DOUBLE-FLOAT, LONG-FLOAT
DO: Expands to a ETYPECASE where only the clauses with unique
float types are present.
|
(float-typecase expression &body clauses) |
macro |
EXPRESSION: an expression evaluate to some value.
CLAUSES: typecase clauses where the type is one of the standard
FLOAT direct subtypes, ie. one of (SHORT-FLOAT
SINGLE-FLOAT DOUBLE-FLOAT LONG-FLOAT).
NOTE: Implementations may conflate the various subtypes of FLOAT.
When two float types are conflated, some implementation
will signal a warning on any typecase that have them in
separate clauses. Since they're the same type, we can as
well remove the duplicate clauses.
SEE: CLHS Type SHORT-FLOAT, SINGLE-FLOAT, DOUBLE-FLOAT, LONG-FLOAT
DO: Expands to a TYPECASE where only the clauses with unique
float types are present.
|
(for (var first last &optional (step NIL stepp)) &body body) |
macro |
For loop.
DO: Repeat BODY with VAR bound to successive integer values from
FIRST to LAST inclusive.
If the optional STEP argument is abstent, then it is taken as 1 or -1
depending on the order of FIRST and LAST.
VAR is incremented by STEP and it stops when VAR goes above
or below LAST depending on the sign of STEP.
|
(fourth-arg x x x x &rest x) |
function |
RETURN: The fourth argument.
|
(functional-pipe &body forms) |
macro |
Execute forms in sequence each in a lexical scope where *, ** and *** are bound to the results of the last three previous forms. Return the results of the last form.
|
(gen-extract-slots ovar slots) |
function |
SEE: PRINT-PARSEABLE-OBJECT RETURN: A form building a plist of slot values.
|
(handling-errors &body body) |
macro |
DO: Execute the BODY with a handler for CONDITION and
SIMPLE-CONDITION reporting the conditions.
|
(hash-table-entries table) |
function |
Returns an a-list of the entries (key . val) in the TABLE.
|
(hash-table-keys table) |
function |
Returns a list of the keys in the TABLE.
|
(hash-table-path table &rest keys) |
function |
Given a hash-table that may contain other hash-table, walks down the path of KEYS, returning the ultimate value
|
(hash-table-select predicate table) |
function |
RETURN: An a-list of (k . v) from the TABLE
such as (funcall PREDICATE k v) is true.
|
(hash-table-to-sexp table) |
function |
Returns a sexp containing the hash-table data.
|
(hash-table-values table) |
function |
Returns a list of the values in the TABLE.
|
(hashtable &key test size rehash-size rehash-threshold elements) |
function |
Creates a new hash-table, filled with the given ELEMENTS. ELEMENTS must be a list of lists of two items, the key and the value. Note: we use the name HASHTABLE to avoid name collision.
|
(imply p q) |
function |
Return P ⇒ Q
|
(include-file path) |
function |
NOTE: Untasty, but sometimes useful.
DO: Read from the file at PATH all the sexps and returns a list of them
prefixed with 'progn.
USAGE: #.(include-file "source.lisp")
|
(map-into-hash-table sequence &key key value test size rehash-size rehash-threshold) |
function |
Creates a new hash-table, filled with the associations obtained by applying the function KEY and the function VALUE on each element of the SEQUENCE. The other key parameter are passed to MAKE-HASH-TABLE.
|
(maximize predicate list) |
function |
RETURN: The maximum value and the item in list for which predicate
is the maximum.
|
(ninth-arg x x x x x x x x x &rest x) |
function |
RETURN: The ninth argument.
|
(nsubseq sequence start &optional end) |
function |
RETURN: When the SEQUENCE is a vector, the SEQUENCE itself, or a dispaced
array to the SEQUENCE.
When the SEQUENCE is a list, it may destroy the list and reuse the
cons cells to make the subsequence.
|
(nth-arg n &rest arguments) |
function |
RETURN: The Nth argument following N.
|
(object-identity object) |
function |
RETURN: A string containing the object identity as printed by
PRINT-UNREADABLE-OBJECT.
|
(op-type-of symbol &optional env) |
function |
From: nikodemus@random-state.net Newsgroups: comp.lang.lisp Date: 29 Jul 2004 03:59:50 GMT Message-ID: <ce9snm$4bp8o$1@midnight.cs.hut.fi>
|
(pjb-defclass name super &rest args) |
macro |
This macro encapsulate DEFCLASS and allow the declaration of the attributes
in a shorter syntax.
ARGS is a list of s-expr, whose car is either :ATT (to declare an attribute)
or :DOC to give the documentation string of the class.
(:OPT ...) is not implemented yet.
(:ATT name type [ init-value [doc-string] | doc-string ]) defines
an attribute named NAME, of type TYPE, with the given initial value
and documentation strings. An accessor and an initarg keyword of
same NAME are also defined.
|
(print-hashtable table &optional stream) |
function |
Prints readably the hash-table, using #. and the HASHTABLE function.
|
(print-parseable-object (object stream &key (type t) identity) &rest slots) |
macro |
DO: Prints on the STREAM the object as a list. If all the
objects printed inside it are printed readably or with
PRINT-PARSEABLE-OBJECT, then that list should be
readable, at least with *READ-SUPPRESS* set to T.
OBJECT: Either a variable bound to the object to be printed,
or a binding list (VARNAME OBJECT-EXPRESSION), in
which case the VARNAME is bound to the
OBJECT-EXPRESSION during the evaluation of the SLOTS.
STREAM: The output stream where the object is printed to.
TYPE: If true, the class-name of the OBJECT is printed as
first element of the list.
IDENTITY: If true, the object identity is printed as a string in
the last position of the list.
SLOTS: A list of either a symbol naming the slot, or a list
(name expression), name being included quoted in the
list, and the expression being evaluated to obtain the
value.
RETURN: The object that bas been printed (so that you can use
it in tail position in PRINT-OBJECT conformingly).
EXAMPLE: (print-parseable-object (object stream :type t :identity t)
slot-1
(:slot-2 (thing-to-list (slot-2 object)))
slot-3)
|
(progn-concat forms) |
function |
DO: Wraps the forms in a PROGN. If they're PROGN forms,
then their PROGN is unwrapped first.
RCURRY
|
(safe-apply fun &rest args) |
function |
DO: Call APPLY or REDUCE depending on the length of ARGS.
NOTE: No prefix argument are allowed for REDUCE!
(safe-apply 'concatenate 'string list-of-sequence) doesn't work!
Use instead:
(safe-apply (lambda (a b) (concatenate 'string a b)) list-of-sequence)
|
(scase keyform &rest clauses) |
macro |
DO: A CASE, but for string keys. That is, it uses STRING= as test
instead of the ''being the same'' test.
|
(sconc &rest args) |
macro |
Concatenate strings.
|
(second-arg x x &rest x) |
function |
RETURN: The second argument.
|
(seventh-arg x x x x x x x &rest x) |
function |
RETURN: The seventh argument.
|
(sexp-to-hash-table sexp) |
function |
Create a new hash-table containing the data described in the sexp (produced by HASH-TABLE-TO-SEXP.
|
(sign n) |
function |
RETURN: -1 if N is negative,
+1 if N is positive,
0 if N is 0.
SIMPLE-PROGRAM-ERROR
SIMPLE-PROGRAM-ERROR-FORMAT-ARGUMENTS
SIMPLE-PROGRAM-ERROR-FORMAT-CONTROL
|
(sixth-arg x x x x x x &rest x) |
function |
RETURN: The sixth argument.
|
sloted-object |
class |
This is a mixin class providing generic SLOTS and PRINT-OBJECT methods.
Class precedence list: SLOTED-OBJECT STANDARD-OBJECT T
|
(slots-for-print object) |
generic-function |
This generic function collects a p-list describing the slots of the OBJECT. The generic function EXTRACT-SLOTS can be used to build this p-list. The APPEND method combination automatically appends the lists provided by the SLOTS-FOR-PRINT methods on the various subclasses.
|
(tenth-arg x x x x x x x x x x &rest x) |
function |
RETURN: The tenth argument.
|
(third-arg x x x &rest x) |
function |
RETURN: The third argument.
|
(topological-sort nodes lessp) |
function |
RETURN: A list of NODES sorted topologically according to
the partial order function LESSP.
If there are cycles (discounting reflexivity),
then the list returned won't contain all the NODES.
|
(tracing &body body) |
macro |
TRACE works only on non-CL functions. This macro will work somewhat on any form in body.
|
(tracing-labels defs &body body) |
macro |
This macro is a replacement for LABELS that traces the calls of the local functions.
|
(tracing-let clauses &body body) |
macro |
Like LET, but prints on the *trace-output* the value of the bindings.
|
(tracing-let* clauses &body body) |
macro |
Like LET*, but prints on the *trace-output* the value of the bindings.
|
(transitive-closure fun set &key test use) |
function |
FUN: set --> P(set)
x |--> { y }
SET: A sequence.
TEST: EQL, EQUAL or EQUALP
USE: Either HASH-TABLE or LIST; specifies the data structure used for the intermediary sets.
RETURN: A list containing closure of fun on the set.
EXAMPLE: (transitive-closure (lambda (x) (list (mod (* x 2) 5))) '(1)) --> (3 4 2 1)
NOTE: This version avoids calling FUN twice with the same argument.
|
(undisplace-array array) |
function |
RETURN: The fundamental array and the start and end positions into
it of a displaced array.
AUTHOR: Erik Naggum <erik@naggum.no>
|
(until condition &body body) |
macro |
Until loop.
|
(vector-init vector constructor) |
function |
DO: Sets all the slots in vector to the successive results of
the function CONSTRUCTOR called with integers from 0 up
s to the dimension of the VECTOR.
RETURN: VECTOR
|
(while condition &body body) |
macro |
While loop.
WITH-FUNCTIONS
|
(with-gensyms syms &body body) |
macro |
DO: Replaces given symbols with gensyms. Useful for creating macros. NOTE: This version by Paul Graham in On Lisp.
|
(wsiosbp &body body) |
macro |
Like with-standard-io-syntax but with the current package. The *PACKAGE* is kept bound to the current package.
|
(xor a b) |
function |
Return A ⊻ B