Subject: Re: Anaphoric macros and packages
From: Erik Naggum <>
Date: 04 Dec 2002 23:37:10 +0000
Newsgroups: comp.lang.lisp
Message-ID: <>

* Gabor Melis
| What did I do wrong?

  You used a poorly designed feature.

  The key here is to get a short-hand for

(let ((expr (whatever)))
  (when expr

  but in the tradition of really badly designed languages, an implicit
  binding is used instead of doing explicit bindings in the Common Lisp
  tradition, which would also allow more than one binding/expression.

  I would much prefer a syntax like this:

(whereas ((expr-1 (whatever-1))
          (expr-2 (whatever-2)))

  Reading it like the standard contract legalese, the key idea is that all
  prior forms are true when an expression in the binding forms is evaluated
  (just like the operator `and´) and prior variable are bound to the (true)
  value of each prior expression.  The body is an implicit `progn´ that can
  thus rely on all of these forms having non-nil values.

  Having exhausted all useful things to do, I, too, have been thinking about
  how to do bindings and declarations more conveniently, and, not being the
  least bit afraid of parentheses, have decided on binding forms that have
  the general structure

(var-list [expression [decl-list]])

  where var-list is a designator for a list of (symbols naming) variables,
  expression may return multiple values bound to those variables with the
  standard nil default, and decl-list is a designator for a list of types.
  To be gratuitously super-clever, if the type of a variable in `whereas´
  is an explicit union of `null´ and something else to signal that `nil´ is
  a valid value, the result of the test is that using the succeeding value
  (etc by induction) and if it is the last value, the entire form is used
  for bindings, only.  Some examples may yet have a slightly illuminating

(whereas (((value present-p) (gethash ...) ((or null ...))))
  ;; value is now actually obtained from the hashtable
= (multiple-value-bind (value present-p) (gethash ...)
     (declare (type (or null ...) value))
     (when present-p

(whereas ((index (position ...) fixnum))
  ;; index now holds a fixnum index of an element actually in the sequence
= (let ((index (position ...)))
    (when index
      (locally (declare (fixnum index))

(whereas ((cell (assoc ...) cons)
          (value (cdr cell)))
  ;; cell now holds an actually matching cons cell from the alist
= (let ((cell (assoc ...)))
    (when cell
      (locally (declare (cons cell))
        (let ((value (cdr cell)))
          (when value

  My `let´ and other binding forms parallel this development with a final
  (additional) argument that is the declared types, and allow a list of
  variables for binding multiple values.  Required arguments in lambda
  lists may be typed just like methods on generic functions.  The amount of
  effort to get this done is surprisingly small, and making it fully
  backward-compatible is almost easier than breaking things.

  Please remember that the purpose of this stunt is to give people a good
  reason to stay away from ill-designed and very un-Common-Lispy ways of
  "improving" on the language.  Macros that bind things and which neither
  work when nested nor when naïvely exported in the package system may
  appear "cool" to people who come from other languages, but not to the
  seasoned users.  Just like some may believe that "then" and "else" have a
  place in `if´ "statements" because the language they /really/ want to use
  does that, misguided attempts annoy people more than benefit a community.
Erik Naggum, Oslo, Norway

Act from reason, and failure makes you rethink and study harder.
Act from faith, and failure makes you blame someone and push harder.