FWIW, here are relevant definitions. (defn tokens->quoted-symbol [string] (list 'quote (read-string (clojure.string/replace string " " "_")))) ;;; When you want symbols, it can be convenient to get them directly. ;;; (If you want a mixture of strings and symbols, use both the macro and function above.) (defmacro with-matching-template-symbols [[template input-form] & body] (let [bindings-hashmap (eval (match-template template input-form))]` (when-not (= bindings-hashmap :fail) (let [symbols-hashmap (zipmap (keys bindings-hashmap) (map tokens->quoted-symbol (vals bindings-hashmap))) bindings-list (into [] (apply concat ; flatten goes to far here, destroys quoting. (into [] symbols-hashmap)))] (let ~bindings-list` ;; Evaluate the body. ~@body)))))

you're doing (eval (match-template template input-form))` when macroexpanding. In you failing example term-string has no value, so I don't know what ~input-form could look like

that's not the error I get when I try and run the code you've pasted here. The first error I get is

No such var: macro/term-string

(let [term-string "a person"]
    (macroexpand `(with-matching-template-symbols ["a *type" 'term-string]
                    (declare-inferred-type *type))))

(defn match-template [a b] {'*type 'person})

(defmacro with-matching-template-symbols [[template input-form]
                                          & body]
  (let [bindings-hashmap (match-template template input-form)]
    (when-not (= bindings-hashmap :fail)
      (let [symbols-hashmap (update-vals bindings-hashmap tokens->quoted-symbol)
            bindings-list (into [] cat symbols-hashmap)]
        `(let ~bindings-list
           ;; Evaluate the body.
           ~@body)))))

@U65G9MPCK using triple backticks around code makes it a lot easier to read than however you are adding code into your posts right now:

exorcise.core> (defmacro with-bindings-list [bindings-list & body]
	              `(let ~bindings-list
		             ~@body))
#'exorcise.core/with-bindings-list
exorcise.core> (with-bindings-list [x 1] x)
1
exorcise.core> (def the-bindings '[x 2])
#'exorcise.core/the-bindings
exorcise.core> (eval `(with-bindings-list ~the-bindings x))
Syntax error compiling at (*cider-repl Cogex/exorcise:localhost:44009(clj)*:169:16).
No such var: exorcise.core/x
exorcise.core>

