I have some sympathy for this view of things as it was a question I had
while learning Clojure as well.
The general justification for the current behavior is that the thing being
bound is always on the left and the expression defining it is always on the
right.
On Saturday, January 18, 2014 3:58:09 AM UTC-6, t x wrote:
>
> With apologies for 3 questions in 1 day:
>
> (def a {:foo {:cat 20
> :dog 30}
> :bar "hi"})
>
> (let [{{cat :cat
> dog :dog} :foo
> bar :bar} a]
> [cat dog bar])
>
>
> (leth [{:foo {:cat cat
> :dog dog}
> :bar bar} a]
> [cat dog bar])
>
>
> I don't understand the reason why existing let key destructuring is
> "backwards"
>
> To me, it seems the fictional leth example is much "simpler" -- the mental
> model is just "do pattern matching"
>
> The current let example seems to be: "okay, um, so for "cat", you look at
> :cat, then you look at :foo", then you think (:cat (:foo a)) -- which seems
> much more work and error prone.
>
>
> Question:
>
> Where can I read up on the rationale behind the current design of map
> destructuring in let?
>
> Thanks!
>
--
--
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
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/groups/opt_out.
