Hmm, why does this print tuples instead of single values?

(setval
   [ALL
    #_(multi-path :target/source )
    :target/neighbours ALL first (fn [v]
                                   (println “is this the first?” v)
                                   v)
    (pred #{“medline”})]
   NONE
   [{:target/source “not” :target/neighbours [[“medline” 1] [“not 2”]]}
    {:target/source “medline” :target/neighbours [[“medline” 1] [“not 2"]]}
    {:target/source “medline” :target/neighbours [[“medline” 1] [“not 2”]]}
    ])

ALL (every map value), :target/neighbours (vector of tuples), ALL (every tuple), first … oh I see

first is acting as a predicate?

ah, FIRST, doh…

I have trouble writing this in specter:

;; only x and y are allowed
  [{:name "x" :rels ["x" "y"]} ;=> fine, keep as is
   {:name "y" :rels ["x" "y" "z"]} ;=> keep only allowed rels: {:name "y" :rels ["x" "y"]}
   {:name "y" :rels ["z"]} ;=> no allowed rels, remove map completely
   {:name "z" :rels ["x" "y"]}] ;=> disallowed name, remove completely
  ;;=>
  [{:name "x" :rels ["x" "y"]}
   {:name "y" :rels ["x" "y"]}]
  

@borkdude

(setval [ALL
         (transformed [:rels ALL (pred (complement #{"x" "y"}))] (fn [_] NONE))
         (selected?
          (multi-path
            (not-selected? :name #{"x" "y"})
            (not-selected? :rels ALL #{"x" "y"})))
         ]
  NONE
  data)

you can also do

(setval [ALL
         (transformed [:rels ALL (pred (complement #{"x" "y"}))] (fn [_] NONE))
         (selected?
          (multi-path
            (not-selected? :name #{"x" "y"})
            [:rels empty?]))
         ]
  NONE
  data)

cool, cool, thanks!

@borkdude looking at it again you don't need the transformed:

(setval [ALL
         (multi-path
          [:rels ALL (pred (complement #{"x" "y"}))]
          (selected?
           (multi-path
             (not-selected? :name #{"x" "y"})
             [:rels empty?])))]
  NONE
  data)

ah, that one makes even more sense

More readable too. Wasn’t familiar with transformed yet

Eh, wait, I didn’t know complement exists either, I always do comp not f 🙂

transformed has same semantics as view, useful when doing multiple distinct transforms in one traversal

or for manipulating the results of a select in one go

@nathanmarz Does this make sense? I mean the pred thing in the let. I’m not really sure when to wrap a function in pred.

(defn keep-allowed-relations [user-profile relations]
  (let [disallowed? (pred #(not (allowed-source? user-profile %)))]
    (setval
     [ALL
      (multi-path
       [:target/neighbours ALL
        (selected? FIRST
                   disallowed?)]
       (selected?
        (multi-path
         [:target/neighbours empty?]
         (selected? :target/source disallowed?)
         )))]
     NONE
     relations)))

but it works

little simplification:

(setval
     [ALL
      (multi-path
       [:target/neighbours ALL
        (selected? FIRST
                   disallowed?)]
       (selected?
        (multi-path
         [:target/neighbours empty?]
         [:target/source disallowed?]
         )))]
     NONE
     relations)))

This is what I meant with, it must be possible with only selected? and multi-path 🙂

(my data looks a little different, hence the variation with FIRST)

@borkdude that's fine though it will be slightly more efficient to use pred in the path declaration rather than outside it

that way specter knows statically it's a compiled navigator and doesn't have to do an instance? check at runtime

but that's not a big deal

wrapping with pred in the let is much better than not, in which case specter would have to do a protocol invocation to convert function -> navigator every time that callsite is invoked