synxtax quote (`) namespaces symbols

which is the dfiference

so the final x in your call to eval is actually exorcise.core/x

which doesn't match the let bound x

which is why you get the error about no such var exorcise.core/x

this is a case where it might actually be easier to construct the output with list rather than using `

yeah, if you constructed the form passed to eval in a way that didn't namespace qualify symbols automatically it would work

doing it manually with list is one way to do that

you can also do you things like ~'x

@U0NCTKEV8 @U064X3EF3 So, this is nice.

exorcise.core> (eval `(with-bindings-list ~the-bindings ~'x))
2

(defmacro with-matching-template-symbols [[template input-form]
                                          & body]
  (let [bindings-hashmap (match-template template input-form)]
    (when-not (= bindings-hashmap :fail)
      (let [symbols-hashmap (update-vals bindings-hashmap tokens->quoted-symbol)
            bindings-list (into [] cat symbols-hashmap)]
        ;; Syntax quote (`) namespaces symbols, which we don't want.
        ;; `(let ~bindings-list
        ;;   ~@body)
        (cons 'let
              (cons bindings-list
                    body))))))

Syntax error macroexpanding with-matching-template-symbols at (*cider-repl Cogex/template-matcher:localhost:45323(clj)*:1060:1).
Don't know how to create ISeq from: clojure.lang.Symbol

2. Unhandled clojure.lang.Compiler$CompilerException
   Error compiling *cider-repl Cogex/template-matcher:localhost:45323(clj)* at (1060:1)
   #:clojure.error{:phase :macro-syntax-check,
                   :line 1060,
                   :column 1,
                   :source
                   "*cider-repl Cogex/template-matcher:localhost:45323(clj)*",
                   :symbol with-matching-template-symbols}
             Compiler.java: 7027  clojure.lang.Compiler/macroexpand1
             Compiler.java: 7110  clojure.lang.Compiler/analyzeSeq
             Compiler.java: 6806  clojure.lang.Compiler/analyze
             Compiler.java: 6762  clojure.lang.Compiler/analyze
             Compiler.java: 6137  clojure.lang.Compiler$BodyExpr$Parser/parse
             Compiler.java: 5479  clojure.lang.Compiler$FnMethod/parse
             Compiler.java: 4041  clojure.lang.Compiler$FnExpr/parse
             Compiler.java: 7122  clojure.lang.Compiler/analyzeSeq
             Compiler.java: 6806  clojure.lang.Compiler/analyze
             Compiler.java: 7112  clojure.lang.Compiler/analyzeSeq
             Compiler.java: 6806  clojure.lang.Compiler/analyze
             Compiler.java:   38  clojure.lang.Compiler/access$300
             Compiler.java:  596  clojure.lang.Compiler$DefExpr$Parser/parse
             Compiler.java: 7124  clojure.lang.Compiler/analyzeSeq
             Compiler.java: 6806  clojure.lang.Compiler/analyze
             Compiler.java: 6762  clojure.lang.Compiler/analyze
             Compiler.java: 7198  clojure.lang.Compiler/eval
             Compiler.java: 7149  clojure.lang.Compiler/eval
                  core.clj: 3215  clojure.core/eval
                  core.clj: 3211  clojure.core/eval
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn/fn
                  AFn.java:  152  clojure.lang.AFn/applyToHelper
                  AFn.java:  144  clojure.lang.AFn/applyTo
                  core.clj:  667  clojure.core/apply
                  core.clj: 1990  clojure.core/with-bindings*
                  core.clj: 1990  clojure.core/with-bindings*
               RestFn.java:  425  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn
                  main.clj:  437  clojure.main/repl/read-eval-print/fn
                  main.clj:  437  clojure.main/repl/read-eval-print
                  main.clj:  458  clojure.main/repl/fn
                  main.clj:  458  clojure.main/repl
                  main.clj:  368  clojure.main/repl
               RestFn.java: 1523  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   84  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:   56  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:  152  nrepl.middleware.interruptible-eval/interruptible-eval/fn/fn
                  AFn.java:   22  clojure.lang.AFn/run
               session.clj:  218  nrepl.middleware.session/session-exec/main-loop/fn
               session.clj:  217  nrepl.middleware.session/session-exec/main-loop
                  AFn.java:   22  clojure.lang.AFn/run
               Thread.java:  833  java.lang.Thread/run

1. Caused by java.lang.IllegalArgumentException
   Don't know how to create ISeq from: clojure.lang.Symbol

                   RT.java:  557  clojure.lang.RT/seqFrom
                   RT.java:  537  clojure.lang.RT/seq
                  core.clj:  139  clojure.core/seq
                  core.clj:  139  clojure.core/seq
                  core.clj:   41  template-matcher.core/strip-leading-chars
                  core.clj:   39  template-matcher.core/strip-leading-chars
                  core.clj:   95  template-matcher.core/read-token
                  core.clj:   94  template-matcher.core/read-token
                  core.clj:  160  template-matcher.core/match-template
                  core.clj:  146  template-matcher.core/match-template
               RestFn.java:  425  clojure.lang.RestFn/invoke
                      REPL:  236  template-matcher.core/with-matching-template-symbols
                      REPL:  234  template-matcher.core/with-matching-template-symbols
               RestFn.java:  146  clojure.lang.RestFn/applyTo
                  Var.java:  705  clojure.lang.Var/applyTo
             Compiler.java: 7010  clojure.lang.Compiler/macroexpand1
             Compiler.java: 7110  clojure.lang.Compiler/analyzeSeq
             Compiler.java: 6806  clojure.lang.Compiler/analyze
             Compiler.java: 6762  clojure.lang.Compiler/analyze
             Compiler.java: 6137  clojure.lang.Compiler$BodyExpr$Parser/parse
             Compiler.java: 5479  clojure.lang.Compiler$FnMethod/parse
             Compiler.java: 4041  clojure.lang.Compiler$FnExpr/parse
             Compiler.java: 7122  clojure.lang.Compiler/analyzeSeq
             Compiler.java: 6806  clojure.lang.Compiler/analyze
             Compiler.java: 7112  clojure.lang.Compiler/analyzeSeq
             Compiler.java: 6806  clojure.lang.Compiler/analyze
             Compiler.java:   38  clojure.lang.Compiler/access$300
             Compiler.java:  596  clojure.lang.Compiler$DefExpr$Parser/parse
             Compiler.java: 7124  clojure.lang.Compiler/analyzeSeq
             Compiler.java: 6806  clojure.lang.Compiler/analyze
             Compiler.java: 6762  clojure.lang.Compiler/analyze
             Compiler.java: 7198  clojure.lang.Compiler/eval
             Compiler.java: 7149  clojure.lang.Compiler/eval
                  core.clj: 3215  clojure.core/eval
                  core.clj: 3211  clojure.core/eval
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn/fn
                  AFn.java:  152  clojure.lang.AFn/applyToHelper
                  AFn.java:  144  clojure.lang.AFn/applyTo
                  core.clj:  667  clojure.core/apply
                  core.clj: 1990  clojure.core/with-bindings*
                  core.clj: 1990  clojure.core/with-bindings*
               RestFn.java:  425  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn
                  main.clj:  437  clojure.main/repl/read-eval-print/fn
                  main.clj:  437  clojure.main/repl/read-eval-print
                  main.clj:  458  clojure.main/repl/fn
                  main.clj:  458  clojure.main/repl
                  main.clj:  368  clojure.main/repl
               RestFn.java: 1523  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   84  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:   56  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:  152  nrepl.middleware.interruptible-eval/interruptible-eval/fn/fn
                  AFn.java:   22  clojure.lang.AFn/run
               session.clj:  218  nrepl.middleware.session/session-exec/main-loop/fn
               session.clj:  217  nrepl.middleware.session/session-exec/main-loop
                  AFn.java:   22  clojure.lang.AFn/run
               Thread.java:  833  java.lang.Thread/run

@U65G9MPCK Sorry, I've been afk. I think the error is in whatever match-template does. Specifically,

core.clj:   41  template-matcher.core/strip-leading-chars

the syntax quote stuff won't apply above, syntax quote only namespace qualifies literal symbols

if you're not already, you might find it helpful to examine the expansion with something like (pprint (macroexpand '(with-matching-template-symbols ...))

so for (foo ~@bar)` foo will be namespace qualified but any symbols within bar will not be

@U064X3EF3 The error comes during macro expansion, so I don't know how to test it that way. macroexpand-1 doesn't show much.

ah, gotcha

Ok, this works now:

(defmacro process-variable-term [term-string]
  (cons 'with-matching-template-symbols
        (cons ["a *type"
               term-string]
              '((declare-inferred-type *type)
                (type->variable *type)))))

