Sorry, the table below is not fully mobile-optimized yet.
(And anyway it'll probably be refactored into something that's not a table.)

In progress. Doing this thing properly could take months, but colossal tasks don't faze me.

Common Lisp symbol name
Bindings Stream Lisp counterparts and notes
&allow-other-keys
Lambda list keyword

Subsumed by new &key+.

&aux
Lambda list keyword

Removed.

&body
Lambda list keyword

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

&environment
Lambda list keyword

As is.

&key
Lambda list keyword

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

&optional
Lambda list keyword

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

&rest
Lambda list keyword

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

&whole
Lambda list keyword

As is.

*
Function

As is, but also operates on matrices and measurements.

Variable

Might be subsumed, renamed or removed.

Type specifier wildcard

As is.

**
Variable

Might be subsumed, renamed or removed.

***
Variable

Might be subsumed, renamed or removed.

*break-on-signals*
Variable

Probably as is.

*compile-file-pathname*
Variable

As is.

*compile-file-truename*
Variable

As is.

*compile-print*
Variable

As is.

*compile-verbose*
Variable

As is.

*debug-io*
Variable

As is.

*debugger-hook*
Variable

As is.

*default-pathname-defaults*
Variable

Probably as is, but might be renamed.

*error-output*
Variable

As is.

*features*
Variable

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.

*gensym-counter*
Variable

Probably as is.

*load-pathname*
Variable

As is.

*load-print*
Variable

As is.

*load-truename*
Variable

As is.

*load-verbose*
Variable

As is.

*macroexpand-hook*
Variable

Probably as is.

*modules*
Variable

Removed. Already obsolete and disused in Common Lisp anyway.

*package*
Variable

As is.

*print-array*
Variable

As is.

*print-base*
Variable

As is.

*print-case*
Variable

As is, except the default is :downcase.

*print-circle*
Variable

As is.

*print-escape*
Variable

As is.

*print-gensym*
Variable

Probably as is.

*print-length*
Variable

As is.

*print-level*
Variable

As is.

*print-lines*
Variable

As is.

*print-miser-width*
Variable

As is.

*print-pprint-dispatch*
Variable

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

*print-pretty*
Variable

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

*print-radix*
Variable

As is.

*print-readably*
Variable

As is.

*print-right-margin*
Variable

As is.

*query-io*
Variable

As is.

*random-state*
Variable

As is.

*read-base*
Variable

As is.

*read-default-float-format*
Variable

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

*read-eval*
Variable

As is.

*read-suppress*
Variable

As is.

*readtable*
Variable

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

*standard-input*
Variable

As is.

*standard-output*
Variable

As is.

*terminal-io*
Variable

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

*trace-output*
Variable

As is.

+
Function

As is, but also operates on matrices and measurements.

Variable

Might be subsumed, renamed or removed.

Method combination type

As is.

++
Variable

Might be subsumed, renamed or removed.

+++
Variable

Might be subsumed, renamed or removed.

-
Function

As is, but also operates on matrices and measurements.

Takes advantage of arity dispatch.

Variable

Might be subsumed, renamed or removed.

/
Function

As is, but also operates on matrices and measurements.

Takes advantage of arity dispatch.

Variable

Might be subsumed, renamed or removed.

//
Variable

Might be subsumed, renamed or removed.

///
Variable

Might be subsumed, renamed or removed.

/=
Function

As is, but takes advantage of &rest+.

1+
Function

As is.

1-
Function

As is.

<
Function

As is, but takes advantage of &rest+.

<=
Function

As is, but takes advantage of &rest+.

=
Function

As is, but takes advantage of &rest+.

>
Function

As is, but takes advantage of &rest+.

>=
Function

As is, but takes advantage of &rest+.

abort
Function

As is.

Restart

As is.

abs
Function

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

acons
Function

Probably remove.

acos
Function

As is. Probably keep same name.

acosh
Function

As is. Probably keep same name.

add-method
Generic function

As is.

adjoin
Function

