Subject: LOOP and patterns (Re: Hash to list?)
From: Erik Naggum <>
Date: 1999/12/10
Newsgroups: comp.lang.lisp
Message-ID: <>

* Frode Vatvedt Fjeld <>
| What do you mean LOOP gives you here other than some (quite horrible,
| IMHO) artificially sweetened syntax of exactly the same as your LET-form?

  I'm curious about all this energy spent hating LOOP and reinventing silly
  wheels, not so much because I think LOOP is a good solution to a problem
  that does not seem to have any better solutions, but because I think it
  shows how the need for patterns might evolve.  all the time people whine
  about LOOP, they produce a _lot_ of code to supplant simple expressions.

  for some bizarre reasons that have nothing to do with just getting the
  job done or correctness or speed of execution or any of the numerous
  other reasons that are actually valid concerns for rewriting code, LOOP
  forms just _have_ to be rewritten, whined about, and detested.  offering
  to take its place is just a bunch of _new_ weirdness that the author is
  sure looks a lot better, but it involves the pattern argument in a strong
  sense: the author can read his own "pattern-oriented" code and claims,
  directly or indirectly, not to be able to read LOOP forms.  this seems
  very strange to me, but I have the same reaction to the IF* macro: if I
  can't macroexpand this abomination into the COND clauses it "really is",
  my head just hurts looking at it, so something I should be able to see is
  at work here.  yet I don't see it.

  what is it about some forms of expression that cry out for rewrites and
  which encourages us to start over with something that somebody else must
  have thought was much worse than their cure?  why is our cure better?

  this leads to my question: is the pattern business just a means of saying
  "it's OK to retch at this code, but don't rewrite it -- it's the best we
  have around", sort of like saying that all the other cures that people
  ache to deply will look no better than the pattern-oriented solution?

  (yeah, yeah, I'm aware that patterns are supposed to be abstract, but
  they wind up being implemented by duplicated, verbose code, regardless.)