Proposed Extensions To ANSI

• Changes to ANSI that are technically extensions, but address long-absent functionality which makes it difficult to portably do simple things.
• Extensions that cannot be reasonably implemented as libraries. (Note: this makes FFI technically in scope, but unless a high-quality spec materializes there's no need to mention it...)
• Extensions that can be implemented as libraries, but are very much standard folklore, like with-gensyms.

I imagine some of these proposals would be appropriate for submittal to CLRFI. -- Lars Brinkhoff

For user-space extensions, go and write a Library.

• Add conformal displacement (array slices) for multidimensional arrays.

• Extend ARRAY, VECTOR, STRING, and related type specifiers so that other array attributes can be specified (that the object is/is not displaced, adjustable, or (for vectors) it does/does not have a fill pointer.)

• Add weak-key hashtables, for example by standardizing on the extensions of Franz or Lispworks.

• Add weak vectors. (people interested in weak anything should also examine clisp's implementation [ in CVS as of 2004-05-30 ] of sophisticated weak data structures. ? Christophe)

• Have a way to weakly intern symbols in a package. The effect is that if nothing else refers to the symbol, the symbol can be gc-ed and removed from the package.

• Add a WITH-GENSYMS or WITH-UNIQUE-NAMES operator, since the absence of such impairs portability of non-trivial macros. Same for REBINDING.

• Specify, for lisps purporting to conform to :IEEE-FLOATING-POINT, the mechanism for enabling traps and clearing accrued exceptions, and for setting the rounding mode (and precision, where applicable), and how this interacts with standard CL functions such as FFLOOR and FCEILING.

• Improve the support for floating-point and complex arithmetic as outlined in section C.9 of the draft version of ISO/IEC 10967-2 and section C.7 of the draft version of ISO/IEC CD 10967-3. (There may be other standards from ISO/IEC JTC1/SC22/WG11 that could be made normative.)

• Add an ARGLIST function that, given a function designator, returns the argument list of the function. Suggested alternative name: FUNCTION-LAMBDA-LIST.

• Define a way for macros to wrap a LOOP around the body without affecting LOOP-FINISH forms within it. This could be done by defining a new LOOP keyword FINISH-NAME. Then, (loop ... do (loop finish-name foo ... do (loop-finish))) would finish the outer loop directly. To finish just the inner loop, you'd have to use (loop-finish foo). Macros would use gensyms.

  Other possible syntaxes include (loop using (loop-finish foo) ...), which puns on for-as-hash; (loop unfinishable ...), which would be entirely invisible to LOOP-FINISH; and (loop fully named foo ...), which would require both (RETURN-FROM foo ...) and (loop-finish foo).

  Would extending LOOP-FINISH to take the loop name as an argument be sufficient (exit from the innermost loop with the given name)? --Nikodemus Not quite. Users of macros would often omit the argument of LOOP-FINISH, for the sake of clarity or compatibility with current CL. Implementors of macros would not be able to handle such cases transparently. If LOOP is extended too, then only macro implementors need be careful, like they already are with names of variables; users can ignore the whole issue. -Kalle Olavi Niemitalo?

  I don't understand the need for this. However, LOOP already has a NAMED clause that could be used for LOOP-FINISH. It would overload its meaning, but it would reduce the number of changes needed. - Marco Antoniotti>

• (backquote ...) standard macro (like Scheme quasiquote) to allow for easier and scheme-like programmatic use of ` in constructs. I forget any arguments as to why it standardising it would not be good idea, but no doubt there are some. Constraining implementations seems unlikely as far as I can see. Morality-police discouraging its use, maybe, but I don't like that.

  If the semantics are going to match Scheme, then the name should too. Also, one cannot implement extensions such as `#C(,x ,y) if the ` reader macro is required to just read a form and put (backquote ...) around it. -Kalle Olavi Niemitalo?

  Is that really so? I would think that changing #C to translate #C(,x ,y) to (unquote (complex x y)) would do the trick. -Dirk Gerrits?

  This is a really, really bad idea; totally contrary to the meaning of backquote. Backquoted material should be handled by the reader (as in most CL implementations now). Turning it into a form is so bad, I'd seriously consider abandoning Lisp if it happened, I feel so strongly about that. -- AC

  No, it's a good idea. While most of the times it doesn't matter whether backquote is handled in the reader or not, there are times when it'd be really nice to know what the sexpression representation of '`(foo ,bar) is. Currently it's implementation defined which means that macro-writing macros can't take backquoted templates as input which they can then frob. A specific example: recently I was writing a mini-language and wanted to write two functions, one that compiled my intermediate representation for use in a macro and another that interpreted it. The compiler and interpreter were essentially identical except one generated code while the other executed it. If backquote templates were read into a specified sexpression form then I could have written a macro that took a list of backquoted templates and generated both functions. Instead I had to essentially implement my own backquote syntax that I could then take apart and put back together. -- Peter Seibel

  I don't claim to have thought this through, but requiring tighter binding of backquote/comma to the reader might let constructions such as #C`(,a ,b) fall out without extra per-read-macro specifications. --nikodemus

• Extend MAKE-HASH-TABLE to take any function as an equality predicate, and open it up so users can write their own hash functions. These will put CLOS objects on an equal footing with built-in objects.

  I'd rather see (DEFINE-HASH-TABLE-TEST test-function-name hash-function-designator), and making MAKE-HASH-TABLE accept any defined test in addition to #'eq.*. This way libraries can provide new hash-table types, and users of those libraries don't need to muck about with extra arguments to M-H-T. --Nikodemus

• Extend the guaranteed behavior of SUBTYPEP, so that it must succeed in determining subtype relationships in more situations. In particular:
  • If SUBTYPEP can determine that A is (or is not) a subtype of B, then it should determine that (NOT B) is (is not) a subtype of (NOT A).
  • (NOT (NOT A)) should have the same behavior as A.
  • If SUBTYPEP can determine that A is a subtype of B, and A is a subtype of C, then it should be able to determine that A is a subtype of (AND B C).
  • If SUBTYPEP can determine that A is a subtype of C, and B is a subtype of C, then it should be able to determine that (OR A B) is a subtype of C.
• Make more builtins be readably printable in some standard way. Alternately, allow users to define PRINT-OBJECT methods for builtin types on which the implementation does not provide a method.
• Add an ELASTIC-NEWLINE function.
• Franz's first-class environments proposal.
• Eliminate holes in standardized exceptional situations. The goal should be that safe code does not have undefined behaviors on erroneous arguments, since any such is a potential security hole.
• A function to expand user-defined types into primitives.
• Ability to efficiently list all specified readtable characters/dispatch-characters.
• Custom CLOS specializers without rewriting that much of standard-class.

Discussion on the nature of this page, moved here from the top

Does this page have any kind of scope for the sweepingness of the extensions that are appropriate? Is breaking existing uncontroversially conforming code acceptable? Should this page have pointers to actual specification-quality drafts, or is this a wishlist? How does it compare in scope to Lisp - Next Generation? ? Christophe

I for one hope that this remains conservative: things that could be done as implementation-specific extensions, things that extend the language in elegant ways even if technically prohibited or made difficult by the current standard -- and above all, things that people/implementations already have some experience with. No "breaks all existing code" changes, no radical redesigns -- the LNG page sounds like a better place for those. That said, things dealing with the language would somehow also seem more fertile then things that could be classified as libraries, so no sockets I hope... ? Nikodemus

I intended this page to have incremental changes and extensions to the language that go beyond what would be appropriate for Proposed ANSI Revisions and Clarifications, but not as radical as changes in Lisp - Next Generation. -- Paul Dietz

What about standard libraries? Wouldn't it be nice for ANSI to specify some libs for things like package management (asdf), advanced string operations, networking (including protocol support for http, ftp, and other common protocols), xml, etc.?

No, it wouldn't. Those things are just libraries; asdf for its part is widely available and easy to load. Getting the vendors to standardize a defsystem, a socket library, etc. Isn't Going To Happen. This page should deal with changes to ANSI that are technically extensions, but address long-absent functionality which makes it difficult to portably do simple things. Your suggestion is best suited for Lisp - Next Generation. - Brian Mastenbrook

I tried to clean up the top of the page a bit. I was tempted to leave out the third clause in the "what's in scope" bit, but that would have made with-gensyms homeless again... ? Nikodemus

This page is linked from: Proposed ANSI Revisions and Clarifications  

CLiki pages can be edited by anyone at any time. Imagine a fearsomely comprehensive disclaimer of liability. Now fear, comprehensively