Standard Common Lisp symbols

Subsumed by new &key+.

Removed.

As is, but there's also a new &body+.

As is.

As is, but see note for &allow-other-keys.

As is, but strongly discouraged in general in public interfaces.

As is, but there's also a new &rest+.

As is.

As is, but also operates on matrices and measurements.

Might be subsumed, renamed or removed.

As is.

Might be subsumed, renamed or removed.

Might be subsumed, renamed or removed.

Probably as is.

As is.

As is.

As is.

As is.

As is.

As is.

Probably as is, but might be renamed.

As is.

Probably as is, but most uses of read-time conditionals will probably be subsumed by better mechanisms, such as generic functions dispatching on specific implementations or features.

Probably as is.

As is.

As is.

As is.

As is.

Probably as is.

Removed. Already obsolete and disused in Common Lisp anyway.

As is.

As is.

As is.

As is, except the default is :downcase.

As is.

As is.

Probably as is.

As is.

As is.

As is.

As is.

Probably as is, but the pprint dispatch tables API will probably have many enhancements.

As is, except the default is true instead of implementation-dependent.

As is.

As is.

As is.

As is.

As is.

As is.

As is, except the default will probably be double-float.

As is.

As is.

Probably as is, but the readtables API will definitely have many enhancements.

As is.

As is.

Probably as is, but might be renamed to *console-io*.

As is.

As is, but also operates on matrices and measurements.

Might be subsumed, renamed or removed.

As is.

Might be subsumed, renamed or removed.

Might be subsumed, renamed or removed.

As is, but also operates on matrices and measurements.

Takes advantage of arity dispatch.

Might be subsumed, renamed or removed.

As is, but also operates on matrices and measurements.

Takes advantage of arity dispatch.

Might be subsumed, renamed or removed.

Might be subsumed, renamed or removed.

Might be subsumed, renamed or removed.

As is, but takes advantage of &rest+.

As is.

As is.

As is, but takes advantage of &rest+.

As is, but takes advantage of &rest+.

As is, but takes advantage of &rest+.

As is, but takes advantage of &rest+.

As is, but takes advantage of &rest+.

As is.

As is.

Possibly rename to absolute or absolute-value.
Retain abs as suggested alias.

Probably remove.

As is. Probably keep same name.

As is. Probably keep same name.

As is.

As is. Probably keep same name.

Undetermined. This is a complex function and the arrays system will be overhauled.

