Is there a more comprehensive guide to writing navigators? I feel like I'm not getting the full picture from the API documentation.

Also, it feels like there's significant overlap between declarepath / providepath recursive paths and navigators?

Am I reading this correctly?

@zane there's also https://github.com/nathanmarz/specter/wiki/List-of-Macros

not sure what you mean by overlap, declarepath / providepath is the main way to make a recursive navigator

I saw that! Definitely helps.

I do agree the docs need work

Ah, there's probably a hole in my understanding around the intended uses of navigators and paths.

studying the implementations of the core navigators will probably help

Ah, that's a good suggestion.

Specter is awesome, by the way! Even with my flawed understanding of it it's already paying dividends.

thanks

though I will say the real power is unlocked when you understand how to write your own navigators

I'm getting that sense!

> though I will say the real power is unlocked when you understand how to write your own navigators I'd love to hear more about this: What kind of custom navigators do you feel deliver the most value?

@zane I have a whole suite of navigators for DAGs that I use privately

as an example

I can do very sophisticated recursive DAG transformations with almost no effort at all, and it runs with near optimal performance

Ah, I think I remember you mentioning that in a video or blog post somewhere.

the key is since that everything composes, you have a combinatoric explosion of ways in which you can apply Specter

Right!

For simple recursive descent through EDN I shouldn't have to reach for custom navigators though, right?

It should just be a matter of defining paths?

most likely

Okay, cool. That was my intuition.

you'll start off using Specter for getting in and out of nested data structures, and later you'll see how much more the concept of navigation generalizes

a big moment for me was realizing that adding to a set could be expressed as a navigator

(setval [:a (subset #{})] #{:new-elem} data)

Ah.

Yes.

Very monadic?

Atom feels similar.

This was making me think about navigators that descended into connections somehow, but that might be 🍌s.

select is semantically identical to the list monad, though specter's implementation is far more efficient

#shotsfired

I looked at how transform might be done as a monad some time ago but it wasn't obvious, and it wasn't really important to figure out

Are these available somewhere?

Hmm. So view is a bit weird in that it doesn't allow for transformations inside the view. (Which I guess makes sense.)

I wonder if transforms should even be allowed on paths that have views in them…

view works just fine in transform

transformed is similar to view except done with a path and transform function

@zane no, those navigators are not publicly available

I guess what I mean is, this is not what I was expecting:

(setval [(view namespace)]
        "woo"
        :hey/there)

"woo"

So now I'm trying to write NAMESPACE:

(defnav NAMESPACE
  []
  (select* [this structure next-fn]
           (next-fn (namespace structure)))
  (transform* [this structure next-fn]
              (keyword (next-fn (namespace structure))
                       (name structure))))

Holy crap, it works.

Magic!

nice one, I have a similar navigator

you want to handle the no-namespace case as well (when (next-fn (namespace structure)) returns nil)