template-matcher.core> (process-variable-term "a person")
?person

Is there a non-namespacing version of syntax quote somewhere? I have a lot of macros to cons up, at this point. 🙂

syntax quote will only namespace literals. So where you've written

(cons 'let
              (cons bindings-list
                    body))

`(let ~bindings-list
     ~@body)

So maybe you could write something like this?

(defmacro process-variable-term [term-string]
  `(with-matching-template-symbols ["a *type" ~term-string]
     (declare-inferred-type ~'*type)
     (type->variable ~'*type)))

@l0st3d Yes, that works also. I think I should be able to keep my code clean, now. 🙂 THANK YOU !!

reduce is one way:

(second
 (reduce
  (fn [[curr so-far] s]
    (if (= s "END")
      [[] (conj so-far (conj curr s))]
      [(conj curr s) so-far]))
  [[] []]
  '("BEGIN" "a" "b" "c" "d" "END" "BEGIN" "foo" "bar" "END" "BEGIN" "c" "l" "j" "cool" "END")))

ah phenomenal, thank you!

@U011DMQ8DSS Pretty sure there must be a more idiomatic solution though. Perhaps someone else will pitch in.

core=> (->> ["BEGIN" "a" "b" "c" "d" "END" "BEGIN" "foo" "bar" "END" "BEGIN" "c" "l" "j" "cool" "END"]
            (partition-by #{"END"})
            (partition-all 2)
            (map (partial apply concat)))
(("BEGIN" "a" "b" "c" "d" "END")
 ("BEGIN" "foo" "bar" "END")
 ("BEGIN" "c" "l" "j" "cool" "END"))

Ah this is great, thank you too!

For the second example (and to betray my clojure newness): would (map (partial apply concat)) be equivalent to (map #(apply concat %))? Running through the code, it looks to give the same results, but I might be missing some nuance?

in this instance yeah they would be equivalent

This question of taking/dropping/partitioning upto some condition comes up quite often, but often isn't intuitive to solve with core fns. I think https://github.com/weavejester/medley take-upto and drop-upto fns can solve this sort of problem quite nicely:

(->> ["BEGIN" "a" "b" "c" "d" "END" "BEGIN" "foo" "bar" "END" "BEGIN" "c" "l" "j" "cool" "END"]
     (iterate #(m/drop-upto #{"END"} %))
     (map     #(m/take-upto #{"END"} %))
     (take-while seq))
;; => (("BEGIN" "a" "b" "c" "d" "END") ("BEGIN" "foo" "bar" "END") ("BEGIN" "c" "l" "j" "cool" "END"))

In @U11BV7MTK's solution, the case of the final group missing a closing tag raises an interesting and meaningful difference if you replace partition-all with partition.

(let [m ["BEGIN" "a" "b" "c" "d" "END"
         "BEGIN" "foo" "bar" "END"
         "BEGIN" "c" "l" "j" "cool"]
      group (fn [part-fn m]
              (->> m
                   (partition-by #{"END"})
                   (part-fn 2)
                   (map (partial apply concat))))]
  
  (prn (group partition-all m))
  ; => (("BEGIN" "a" "b" "c" "d" "END")
  ;      ("BEGIN" "foo" "bar" "END")
  ;      ("BEGIN" "c" "l" "j" "cool"))
  
  (prn (group partition m))
  ; => (("BEGIN" "a" "b" "c" "d" "END")
  ;      ("BEGIN" "foo" "bar" "END"))
  )

spec solution

user=> (require '[clojure.spec.alpha :as s])
nil
user=> (s/def ::group (s/cat :begin #{"BEGIN"} :body (s/+ string?)  :end #{"END"}))
:user/group
user=> (s/conform ::group ["BEGIN" "A" "B" "C" "END"])
{:begin "BEGIN", :body ["A" "B" "C"], :end "END"}

could that easily be extended to a s/coll-of solution to handle the original input? (forget how great the spec regex style stuff is)

yup

would be an s/cat with a regex +

(s/coll-of would result in a collection of groups, but the original input in the question is "flat")

Pretty sure you are storing something else to that atom somewhere

If you're not sure why this is happening, maybe try some puts debugging:

(swap! session #(do (prn %) (assoc % 123 123)))

Or if you want to find out where the value comes from, I guess something like this?

(require '[clojure.stacktrace :as st])

(def a (atom {} :validator
             (fn [v]
               (st/print-stack-trace (Exception.))
               (println "New value for atom: " v)
               true)))

(defn test []
  (swap! a assoc 1 1))

(test)
;; Will print stacktrace here

$ clj
Clojure 1.11.1
user=> (def s (atom {}))
#'user/s
user=> (swap! s assoc 123 123)

{123 123}
user=> user=> 

Thanks everyone:+1:

pprint will add new lines and respond to other pretty printing directives where prn will not

with-out-str is a macro, can't comp it

(i assume you meant to comp them "in spirit")

This particular case doesn't define any directives but I didn't think about the new lines, thanks 🙂 > with-out-str is a macro, can't comp it I didn't mean a literal comp, yes, but good point, especially since we're in #C053AK3F9! I fixed it, thanks 🙂

We have condp-> (and condp->>) in our "commons" library but we have moved away from using them as they make code harder to understand more often than they improve things.

https://github.com/worldsingles/commons/blob/master/src/ws/clojure/extensions.clj#L24-L48

What do you do instead? What are the suggestions? It is a pattern I see very often that I'd like to learn a more definitive solution

What we found was that we almost never threaded the result into additional predicates: only the initial expression:

(condp-> expr
  some-pred some-transform)

(condp-> expr
  pred1 transform1
  pred2 transform2
  ..    ..)

That said, I believe there is some consideration for including something like this in a future version of Clojure... https://clojure.atlassian.net/browse/CLJ-2732

I see. So, there were some legitimate uses for condp->, right? Thank you for this very complete answer!

"legimate" is subjective -- does it make the code easier to read than the alternatives? Some people might say "yes", others might say "no".

That CLJ ticket is about a situation where the predicate is the same in all cases: keep threading while the value is "valid" under some specific predicate, rather than threading each result through each different predicate.

You could compose multiple predicates into one. This example (written on phone, maybe buggy) assumes you don't want to mess with the original predicates, instead wrapping them up in a helper to only test on truthy input and pass the input forward on success.

(let [and-pred (fn [pred]
                   (fn [x] (and x (pred x) x))))]
   (when (-> x
            (and-pred pred1)
            (and-pred pred2)
            (and-pred pred3) (foo x))

Here's the backtrace:

2. Unhandled clojure.lang.Compiler$CompilerException
   Error compiling *cider-repl Cogex/exorcise:localhost:44009(clj)* at (674:16)
   #:clojure.error{:phase :macro-syntax-check,
                   :line 674,
                   :column 16,
                   :source
                   "*cider-repl Cogex/exorcise:localhost:44009(clj)*",
                   :symbol defmacro}
             Compiler.java: 7027  clojure.lang.Compiler/macroexpand1
             Compiler.java: 7092  clojure.lang.Compiler/macroexpand
             Compiler.java: 7178  clojure.lang.Compiler/eval
             Compiler.java: 7149  clojure.lang.Compiler/eval
                  core.clj: 3215  clojure.core/eval
                  core.clj: 3211  clojure.core/eval
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn/fn
                  AFn.java:  152  clojure.lang.AFn/applyToHelper
                  AFn.java:  144  clojure.lang.AFn/applyTo
                  core.clj:  667  clojure.core/apply
                  core.clj: 1990  clojure.core/with-bindings*
                  core.clj: 1990  clojure.core/with-bindings*
               RestFn.java:  425  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn
                  main.clj:  437  clojure.main/repl/read-eval-print/fn
                  main.clj:  437  clojure.main/repl/read-eval-print
                  main.clj:  458  clojure.main/repl/fn
                  main.clj:  458  clojure.main/repl
                  main.clj:  368  clojure.main/repl
               RestFn.java: 1523  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   84  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:   56  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:  152  nrepl.middleware.interruptible-eval/interruptible-eval/fn/fn
                  AFn.java:   22  clojure.lang.AFn/run
               session.clj:  218  nrepl.middleware.session/session-exec/main-loop/fn
               session.clj:  217  nrepl.middleware.session/session-exec/main-loop
                  AFn.java:   22  clojure.lang.AFn/run
               Thread.java:  833  java.lang.Thread/run

1. Caused by java.lang.IllegalArgumentException
   Don't know how to create ISeq from: clojure.lang.Symbol

                   RT.java:  557  clojure.lang.RT/seqFrom
                   RT.java:  537  clojure.lang.RT/seq
                   RT.java:  687  clojure.lang.RT/cons
                  core.clj:   29  clojure.core/cons
                  core.clj:  472  clojure.core/defmacro/add-implicit-args
                  core.clj:  481  clojure.core/defmacro/add-args
                  core.clj:  482  clojure.core/defmacro
                  core.clj:  454  clojure.core/defmacro
               RestFn.java:  146  clojure.lang.RestFn/applyTo
                  Var.java:  705  clojure.lang.Var/applyTo
             Compiler.java: 7010  clojure.lang.Compiler/macroexpand1
             Compiler.java: 7092  clojure.lang.Compiler/macroexpand
             Compiler.java: 7178  clojure.lang.Compiler/eval
             Compiler.java: 7149  clojure.lang.Compiler/eval
                  core.clj: 3215  clojure.core/eval
                  core.clj: 3211  clojure.core/eval
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn/fn
                  AFn.java:  152  clojure.lang.AFn/applyToHelper
                  AFn.java:  144  clojure.lang.AFn/applyTo
                  core.clj:  667  clojure.core/apply
                  core.clj: 1990  clojure.core/with-bindings*
                  core.clj: 1990  clojure.core/with-bindings*
               RestFn.java:  425  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn
                  main.clj:  437  clojure.main/repl/read-eval-print/fn
                  main.clj:  437  clojure.main/repl/read-eval-print
                  main.clj:  458  clojure.main/repl/fn
                  main.clj:  458  clojure.main/repl
                  main.clj:  368  clojure.main/repl
               RestFn.java: 1523  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   84  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:   56  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:  152  nrepl.middleware.interruptible-eval/interruptible-eval/fn/fn
                  AFn.java:   22  clojure.lang.AFn/run
               session.clj:  218  nrepl.middleware.session/session-exec/main-loop/fn
               session.clj:  217  nrepl.middleware.session/session-exec/main-loop
                  AFn.java:   22  clojure.lang.AFn/run
               Thread.java:  833  java.lang.Thread/run

(predicate) needs to be [predicate]. Clojure uses vector literals for the argument list

could be others. your unquoting of ~'predicate is probably not what you want if you are taking a predicate arg

@U11BV7MTK Re [predicate], ouch. (Probably too much CL history, not enough sleep. ;-)) But with that change the output assertion is (predicate nil nil), not (foo nil nil) as intended. Not sure what to do. <<- is a macro (that calls a macro in the Prolog interface). My predicate here (for assertion to Prolog) is foo, in case that's not obvious. Unquoting isn't getting me foo, though.

...fixed using function instead of macro.