[Openmcl-devel] Obfuscated Lisp contest anyone? (Seriously)

[Scott L. Burson]

Writing new binding macros is a popular activity.  I'll plug my own, in a
little Quickloadable package called Misc-Extensions.  It does both parallel
and sequential binding, and handles multiple values.  For example:

  (let ((a b c (foo))
          ((d (bar a c)))
          (e a))
     ...)

binds A, B, and C to values of (FOO), binds D to the result of calling BAR
on the first and third of those values, and binds E to the value of A in
the containing scope.

A DECLARE form at the top of the body is handled correctly.

It doesn't do DESTRUCTURING-BIND, but I use that far less frequently than I
use multiple values.

-- Scott

On Sat, Apr 15, 2023, 7:38 AM Tim McNerney <mc at media.mit.edu> wrote:

> Heck… A whole *course* could be taught on coding style.
>
> One entertaining source of *counter examples* is the Obfuscated C contest.
> (Perhaps there are others).
> *I’m mostly attracted by functionality implemented in ridiculously small
> amounts of code.*
> It makes me do silly things like de-obfuscation (macro-expansion,
> reformatting, etc).
> Maybe other people in this group have tried their hand at this too.
>
> *Hmm… Is it crazy to contemplate launching an obfuscated Lisp contest?*
> I would volunteer to be a judge. We’d want more than one, of course.
>
> --Tim
>
> On Apr 15, 2023, at 10:10, Tim McNerney <mc at media.mit.edu> wrote:
>
> I wouldn’t fret Arthur.
> The scope of declarations is a known weakness of Common Lisp (at least to
> me).
> I have found other syntactic situations where, whether in practice or by
> spec, it is impossible to declare variables.
> Declare *ignore* in *destructuring-bind* and *multiple-value-bind* come
> to mind.
>
> An effort to tighten this up might gain CCL an improved reputation.
> For this to have an effect on portability might need a committee and
> commitment from other maintainers.
> At least *ignore* declarations only affect compiler warnings.
> It had honestly never occurred to me to use MV-bind on special variables.
>
> I wonder if anyone has written a Lisp style guide. (Or how many and from
> where, if so).
> There are certain things I just never do, but the “rules” are in the
> attics of my mind.
> There is certainly a subset of the language that falls within “good
> practice” for readability.
> I know this is true with C++, because when I passed in function objects as
> arguments, my manager wrote in a review that my code was “too academic.”
>
> --Tim
>
> On Apr 14, 2023, at 19:54, Arthur Cater <arthur.cater at ucd.ie> wrote:
>
> Oh dear oh dear. I’m sorry I’ve opened a can of worms. I must apologise
> as I wasn’t looking at the spec, but at CLtL2 which clearly says LET* is a
> macro.
>
> Personally, I’d never write the code I gave as an example. I totally agree
> with Shannon, it’s ugly. The reason I asked is because I thought it’d be
> handy to write a new macro for my own use, and offer it to others,
> provisionally called LET**. The doc string says
>
> LET** provides a syntax for easily combining functionality of LET* and
> MULTIPLE-VALUE-BIND.
> Anything you can say to LET* you can say to LET**, the converse is not
> true.
> …...
>
>
> So I wanted to make it true that "Anything you can say to LET* you can say
> to LET**", and this involves handling declarations the same way, and that
> involves understanding how LET* handles declarations, and that led to
> asking myself whether it was possible to bind the same name multiple times
> - thinking I understood LET* expanded into multiple nested LETs. CLtL2
> didn’t say yea or nay, so I experimented and CCL said yea. What’s it doing
> then? What does it expand to? Let’s look at the macro expansion. What, it
> expands to itself??? Ask my openmcl friends.
>
> And it looks like it’s a can of worms. Just yesterday I was amused to see
> in somebody’s blog a snapshot of the CLtL2 index  “kludges, 1-971”.
>
>
>
> On 14 Apr 2023, at 22:01, Tim Bradshaw <tfb at tfeb.org> wrote:
>
>
> I think this is surprisingly underspecified.  I think the only sane answer
> is that declarations should apply to all the bindings of a given name in a
> given let* (or other sequential-binding) form.
>
>
> It is possible to check this :
>
>
> (let (c)
>
> (let ((x 1)
>
>       (x (progn (setf c (lambda () x)) 2))
>
>   (declare (special x))
>
>   (values c (lambda () x))))
>
>
> (sorry for paren/indentation errors, I'm typing this on a phone).  If the
> special declaration applies to both bindings then calling either function
> returned will be an error.  If it applies to only one: which, and why, and
> why does nothing say?  Either the spec simply omits this crucial
> information which would be a horrible omission, or the declarations apply
> to all the bindings.  Or, quite possibly I've just missed the place where
> it *does* say...
>
>
> --tim
>
>
> On 14 Apr 2023, at 21:17, Arthur Cater <arthur.cater at ucd.ie> wrote:
>
>
> I can only find a define-compiler-macro, I want to see how LET* handle
> declarations.
>
> It surprises me that it is apparently legal to say
>
>
> ? (let* ((it 7) (it (list it it)) (it (length it))) it)
>
> 2
>
> ?
>
>
> and I wondered how declarations (if present) are treated - but I can’t
> find the source code.
>
>
> TIA for any hep
>
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.clozure.com/pipermail/openmcl-devel/attachments/20230415/f7b9952e/attachment.htm>