Early access to Specter Koans: https://github.com/gdeer81/specter-koans currently only covers select and navigation and only takes about 10 minutes to complete but I'm going to constantly be adding more

nice, I’ll check em out later today!

@gdeer81 Great initiative!

Is there a bug here?

"FIRST is obvious on collections except for on a map"
 (= true (= [[0 :a]] (select FIRST (sorted-map 0 :a 1 :b))))

 "You will also run into the same thing with LAST on a map"
 (= false (= [1 :b] (select LAST (sorted-map 0 :a 1 :b))))

I think you're just missing a wrapping set of [] for the second assertion

because (though this could just be lucky)

(first (sorted-map 0 :a 1 :b))
=> [0 :a]
(last (sorted-map 0 :a 1 :b))
=> [1 :b]
(sp/select sp/FIRST (sorted-map 0 :a 1 :b))
=> [[0 :a]]
(sp/select sp/LAST (sorted-map 0 :a 1 :b))
=> [[1 :b]]

@james that one was actually pulled from the example https://github.com/nathanmarz/specter/wiki/List-of-Navigators#first but it looks like I used select instead of select-one

@bfabry yeah this koan has taught me to pay attention to which select function I'm using lol

checking out specter, looks great so far. one thing i'm trying to figure out is, given a nested data structure and a leaf node (e.g. :foo), can specter compute the path to that node for me?

@devth you're looking for this: https://github.com/nathanmarz/specter/issues/49

not implemented

you can do it manually for some cases using value collection (`collect` and collect-one)

thanks. i'll play with it

doesn't collect require that you know the path ahead of time? e.g. searching for :qux in a given structure – [:foo/bar {:baz/a [:qux]}] as an example

@devth there's an example above of what I mean

here:

(defnav ALL-INDEXED []
  (select* [this structure next-fn]
    ;; fill this in
    )
  (transform* [this structure next-fn]
    (map-indexed
      (fn [i v]
        (second (next-fn [i v])))
      structure
      )))


(def MyPath
  (recursive-path [] p
    (cond-path map? [ALL (collect-one FIRST) LAST p]
               vector? [ALL-INDEXED (collect-one FIRST) LAST p]
               STAY STAY)))

(transform MyPath
  (fn [& vals] vals)
  {:a {:b [:apple :orange :pear]
   :c [:juice]}
   :e [:cat :dog]})

@nathanmarz awesome, thanks!

if you filled in select* for ALL-INDEXED then you could do (select MyPath data) to retrieve the paths to each leaf element