Nice simple intro. Thanks. I noticed several code blocks state the incorrect file name, ;; src/my_app/ , which should be ;; src/my_webapp/ (I assume that was the name in the older example before the update)

looks awesome!

I think it looks great at a glance. I'm not a beginner, but I very much like how you structured it, because the code is so straight forward. There is no abstraction or mental model that a reader needs to follow. Just basic stuff without surprises that goes straight from A to Z. I might actually use this to teach someone Clojure web dev.

Very nice, I would have loved this guide when starting out!

@U05254DQM Good catch -- thanks! Fixed.

Thanks, folks! The original text and code were both by John Gabriele, who hasn't been active here since 2017, but contributed a lot of great material on http://clojure-doc.org -- I just reorganized it and brought the code up-to-date (and switched it from Leiningen to Clojure CLI). Thanks, folks. The original work was all by John Gabriel

Very nice. This is the kind of thing I was looking for when I was a beginner, but I got lost in the amount of choices available. This kind of clear tutorial should be one of the first entry points for beginners.

No spec expert, but the example I see suggests you need a vector round the s/keys args:

(s/def ::user (s/keys :req-un [::id ::name]))

Yes, I used to have just that, but then I extracted the vector as list (in let), because I want to make that iteration over it and then pass it to the s/keys macros.

Of course it does work with (s/keys :opt-un []), but I'm surprised it doesn't work when I replace [] by a variable.

The error is not saying you cannot use variables in a macro, it is saying that, while macroexpanding your form it hit an error where it wanted an ISeq but got a clojure.lang.Symbol.

I'm not following. Like OK, the symbol is the list variable, I get that, but why shouldn't it be there?

"I'm surprised it doesn't work when I replace [] by a variable." Heh-heh, well the author of the macro chose to require a vector right there. I have written code that gracefully tolerates an atom or a sequence and works it out on the fly, but not always. Pardon, by the way, if my ignorance of spec is getting in the way. Saw a bit more:

(s/keys :req-un [:my.ns/x :my.ns/y])

Ima gonna be quiet, I think I do not know enough about spec!

Very simple, I had this:

(s/def ::labour price-validator)
(s/def ::material price-validator)
(s/def ::other price-validator)

(s/def ::cost-of-sale (s/keys :opt-un [::labour ::material ::other]))

(let [list [::labour ::material ::other]]
  (doseq [name list] (s/def name price-validator))
  (s/def ::cost-of-sale (s/keys :opt-un list)))

(s/def ::cost-of-sale (s/keys :opt-un [::labour ::material ::other]))

(s/def ::cost-of-sale (s/keys :opt-un list))

Oh, my, yes this is indeed a macro thing. Macros may or may not evaluate an arg. Your usage is hoping for evaluation, which indeed sometimes will be the case, but in this case the macro expansion code wants a vector in the code. Not at runtime when evaluation would take place.

Yeah it makes sense, but it surprised me anyways 🙈

Solution: write another macro that unpacks it 😄 I suppose is the way there. I think I'll just go with spec and will remember to update the list.

If you want to have fun, create a toy macro and outside any backquote expansion just print the parameters. It can be a downright shock what the Clojure reader presents to the macro.

My favorite was when I coded (mymacro 'foo) ind the print statement just inside mymacro showed (quote foo).

🙂

Oh yes.

OK, anyway at least I know what's going on now.

Thanks @U0PUGPSFR!

Just noticed one macro in my Matrix API:

(defmacro cF+ [[& options] & body]
  `(make-c-formula
     ~@options
     :code '~body
     :value unbound
     :rule (c-fn ~@body)))

(cF+ [:debug false]
                        (let [route (mget me :route)]
                          (some (fn [lesson]
                                  (when (= route (:route lesson))
                                    ;; (prn :selected-lesson-checks-lesson (:route lesson) lesson)
                                    lesson)) lessons)))

(defmacro ~tag [& ~vargs]
       (let [~tag-name (str '~tag)]
         (cond
           (nil? ~vargs)
           `(tiltontec.web-mx.gen/make-tag ~~tag-name {} {} nil)

           (map? (first ~vargs))
           (cond
             (map? (second ~vargs))
  ....etc....)

(span { :style "color:red"} { :some-custom-state 42} (str "The value is " (mget me :some-custom-state)))
(span { :style "color:red"} (str "The value is " (rand-int 99)))
(span (str "The value is " (rand-int 99)))

(span {} {} (str "The value is " (rand-int 99)))

Nice.

"Solution: write another macro that unpacks it 😄 I suppose is the way there." Haha, I missed that ^^^, but saw it when I was about to suggest exactly that. Good exercise in macrology, if nothing else. But I would indeed have offered the same smiley.

I encountered this a while ago, here's a solution (on my phone, so I'm writing this from memory, might have typos; use with caution):

(let [list [::labour ::material ::other]]
   (doseq [name list] (s/def name price-validator))
   (eval `(s/def ::cost-of-sale (s/keys :opt-un ~list))))