These work as expected:

(match [{:a 1 :b 2}]
       [{:a 1}] true
       :else false
       )
;; => true


(match [{:a 1 :b 2}]
       [({:a 1} :only [:a])] true
       :else false
       )
;; => false

(let [map-pattern {:a 1}]
  (match [{:a 1}]
         [map-pattern] true
         :else false
         ))
;; => true

Is it maybe not possible to do this? It seems that patterns in local bindings are treated as literals and are only valid if they are exactly matched against them self.

> Anybody has the same experience? Yep. And let.

And to be fair, I learned Scheme to some extent way before Clojure, via SICP. And it was just as confusing back then.

It might also be just because I’m used to Clojure. People writing Scheme might say the same of Clojure

I've seen this argument before. The nitpick was, IIRC, "Clojure doesn't use S-expressions everywhere". Why exactly it's bad, wasn't really described.

I have read through this book, and yes the scheme took a bit of time to get comfortable with. Fortunately the book is very light on macros, which is not the case with other scheme I've encountered! A difference from Clojure that was confusing at first is that scheme apparently treats (...) and [...] the same, so those forms are interchangeable and how people use them is simply a matter of style. Once I got used to the (define (fn-name arg1 arg2 . rest) ...) form I admit that I found it kind of elegant, since it means the function definition looks exactly like the function invocation. On the other hand it loses out on Clojure's ability to define multiple arities... As I got farther along, I started thinking of scheme (let loop [x x y y] ... (loop (cdr x) (cdr y))) as virtually identical to Clojure's (loop [x x y y] ... (recur (next x) (next y))), though the Scheme syntax is more expressive because you can use it in more complex nestings, so when porting the code I'd need to pull out code into letfn forms, which I also pulled out whenever I came across a nested define... Curiously, letfn does seem more scheme-like than other parts of Clojure... Anyway, it's a great book! Have fun!

Oh yeah the worst named scheme standard functions: memq -> contains? and iota -> range.

cdr is not much better. :D Everything has its history, of course, but without knowing it it's impossible to guess what it does.

cdr is from decrementing register according to what I read

Yeah, I guess I've encountered enough cdaddrs by now to be able to just untangle them and move on without another thought. Clever hacks from the dawn of time... Definitely glad Clojure dropped them! 🙂

they are both aggressively lexically scoped (let has similar rules, function closures have the same capture behavior)

the surface level syntax is more diverse for clojure, semantically they are very similar (though the scheme functions for vectors and sets and hash-maps are excessively verbose)

In my head to understand what the code is doing.

Same here. Apparently this book ain’t gonna be easy to read then!

Im reading this book currently too. Its tough, both the scheme and the concepts!

I’ve read the first chapter on the regular expression and the temperature converter. So far it was not life changing, it’s something that I’ve been doing/advocating anyway in the past. Will see how the rest turns out!

Coming to that book from Clojure might not be as life-changing is it might be coming from a different background. I bought a copy but haven't read it yet, but I suspect if you've listened to many of Rich Hickey's talks, you will find some similar advice in this book. I also fully believe the book will have some good gems spread throughout.

This question of Scheme/Common Lisp readability after being accustomed to Clojure reminds me of the phrase: "The United States and Great Britain are two countries separated by a common language."

i.e. most things look familiar, but a little bit of the vocabulary means something completely different than you expect.

I’ve watched all the talks, yes.