That approach seems reasonable to me on both accounts. Small notes: 1. consider not mirroring clojure.core names like seq maybe use xs which can mean "a list of anything". 2. fn-name isn't common either (as far as i know) " " gets used to mean "a value you can ignore". The most complex part of this is that the patterns and the seq aren't really the same, the _contains method shows that sometimes the seq contains a set which contains the pattern item. Though a tad longer, its still the same big O. Also requires less special cases:

;;following the convention here:
(set/subset? #{1 2} #{1 2 3})
;; => true

(defn ordered-subset?
  "is xs1 a ordered (by index) subset of xs2?"
  [xs1 xs2]
  (= xs1 (filter (set xs1) xs2)))


;; matching
(let [c1 [1 2 3]
      c2 [1 3]]
  (ordered-subset? c2 c1))
;; => true

;; not matching because not all patterns matched
(let [c1 [1 2]
      c2 [1 3]]
  (ordered-subset? c2 c1))
;; => false

;; not matching because patterns not in order
(let [c1 [3 1]
      c2 [1 3]]
  (ordered-subset? c2 c1))
;; => false

thx !

err this naming also works and is a bit more clear to use c1 and c2 in this case as those seem to indicate its a collection

I might need to filter before the data 😁

If inside a doseq and I knew I needed to skip the current element, I might use a when. Here is an example:

(doseq [x (range 10)]
 (when (odd? x)
  (println x)))

But, yeah, if you can do more work in the "functional domain" then filter would be better, as you suggest.

(doseq [x (filter odd? (range 10))]
 (println x))

thx! yep I was thinking to use println for skipping. but I think that I need to fliter data before passing to the sequence. My OOP imperative lazyness 😁

Ooh, I wanna know an elegant way to solve this too. I followed the same tutorial(I think) and messed up by doing something in the book before they asked and I had this error until I started over 😞 .

You may want to ask in #luminus channel