As is. Probably keep same name.

adjust-array
Function

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

adjustable-array-p
Function

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

allocate-instance
Generic function

As is.

alpha-char-p
Function

Rename to alphabetic-character?.

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

alphanumericp
Function

Rename to alphanumeric-character?.

and
Macro

Maybe integrate multiple values more tightly.

Combining type specifier

As is.

Method combination type

As is.

append
Function

As is.

apply
Function

As is.

apropos
Function

Undetermined.

apropos-list
Function

Undetermined.

aref
Accessor

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

arithmetic-error
Condition type

As is.

arithmetic-error-operands
Function

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

arithmetic-error-operation
Function

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

array
System class

The arrays system will be majorly overhauled.

array-dimension
Function

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

array-dimension-limit
Constant variable

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

array-dimensions
Function

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

array-displacement
Function

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

array-element-type
Function

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

array-has-fill-pointer-p
Function

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

array-in-bounds-p
Function

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

Maybe add :if-negative :error option.

array-rank
Function

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

array-rank-limit
Constant variable
array-row-major-index
Function
array-total-size
Function

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

array-total-size-limit
Constant variable
arrayp
Function

Subsumed: (type? 'array object)

ash
Function

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

asin
Function

As is. Probably keep same name.

asinh
Function

As is. Probably keep same name.

assert
Macro

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

assoc
Function

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.

assoc-if
Function

See notes for assoc.

assoc-if-not
Function

Remove. Easily emulated with short replacement for complement.

atan
Function

As is. Probably keep same name.

atanh
Function

As is. Probably keep same name.

atom
Function

Subsumed: (type? 'atom object)

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

Type

As is.

Glossary entry

As is.

base-char
Type

Undetermined, maybe remove.

base-string
Type

Undetermined, maybe remove.

bignum
Type

As is.

bit
Accessor

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

See notes for bit-and for new bit function.

Type

As is.

Glossary entry

As is.

bit-and
Function

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

opt-arg subsumed by new into mechanism:

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

bit-andc1
Function

See bit-and notes.

bit-andc2
Function

See bit-and notes.

bit-eqv
Function

See bit-and notes.

bit-ior
Function

See bit-and notes.

bit-nand
Function

See bit-and notes.

bit-nor
Function

See bit-and notes.

bit-not
Function

See bit-and notes.

bit-orc1
Function

See bit-and notes.

bit-orc2
Function

See bit-and notes.

bit-vector
System class

As is.

bit-vector-p
Function

Subsumed: (type? 'bit-vector object)

bit-xor
Function

See bit-and notes.

block
Special operator

As is.

boole
Function

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.

boole-1
Constant variable

See boole notes.

boole-2
Constant variable

See boole notes.

boole-and
Constant variable

See boole notes.

boole-andc1
Constant variable

See boole notes.

boole-andc2
Constant variable

See boole notes.

boole-c1
Constant variable

See boole notes.

boole-c2
Constant variable

See boole notes.

boole-clr
Constant variable

See boole notes.

boole-eqv
Constant variable

See boole notes.

boole-ior
Constant variable

See boole notes.

boole-nand
Constant variable

See boole notes.

boole-nor
Constant variable

See boole notes.

boole-orc1
Constant variable

See boole notes.

boole-orc2
Constant variable

See boole notes.

boole-set
Constant variable

See boole notes.

boole-xor
Constant variable

See boole notes.

boolean
Type

As is.

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

both-case-p
Function

Rename to character-has-case?.

Maybe subsumed by a generic character properties testing mechanism.

boundp
Function

Probably subsumed: (bound? 'variable symbol)

break
Function

Return 0 values.

The new format mechanism will be used.

broadcast-stream
System class

As is.

broadcast-stream-streams
Function

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

built-in-class
System class

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

butlast
Function

Maybe rename to butlast-pair or something else.

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

byte
Function

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.

byte-position
Function

Quite probably removed, as explained in byte notes.

byte-size
Function

Quite probably removed, as explained in byte notes.

caaaar
Accessor

Removed. See notes for cons.

caaadr
Accessor

Removed. See notes for cons.

caaar
Accessor

Removed. See notes for cons.

caadar
Accessor

Removed. See notes for cons.

caaddr
Accessor

Removed. See notes for cons.

caadr
Accessor

Removed. See notes for cons.

caar
Accessor

Removed. See notes for cons.

cadaar
Accessor

Removed. See notes for cons.

cadadr
Accessor

Removed. See notes for cons.

cadar
Accessor

Removed. See notes for cons.

caddar
Accessor

Removed. See notes for cons.

cadddr
Accessor

Removed. See notes for cons.

caddr
Accessor

Removed. See notes for cons.

cadr
Accessor

Removed. See notes for cons.

call-arguments-limit
Constant variable

Subsumed: (impl-limit :call-arguments)

call-method
Local macro

As is.

call-next-method
Local function

As is.

car
Accessor

See notes for cons.

case
Macro

As is, except drop otherwise.

catch
Special operator

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.

ccase
Macro

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

cdaaar
Accessor

Removed. See notes for cons.

cdaadr
Accessor

Removed. See notes for cons.

cdaar
Accessor

Removed. See notes for cons.

cdadar
Accessor

Removed. See notes for cons.

cdaddr
Accessor

Removed. See notes for cons.

cdadr
Accessor

Removed. See notes for cons.

cdar
Accessor

Removed. See notes for cons.

cddaar
Accessor

Removed. See notes for cons.

cddadr
Accessor

Removed. See notes for cons.

cddar
Accessor

Removed. See notes for cons.

cdddar
Accessor

Removed. See notes for cons.

cddddr
Accessor

Removed. See notes for cons.

cdddr
Accessor

Removed. See notes for cons.

cddr
Accessor

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.

cdr
Accessor

See notes for cons.

ceiling
Function

As is.

cell-error
Condition type

As is.

cell-error-name
Function

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

cerror
Function

As is, except use new format mechanism.

change-class
Generic function

As is.

char
Accessor

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.

char-code
Function

Probably subsumed by code-point or something.

char-code-limit
Constant variable

See notes for char-code.

char-downcase
Function
char-equal
Function

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

char-greaterp
Function

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

char-int
Function

See notes for char-code.

char-lessp
Function

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

char-name
Function

Rename to character-name.

Returns the unicode name.

char-not-equal
Function

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

char-not-greaterp
Function

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

char-not-lessp
Function

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

char-upcase
Function
char/=
Function

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

char<
Function

Subsumed: ((char '<) char1 char2)

char<=
Function

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

char=
Function

Subsumed: ((char '=) char1 char2)

char>
Function

Subsumed: ((char '>) char1 char2)

char>=
Function

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

character
Function

Subsumed: (coerce 'character char)

System class

In Stream Lisp, represents a unicode code-point.

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

Glossary entry

As is.

characterp
Function

Subsumed: (type? 'character object)

check-type
Macro

As is.

cis
Function

As is.

class
System class

As is.

class-name
Generic function

Subsumed: (name class)

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

class-of
Function

As is.

clear-input
Function

Upgrade to a generic-function.

Return 0 values.

clear-output
Function

Upgrade to a generic-function.

Return 0 values.

close
Function

Upgrade to a generic-function.

clrhash
Function

Rename to clear-hash-table.

code-char
Function

See notes for char-code.

coerce
Function

Flip the order of the first 2 arguments.

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

compilation-speed
Optimize quality

As is.

compile
Function

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.

compile-file
Function

Probably as is.

compile-file-pathname
Function

Probably as is.

compiled-function
Type

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

compiled-function-p
Function

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

compiler-macro
Documentation type

As is.

compiler-macro-function
Accessor

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

complement
Function

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.

complex
Function

As is.

System class

As is.

Glossary entry

As is.

complexp
Function

Subsumed: (type? 'complex object)

compute-applicable-methods
Generic function

As is.

compute-restarts
Function

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.

concatenate
Function

As is.

concatenated-stream
System class

As is.

concatenated-stream-streams
Function

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

cond
Macro

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.

condition
Condition type

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.

conjugate
Function

As is.

cons
Function

As is, modulo renaming.

System class

Maybe renamed to pair.

Various more details about conses in Stream Lisp coming soon.

Glossary entry
consp
Function

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

constantly
Function

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

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

constantp
Function

Rename to constant?.

continue
Function

As is, except return 0 values.

Restart

As is.

control-error
Condition type

As is.

copy-alist
Function
copy-list
Function
copy-pprint-dispatch
Function
copy-readtable
Function
copy-seq
Function
copy-structure
Function
copy-symbol
Function
copy-tree
Function
cos
Function

As is.

cosh
Function

As is. Probably keep same name

count
Function
count-if
Function
count-if-not
Function
ctypecase
Macro

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

debug
Optimize quality

As is.

decf
Macro

Subsumed: (modify (1- place))

declaim
Macro

As is.

declaration
Declaration

As is.

declare
Symbol

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.

decode-float
Function

As is.

decode-universal-time
Function

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

defclass
Macro

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

defconstant
Macro

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

defgeneric
Macro
define-compiler-macro
Macro
define-condition
Macro
define-method-combination
Macro
define-modify-macro
Macro
define-setf-expander
Macro
define-symbol-macro
Macro
defmacro
Macro
defmethod
Macro
defpackage
Macro
defparameter
Macro
defsetf
Macro
defstruct
Macro
deftype
Macro
defun
Macro
defvar
Macro
delete
Function
delete-duplicates
Function

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

delete-file
Function
delete-if
Function
delete-if-not
Function
delete-package
Function
denominator
Function
deposit-field
Function
describe
Function
describe-object
Generic function
destructuring-bind
Macro
digit-char
Function
digit-char-p
Function

Rename to digit-character?.

directory
Function
directory-namestring
Function
disassemble
Function
division-by-zero
Condition type
do
Macro
do*
Macro
do-all-symbols
Macro
do-external-symbols
Macro
do-symbols
Macro
documentation
Generic function
dolist
Macro
dotimes
Macro
double-float
Type
double-float-epsilon
Constant variable
double-float-negative-epsilon
Constant variable
dpb
Function
dribble
Function
dynamic-extent
Declaration
ecase
Macro
echo-stream
System class
echo-stream-input-stream
Function
echo-stream-output-stream
Function
ed
Function
eighth
Accessor
elt
Accessor
encode-universal-time
Function
end-of-file
Condition type
endp
Function

Probably as is, but rename to end?.

enough-namestring
Function
ensure-directories-exist
Function
ensure-generic-function
Function
eq
Function
eql
Function
Type specifier
Parameter specializer
equal
Function
equalp
Function
error
Condition type
Function
Glossary entry
etypecase
Macro
eval
Function
eval-when
Special operator
evenp
Function

Renamed to even?.

every
Function
exp
Function
export
Function
expt
Function
extended-char
Type
fboundp
Function
fceiling
Function
fdefinition
Accessor
ffloor
Function
fifth
Accessor
file-author
Function
file-error
Condition type
file-error-pathname
Function
file-length
Function
file-namestring
Function
file-position
Function
file-stream
System class
file-string-length
Function
file-write-date
Function
fill
Function
fill-pointer
Accessor
find
Function
find-all-symbols
Function
find-class
Accessor
find-if
Function
find-if-not
Function
find-method
Generic function
find-package
Function
find-restart
Function
find-symbol
Function
finish-output
Function
first
Accessor
fixnum
Type
flet
Special operator
float
Function
System class
Glossary entry
float-digits
Function
float-precision
Function
float-radix
Function
float-sign
Function
floating-point-inexact
Condition type
floating-point-invalid-operation
Condition type
floating-point-overflow
Condition type
floating-point-underflow
Condition type
floatp
Function

Subsumed: (type? 'float object)

floor
Function
fmakunbound
Function
force-output
Function
format
Function
formatter
Macro
fourth
Accessor
fresh-line
Function
fround
Function
ftruncate
Function
ftype
Declaration
funcall
Function
function
Special operator
Documentation type
System class
Glossary entry
function-keywords
Generic function
function-lambda-expression
Function
functionp
Function

Subsumed: (type? 'function object)

gcd
Function
generic-function
System class
gensym
Function
gentemp
Function
get
Accessor
get-decoded-time
Function
get-dispatch-macro-character
Function
get-internal-real-time
Function
get-internal-run-time
Function
get-macro-character
Function
get-output-stream-string
Function
get-properties
Function
get-setf-expansion
Function
get-universal-time
Function
getf
Accessor
gethash
Accessor
go
Special operator
graphic-char-p
Function
handler-bind
Macro
handler-case
Macro
hash-table
System class
hash-table-count
Function
hash-table-p
Function

Subsumed: (type? 'hash-table object)

hash-table-rehash-size
Function
hash-table-rehash-threshold
Function
hash-table-size
Function
hash-table-test
Function
host-namestring
Function
identity
Function
if
Special operator
ignorable
Declaration
ignore
Declaration
ignore-errors
Macro
imagpart
Function
import
Function
in-package
Macro
incf
Macro

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

initialize-instance
Generic function
inline
Declaration
input-stream-p
Function

Subsumed: (type? 'input-stream object)

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

inspect
Function
integer
System class
integer-decode-float
Function
integer-length
Function
integerp
Function

Subsumed: (type? 'integer object)

interactive-stream-p
Function

Rename to interactive-stream?.

intern
Function
internal-time-units-per-second
Constant variable
intersection
Function
invalid-method-error
Function
invoke-debugger
Function
invoke-restart
Function
invoke-restart-interactively
Function
isqrt
Function
keyword
Type
keywordp
Function

Subsumed: (type? 'keyword object)

labels
Special operator
lambda
Macro
Symbol
lambda-list-keywords
Constant variable
lambda-parameters-limit
Constant variable
last
Function
lcm
Function
ldb
Accessor
ldb-test
Function
ldiff
Function
least-negative-double-float
Constant variable
least-negative-long-float
Constant variable
least-negative-normalized-double-float
Constant variable
least-negative-normalized-long-float
Constant variable
least-negative-normalized-short-float
Constant variable
least-negative-normalized-single-float
Constant variable
least-negative-short-float
Constant variable
least-negative-single-float
Constant variable
least-positive-double-float
Constant variable
least-positive-long-float
Constant variable
least-positive-normalized-double-float
Constant variable
least-positive-normalized-long-float
Constant variable
least-positive-normalized-short-float
Constant variable
least-positive-normalized-single-float
Constant variable
least-positive-short-float
Constant variable
least-positive-single-float
Constant variable
length
Function
let
Special operator
let*
Special operator
lisp-implementation-type
Function
lisp-implementation-version
Function
list
Function
System class
Glossary entry
list*
Function
list-all-packages
Function
list-length
Function
listen
Function
listp
Function

Subsumed: (type? 'list object)

load
Function
load-logical-pathname-translations
Function
load-time-value
Special operator
locally
Special operator
log
Function
logand
Function
logandc1
Function
logandc2
Function
logbitp
Function
logcount
Function
logeqv
Function
logical-pathname
Function
System class
logical-pathname-translations
Accessor
logior
Function
lognand
Function
lognor
Function
lognot
Function
logorc1
Function
logorc2
Function
logtest
Function
logxor
Function
long-float
Type
long-float-epsilon
Constant variable
long-float-negative-epsilon
Constant variable
long-site-name
Function
loop
Macro
loop-finish
Local macro
lower-case-p
Function
machine-instance
Function
machine-type
Function
machine-version
Function
macro-function
Accessor
macroexpand
Function
macroexpand-1
Function
macrolet
Special operator
make-array
Function
make-broadcast-stream
Function
make-concatenated-stream
Function
make-condition
Function
make-dispatch-macro-character
Function
make-echo-stream
Function
make-hash-table
Function
make-instance
Generic function
make-instances-obsolete
Generic function
make-list
Function
make-load-form
Generic function
make-load-form-saving-slots
Function
make-method
Local macro
make-package
Function
make-pathname
Function
make-random-state
Function
make-sequence
Function
make-string
Function
make-string-input-stream
Function
make-string-output-stream
Function
make-symbol
Function
make-synonym-stream
Function
make-two-way-stream
Function
makunbound
Function
map
Function
map-into
Function
mapc
Function
mapcan
Function
mapcar
Function
mapcon
Function
maphash
Function
mapl
Function
maplist
Function
mask-field
Accessor
max
Function
member
Function
Type specifier
member-if
Function
member-if-not
Function
merge
Function
merge-pathnames
Function
method
System class
method-combination
System class
Documentation type
method-combination-error
Function
method-qualifiers
Generic function
min
Function
minusp
Function

Rename to negative?.

mismatch
Function
mod
Function
Type specifier
most-negative-double-float
Constant variable
most-negative-fixnum
Constant variable
most-negative-long-float
Constant variable
most-negative-short-float
Constant variable
most-negative-single-float
Constant variable
most-positive-double-float
Constant variable
most-positive-fixnum
Constant variable
most-positive-long-float
Constant variable
most-positive-short-float
Constant variable
most-positive-single-float
Constant variable
muffle-warning
Function
Restart
multiple-value-bind
Macro
multiple-value-call
Special operator
multiple-value-list
Macro
multiple-value-prog1
Special operator
multiple-value-setq
Macro
multiple-values-limit
Constant variable
name-char
Function
namestring
Function
nbutlast
Function

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

nconc
Function

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

next-method-p
Local function

Rename to next-method?.

nil
Constant variable
Type
Glossary entry
nintersection
Function

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

ninth
Function
no-applicable-method
Generic function
no-next-method
Generic function
not
Function
Combining type specifier
notany
Function
notevery
Function
notinline
Declaration
nreconc
Function

Remove.

nreverse
Function

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

nset-difference
Function

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

nset-exclusive-or
Function

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

nstring-capitalize
Function

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

nstring-downcase
Function

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

nstring-upcase
Function

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

nsublis
Function

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

nsubst
Function

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

nsubst-if
Function

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

nsubst-if-not
Function

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

nsubstitute
Function

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

nsubstitute-if
Function

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

nsubstitute-if-not
Function

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

nth
Accessor
nth-value
Macro
nthcdr
Function
null
Function
System class
Glossary entry
number
System class
numberp
Function

Subsumed: (type? 'number object)

numerator
Function
nunion
Function

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

oddp
Function

Rename to odd?.

open
Function
open-stream-p
Function

Rename to open-stream?.

optimize
Declaration
or
Macro
Combining type specifier
otherwise
Symbol
output-stream-p
Function

See notes for input-stream-p.

package
System class
package-error
Condition type
package-error-package
Function
package-name
Function
package-nicknames
Function
package-shadowing-symbols
Function
package-use-list
Function
package-used-by-list
Function
packagep
Function

Subsumed: (type? 'package object)

pairlis
Function
parse-error
Condition type
parse-integer
Function
parse-namestring
Function
pathname
Function
System class
Glossary entry
pathname-device
Function
pathname-directory
Function
pathname-host
Function
pathname-match-p
Function
pathname-name
Function
pathname-type
Function
pathname-version
Function
pathnamep
Function

Subsumed: (type? 'pathname object)

peek-char
Function
phase
Function
pi
Constant variable
plusp
Function

Rename to positive?.

pop
Macro
position
Function
position-if
Function
position-if-not
Function
pprint
Function
pprint-dispatch
Function
pprint-exit-if-list-exhausted
Local macro
pprint-fill
Function
pprint-indent
Function
pprint-linear
Function
pprint-logical-block
Macro
pprint-newline
Function
pprint-pop
Local macro
pprint-tab
Function
pprint-tabular
Function
prin1
Function
prin1-to-string
Function
princ
Function
princ-to-string
Function
print
Function
print-not-readable
Condition type
print-not-readable-object
Function
print-object
Generic function
print-unreadable-object
Macro
probe-file
Function
proclaim
Function
prog
Macro
prog*
Macro
prog1
Macro
prog2
Macro
progn
Special operator
program-error
Condition type
progv
Special operator
provide
Function
psetf
Macro
psetq
Macro
push
Macro
pushnew
Macro
quote
Special operator
random
Function
random-state
System class
random-state-p
Function

Subsumed: (type? 'random-state object)

rassoc
Function
rassoc-if
Function
rassoc-if-not
Function
ratio
System class
rational
Function
System class
Glossary entry
rationalize
Function
rationalp
Function

Subsumed: (type? 'rational object)

read
Function
read-byte
Function
read-char
Function
read-char-no-hang
Function
read-delimited-list
Function
read-from-string
Function
read-line
Function
read-preserving-whitespace
Function
read-sequence
Function
reader-error
Condition type
readtable
System class
readtable-case
Accessor
readtablep
Function

Subsumed: (type? 'readtable object)

real
System class
realp
Function

Subsumed: (type? 'real object)

realpart
Function
reduce
Function
reinitialize-instance
Generic function
rem
Function
remf
Macro
remhash
Function
remove
Function
remove-duplicates
Function
remove-if
Function
remove-if-not
Function
remove-method
Generic function
remprop
Function
rename-file
Function
rename-package
Function
replace
Function
require
Function
rest
Accessor
restart
System class
restart-bind
Macro
restart-case
Macro
restart-name
Function
return
Macro
return-from
Special operator
revappend
Function
reverse
Function
room
Function
rotatef
Macro
round
Function
row-major-aref
Accessor
rplaca
Function
rplacd
Function
safety
Optimize quality
satisfies
Type specifier
sbit
Accessor
scale-float
Function
schar
Accessor
search
Function
second
Accessor
sequence
System class
serious-condition
Condition type
set
Function
set-difference
Function
set-dispatch-macro-character
Function
set-exclusive-or
Function
set-macro-character
Function
set-pprint-dispatch
Function
set-syntax-from-char
Function
setf
Macro
Documentation type
setq
Special operator
seventh
Accessor
shadow
Function
shadowing-import
Function
shared-initialize
Generic function
shiftf
Macro
short-float
Type
short-float-epsilon
Constant variable
short-float-negative-epsilon
Constant variable
short-site-name
Function
signal
Function
signed-byte
Type
signum
Function
simple-array
Type
simple-base-string
Type
simple-bit-vector
Type
simple-bit-vector-p
Function

Subsumed: (type? 'simple-bit-vector object)

simple-condition
Condition type
simple-condition-format-arguments
Function
simple-condition-format-control
Function
simple-error
Condition type
simple-string
Type
simple-string-p
Function

Removed, as there won't be a concept of "simple string" anymore.

simple-type-error
Condition type
simple-vector
Type
simple-vector-p
Function

Subsumed: (type? 'simple-vector object)

simple-warning
Condition type
sin
Function
single-float
Type
single-float-epsilon
Constant variable
single-float-negative-epsilon
Constant variable
sinh
Function
sixth
Accessor
sleep
Function
slot-boundp
Function
slot-exists-p
Function
slot-makunbound
Function
slot-missing
Generic function
slot-unbound
Generic function
slot-value
Function
software-type
Function
software-version
Function
some
Function
sort
Function
space
Declaration
special
Declaration
special-operator-p
Function

Rename to special-operator?.

speed
Declaration
sqrt
Function
stable-sort
Function
standard
Method combination type
standard-char
Type
standard-char-p
Function

Probably removed, since there probably won't be the concept of a "standard char" anymore.

standard-class
System class
standard-generic-function
System class
standard-method
System class
standard-object
Class
step
Macro
storage-condition
Condition type
store-value
Function
Restart
stream
System class
stream-element-type
Function
stream-error
Condition type
stream-error-stream
Function
stream-external-format
Function
streamp
Function

Subsumed: (type? 'stream object)

string
Function
System class
Glossary entry
string-capitalize
Function
string-downcase
Function
string-equal
Function
string-greaterp
Function
string-left-trim
Function
string-lessp
Function
string-not-equal
Function
string-not-greaterp
Function
string-not-lessp
Function
string-right-trim
Function
string-stream
System class
string-trim
Function
string-upcase
Function
string/=
Function
string<
Function
string<=
Function
string=
Function
string>
Function
string>=
Function
stringp
Function

Subsumed: (type? 'text object)

structure
Documentation type
structure-class
System class
structure-object
Class
style-warning
Condition type
sublis
Function
subseq
Accessor
subsetp
Function

Rename to subset?.

subst
Function
subst-if
Function
subst-if-not
Function
substitute
Function
substitute-if
Function
substitute-if-not
Function
subtypep
Function

Rename to subtype?.

svref
Accessor
sxhash
Function
symbol
System class
symbol-function
Accessor
symbol-macrolet
Special operator
symbol-name
Function
symbol-package
Function
symbol-plist
Accessor
symbol-value
Accessor
symbolp
Function

Subsumed: (type? 'symbol object)

synonym-stream
System class
synonym-stream-symbol
Function
t
Constant variable
Documentation type
System class
Glossary entry
tagbody
Special operator
tailp
Function
tan
Function
tanh
Function
tenth
Accessor
terpri
Function
the
Special operator
third
Accessor
throw
Special operator
time
Macro
trace
Macro
translate-logical-pathname
Function
translate-pathname
Function
tree-equal
Function
truename
Function
truncate
Function
two-way-stream
System class
two-way-stream-input-stream
Function
two-way-stream-output-stream
Function
type
Declaration
Documentation type
Glossary entry
type-error
Condition type
type-error-datum
Function
type-error-expected-type
Function
type-of
Function
typecase
Macro
typep
Function

Rename to type?.

Flip the order of the first 2 arguments.

Takes advantage of arity dispatch: given only one argument, returns a type test function. (Can't be used if passing an environment is needed, but that's rare.)

Maybe make the environment argument a keyword argument.

unbound-slot
Condition type
unbound-slot-instance
Function
unbound-variable
Condition type
undefined-function
Condition type
unexport
Function
unintern
Function
union
Function
unless
Macro
unread-char
Function
unsigned-byte
Type
untrace
Function
unuse-package
Function
unwind-protect
Special operator
update-instance-for-different-class
Generic function
update-instance-for-redefined-class
Generic function
upgraded-array-element-type
Function
upgraded-complex-part-type
Function
upper-case-p
Function
use-package
Function
use-value
Function
Restart
user-homedir-pathname
Function
values
Accessor
Type specifier
values-list
Function
variable
Documentation type
vector
Function
System class
Glossary entry
vector-pop
Function
vector-push
Function
vector-push-extend
Function
vectorp
Function

Subsumed: (type? 'vector object)

warn
Function
warning
Condition type
when
Macro
wild-pathname-p
Function

Rename to wild-pathname?.

with-accessors
Macro
with-compilation-unit
Macro
with-condition-restarts
Macro
with-hash-table-iterator
Macro
with-input-from-string
Macro
with-open-file
Macro
with-open-stream
Macro
with-output-to-string
Macro
with-package-iterator
Macro
with-simple-restart
Macro
with-slots
Macro
with-standard-io-syntax
Macro
write
Function
write-byte
Function
write-char
Function
write-line
Function
write-sequence
Function
write-string
Function
write-to-string
Function
y-or-n-p
Function

Rename to y-or-n?.

yes-or-no-p
Function

Rename to yes-or-no?.

zerop
Function

Rename to zero?.