Language design problems

A system for managing multiple namespaces - loading files into appropriate environments, and communicating names from one module to another in a controlled way - is sorely needed.

Better aggregate structures are needed (arrays, hash tables).

A condition/error signalling system is needed.

Each special form should be marked as being either primitive or a macro. This would allow users to write robust program-manipulating programs using only the released language.

There should be a way to remove bindings from locales.

There ought to be able to have variables named by objects other than symbols. Maybe there ought to be a generalized INTERN which creates a unique instance of any object, or something like OWL's UCONS (unique cons) primitive.

Should reintroduce DEFINE-LOCALE?

MEMQ, ASSQ, POSQ, etc. are inconsistent with the other aggregate accessing routines in that the aggregate argument follows the index argument and not vice versa.

Ideas for list routines: SUBSET, FILTER, FIND, set operations.

Need a term more specific than ``tree'' for whatever those things are.

The tree manipulation routines (e.g. ALIKEV?) should be user-extensible. Big problem with what TREE-HASH should do with unusual leaf nodes.

There should be a general way to do generic dispatches based on more than one argument.

There should be a non-side-effecting way to define methods for structures.

SYNONYM is a misleading name.

SETTER is inadequate. Why not PUSHER, SWAPPER, etc.? Is there any way to do this that's at the same time convenient, general, and efficient?

CASE and SELECT should use EQUIV? instead of EQ?.

Method-clauses aren't incrementally redefinable. What to do about this. Objects handling many operations become quite unmanageable. Maybe this is an implementation and editor problem, not a language problem.

The looping/iteration constructs are maybe a little too simple. Figure out some better ones without compromising principles, if possible. Waters' LetS looks sort of good.

CHECK-ARG is ad hoc. Need type inference and other compiler smarts. Need better type declaration syntax.

There should be case-ignoring character and string comparison predicates.

STRING-POSQ is not a good name.

STRING-REPLACE should probably be called STRING-REPLACE!, or flushed. Similarly with VECTOR-FILL, VECTOR-REPLACE.

The name DIGIT? is nconsistent with DIGIT->CHAR - does the term digit mean a character or an integer?

What about UPPERCASE? UPPER-CASE?? Ugh.

Enumerated types.

Infinities?

Should NOT-ZERO? and friends be renamed to be NONZERO? etc.?

Divulge expression syntax for quasiquote?

Maybe release BOUND?.

Need a way to make read tables be read-only.

Need LET-SYNTAX-TABLE and LET-READ-TABLE features?

Maybe flush the random not-parsable-as-number-implies-symbol syntax feature. It can be a real pain to catch typos in numbers.

I/O system improvements needed:
 Streams are pretty random. How does a stream differ from a sequence? There should be ways to coerce from streams to (infinite) sequences, and vice versa. Maybe the term stream should follow Sussman's usage (infinte sequence), not Common Lisp's (pointer into same).

 The FORMAT sublanguage is random and unextensible.

 Block-mode and/or ``binary'' I/O, for database or whatever applications.

 There ought to be a way to make the printer complain if it comes across an object which isn't re-readable.

 Ought to be a way to establish the line-length of a stream.

 HPOS and VPOS aren't precisely defined.

 SPACE operation needs a better definition.

Structure package improvements needed:
 DEFINE-STRUCTURE-TYPE features: initializers, variant record types, arguments to constructor procedure, type-restricted fields, alternate name construction.

 Maybe structures should have an official external syntax.

 Structures ought to be callable.

 COPY-STRUCTURE and COPY-STRUCTURE! ought to take as an additional argument the structure type to which the structure belongs. Alternatively, a copying procedure could be associated with the structure type object itself.

 Maybe there ought to be a way to test initializedness of structure components.