Subsumed: ((its 'array :adjustable?) my-array)

As is.

Rename to alphabetic-character?.

Perhaps equivalent to something like (character-is 'alphabetic).

Rename to alphanumeric-character?.

Maybe integrate multiple values more tightly.

As is.

As is.

As is.

As is.

Undetermined.

Undetermined.

Maybe rename to something else.

Idiomatic Stream Lisp style might be to use element to access one-dimensional arrays. (No performance penalty if array is declared as such.)

As is.

Subsumed: ((its 'arithmetic-error :operands) my-error)

Subsumed: ((its 'arithmetic-error :operation) my-error)

The arrays system will be majorly overhauled.

Perhaps subsumed by a guarantee that (element ((its 'array :dimensions) my-array) i) will be just as efficient.

Subsumed: (impl-limit 'array :dimensions) (or similar).

Subsumed: ((its 'array :dimensions) my-array)

Subsumed: ((its 'array :base :offset) my-array)

Subsumed: ((its 'array :element-type) my-array)

Subsumed: ((its 'vector :fill-pointer?) vector) (accepts only vectors) and ((its 'array :fill-pointer?) array) (also accepts non-vector arrays but always returns nil in these cases.)

Probably as is, except rename to within-array-bounds?.

Maybe add :if-negative :error option.

Subsumed: ((its 'array :rank) my-array)

Subsumed: ((its 'array :size) my-array) and probably also (size my-array).

Subsumed: (type? 'array object)

As is, but maybe rename to ashift or bit-shift.

As is. Probably keep same name.

As is. Probably keep same name.

Probably as is. (Honestly I never think of using it.)

Maybe subsume with a general "scanning" mechanism.

Probably rename to something else. Maybe alist-find.

Separate "operator" arguments from "data" arguments.

(λ (&key key test) (λ (&key item alist) ...))

Remove test-not argument.

Don't accept nil as key.

See notes for assoc.

Remove. Easily emulated with short replacement for complement.

As is. Probably keep same name.

As is. Probably keep same name.

Subsumed: (type? 'atom object)

(But maybe keep anyway since we need the symbol regardless.)

As is.

As is.

Undetermined, maybe remove.

Undetermined, maybe remove.

As is.

Old bit accessor subsumed by... some new mechanism or other.

See notes for bit-and for new bit function.

As is.

As is.

Subsumed: ((bit :and) bit-array1 bit-array2)

opt-arg subsumed by new into mechanism:

(into result-array ((bit :and) bit-array1 bit-array2))

See bit-and notes.

See bit-and notes.

See bit-and notes.

See bit-and notes.

See bit-and notes.

See bit-and notes.

See bit-and notes.

See bit-and notes.

See bit-and notes.

As is.

Subsumed: (type? 'bit-vector object)

See bit-and notes.

As is.

The design of this one has always baffled me.

Allocating 16 constants (and symbols) for this strikes me as ridiculous.

Probably ((boole :and) integer-1 integer-2), etc.

Maybe rename.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

See boole notes.

As is.

Add a function binding that will be the canonical way to convert a generalized boolean to a boolean.

Rename to character-has-case?.

Maybe subsumed by a generic character properties testing mechanism.

Probably subsumed: (bound? 'variable symbol)

Return 0 values.

The new format mechanism will be used.

As is.

Subsumed: ((its 'broadcast-stream :streams) stream)

In Stream Lisp, almost all of Common Lisp's built-in-classes will just be normal classes that you can extend. What to create a new class of arrays that has a few additional slots? No problem! (Creating a "thin wrapper" is often annoying in many ways.)

Maybe rename to butlast-pair or something else.

Maybe it should work on all sequences. Keep same name in that case...

Probably eliminate the concept of "byte specifiers" entirely and just pass the position and size as separate arguments. I think the old approach clearly introduces an additional conceptual burden, and I don't see any benefits to make up for it.

The theoretical ability to pass byte specifiers around instead of directly to the functions that handle them doesn't seem to ever be used in practice, and the prospect of actually consing up a byte specifier at run time because of having done so is scary anyway.

If the concept of "byte specifiers" is not abolished, probably rename to bits.

Quite probably removed, as explained in byte notes.

Quite probably removed, as explained in byte notes.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Subsumed: (impl-limit :call-arguments)

As is.

As is.

See notes for cons.

As is, except drop otherwise.

As is. Probably keep it.

Discourage in favor of block/return-from mechanism in documentation. Also mention that this doesn't really have anything to do with exception handling as in other languages. Too many newbies wasting their time with it.

As is. (I never think of using it, but that's probably a failing on my part.)

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed. See notes for cons.

Removed or renamed to something else. See notes for cons.

This one is actually quite useful in Common Lisp. I don't know how useful it would be in Stream Lisp, with its better support for plists, among other things.

See notes for cons.

As is.

As is.

Subsumed: ((its 'cell-error :name) error)

As is, except use new format mechanism.

As is.

Remove, since Stream Lisp strings, probably called "text" instead, are unicode-aware, not based on vectors, and don't support (efficient) random access. Use element to access a string element by index (in linear time).

Reuse the name as a primary alias for character.

Probably subsumed by code-point or something.

See notes for char-code.

Subsumed: ((ci (char '=)) char1 char2)

Subsumed: ((ci (char '>)) char1 char2)

See notes for char-code.

Subsumed: ((ci (char '<)) char1 char2)

Rename to character-name.

Returns the unicode name.

Subsumed: ((ci (char '/=)) char1 char2)

Subsumed: ((ci (char '<=)) char1 char2)

Subsumed: ((ci (char '>=)) char1 char2)

Subsumed: ((char '/=) char1 char2)

Subsumed: ((char '<) char1 char2)

Subsumed: ((char '<=) char1 char2)

Subsumed: ((char '=) char1 char2)

Subsumed: ((char '>) char1 char2)

Subsumed: ((char '>=) char1 char2)

Subsumed: (coerce 'character char)

In Stream Lisp, represents a unicode code-point.

Common Lisp's concept of "character attributes" will probably be either expanded on or removed.

As is.

Subsumed: (type? 'character object)

As is.

As is.

As is.

Subsumed: (name class)

Unlike the MOP says, must be a symbol, not any kind of object.

As is.

Upgrade to a generic-function.

Return 0 values.

Upgrade to a generic-function.

Return 0 values.

Upgrade to a generic-function.

Rename to clear-hash-table.

See notes for char-code.

Flip the order of the first 2 arguments.

Takes advantage of arity dispatch: given only one argument, returns a coercing function.

As is.

Accept only one required argument, definition, which must be a lambda expression.

All functions are always compiled in Stream Lisp, so attempting to compile an existing function makes no sense.

Probably as is.

Probably as is.

Remove, since all functions are always compiled in Stream Lisp.

Remove, since all functions are always compiled in Stream Lisp.

As is.

Subsumed: (locate 'compiler-macro name :environment env) returns a compiler-macro object, which is a funcallable instance implementing the compiler-macro.

As is. This will be much more used in Stream Lisp, so add a very short primary alias. Probably just one unicode character, though I don't know which yet.

As is.

As is.

As is.

Subsumed: (type? 'complex object)

As is.

Probably as is. Possibly add a way to map over, accumulate and filter the restarts in addition or replacement. And/or some kind of dynamic-extent iterator.

As is.

As is.

Subsumed: ((its 'concatenated-stream :streams) stream)

Maybe rename to depending. Or maybe just keep the name, but I don't like abbreviations in general.

If no test-clause evaluates to true, return 0 values.

In Stream Lisp, condition types will just be normal classes defined (as subclasses of condition) and instantiated by the usual means. Condition classes might inherit from the condition-class metaclass.

As is.

As is, modulo renaming.

Maybe renamed to pair.

Various more details about conses in Stream Lisp coming soon.

Depends on what cons is renamed to, if it's renamed.

Accepts any number of values, which the returned closure will return as multiple values.

(funcall (constantly 1 2 3)) ➡ 1, 2, 3

Rename to constant?.

As is, except return 0 values.

As is.

As is.

As is.

As is. Probably keep same name

As is. (I never think of using it, but that's probably a failing on my part.)

As is.

Subsumed: (modify (1- place))

As is.

As is.

As is, except bound declarations will be wrapped around the variables they affect:

(λ ((&type integer foo) (&ignored test)) ...)

This has a host of advantages, especially in Stream Lisp. I'll explain this later.

As is.

Probably as is, but universal-times will probably have their own type, not just be non-negative integers.

(define (class foo (:metaclass bar)) superclasses
                        slot-specifiers)

Remove the ability to use symbols as type specifiers. It complicates the syntax for no reason. I don't think anyone ever actually uses that in actual code.

Otherwise, largely unchanged. Also subsumes define-condition and defstruct. The concept of structures will still exist but they'll just be classes with restricted capabilities having the structure-class metaclass.

Putting big documentation up there with the metaclass might not be ideal.

I'm thinking of maybe doing: (documenting doc (define (class foo) ...))

Stream Lisp will probably make quite heavier use of class options. I'm torn because some of them are important to see (like metaclass) and might affect processing of the slot options, so it's a good idea to put them up there, but others could just as well be at the usual place at the bottom. Keeping both places and concatenating them together would mean that if you didn't see an important option at the top, it could still be at the bottom. This could be addressed with conventions, but... Anyway, I don't know.

Subsumed: (define (constant foo) ...)

Subsumed: ((! 'remove-duplicates) ...)

Rename to digit-character?.

Probably as is, but rename to end?.

Renamed to even?.

Subsumed: (type? 'float object)

Subsumed: (type? 'function object)

Subsumed: (type? 'hash-table object)

Subsumed: (modify (1+ place)), (modify (+ place delta))

Subsumed: (type? 'input-stream object)

(I'm not 100% sure this is semantically a type test...)

Subsumed: (type? 'integer object)

Rename to interactive-stream?.

Subsumed: (type? 'keyword object)

Subsumed: (type? 'list object)

Rename to negative?.

Subsumed: ((! 'butlast) ...)

Subsumed: ((! 'append) ...)

Rename to next-method?.

Subsumed: ((! 'intersection) ...)

Remove.

Subsumed: ((! 'reverse) ...)

Subsumed: ((! 'set-difference) ...)

Subsumed: ((! 'set-exclusive-or) ...)

Subsumed: ((! 'string-capitalize) ...)

Subsumed: ((! 'string-downcase) ...)

Subsumed: ((! 'string-upcase) ...)

Subsumed: ((! 'sublis) ...)

Subsumed: ((! 'subst) ...)

Subsumed: ((! 'subst-if) ...)

Subsumed: ((! 'subst-if-not) ...)

Subsumed: ((! 'substitute) ...)

Subsumed: ((! 'substitute-if) ...)

Subsumed: ((! 'substitute-if-not) ...)

Subsumed: (type? 'number object)

Subsumed: ((! 'union) ...)

Rename to odd?.

Rename to open-stream?.

See notes for input-stream-p.

Subsumed: (type? 'package object)

Subsumed: (type? 'pathname object)

Rename to positive?.