Evan Gamble <[email protected]> writes:
> (let? [a foo :else nil
> b bar :is even?
> c baz :when (> b c)
> d qux]
> (f a b c d))
Macros like that just make your code so much LESS readable. I now have
to understand the semantics of a bunch of keywords specific to the
macro, their order of operations within the macro, as well as
recognizing the little ? on the end of the let as I'm scanning. I also
have to see if that's a keyword or the start of another binding!
:else nil? really?
:is ... Geezus christ
:when !?!?! Put down that nailgun, kid
;; This maintains the same logic (unless I fucked up transcoding)
;; and also the same err, complexity, in that forms are not exeuted if
;; they don't need to be, as your initial example, without nesting all
;; the way over to the side, or using some weird keyword language.
(when-let [a foo]
(let [b bar
c (when (even? b) baz)]
(when (and c (> b c))
(f a b c qux))))
;; or
(when-let [a foo]
(let [b bar
c (when (even? b) baz)
d (when (and c (> b c)) qux)]
(when d (f a b c d))))
Keep your constructs simple, and learn to love the nil.
Also, people have been writing lisp for a real long time, and they
haven't invented a chucklehead macro like let? yet, so prolly not really
needed to improve the readability...
--
Craig Brozefsky <[email protected]>
Premature reification is the root of all evil
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to [email protected]
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
