Cool. Jag gjorde något inom samma område för länge sedan https://github.com/kardan/taxa

Det var lite lek med macros och hierkier

Macron för att navigera träd?

Kom från att ha sett logic by exception i api responses. Är kanske inte så relevant 😇

😄 Jag förstår inte vad det innebär. Men visst är det kul att skriva macros, eller meta-programmering över lag. Gjorde ett eget programmeringsspråk på 90-talet, bara för att det var kul. med lex och yacc och liknande verktyg. Sådan glädje när man hittar användning man inte tänkt på. Men också därför det är lite svårt med macros.

Jag fattar inte heller - längre 🙂

Naturligtvis, jag använder en cond-> i det lite svårare exemplet ovan. Det funkar ganska bra i många fall, men i detta fall får jag inte ett fritt värde av cond->:ens test, och måste köra det två gånger:

(cond-> (:foreign outer)
            (assoc :banana (+ 2 (:foreign outer))))

jämför

(->as-when-let fruits [another (:foreign outer)]
         (assoc fruits :banana (+ 2 another)))

Här får det trådade värdet ett namn: fruits, medan (:foreign outer) får heta another. Det kanske inte är så farligt att göra ett uppslag i en map. Men det skulle ju kunna finnas behov av att göra ett anrop med sidoeffekter, så man syntaktiskt "tvingas" göra anropet två gånger. Det finns många vägar runt detta, men här försker jag vara snäll mot den som vill göra det hela inline i -> uttrycket.

Ah, läste på mobilen så såg inte hela exemplet. Tycker att cond-> är cleant nog. Om man vill göra något advancerat med sidoeffekter så skulle jag refaktorera ut i en funktion.

Eller bara inte skriva trådade uttryck, det är inte alltid det snyggaste 😉

@U04JJEM2X1V Japp, håller med dig Carl. Jag har också en förmåga att skapa nya funktioner. Och ska det vara sidoeffekter så definitivt. Mitt problem är att jag snabbt blir förvirrad när jag ser kod som i mitt första exempel. "Å va betyder det här då"-känslan. Ibland får man kritik för att man refaktoriserat ut till en funktion, med argument att det är mer överblickbart med om valen är up front in i threading uttrycket. För mig är det något som kan åtgärdas med bra namngivning. Men jag tycker argumentationen är bra. Det finns ibland en fördel att se valen up front, och man har ju inte alltid tid att skriva tillräckligt bra kod.

Däremot eftersöker jag "threading modifiers". Det är inte alltid "thread first", "thread last" eller "thread as" går bra ihop. Skulle vilja ha ett sätt att mitt i ett trådat uttryck byta trådningsposition. Något som kanske finns i ditt libb? 🙂

(->> (map f xs) (filer pred) (first) <switch-to-thread-first> ...)

Typ så

Ja, ->as, och ->>as ger möjlighet

Najs.

Se där... Där åkte du på kodgranskning 🙂

Läser igenom exemplen i repot, fattar inte riktigt skillnaden på ->asoch ->>as . Kan du ge ett exempel där ->>as löser det ->as inte gör?

Skillnaden mellan ->as och ->>as är bara hur det läser argumenten. I ->as kommer värdet som ska få ett namn först, och i ->>as kommer värdet som ska få ett namn sist, piggybackat på på & form. ->>as passar i en ->>. Vi använder ->as och ->>as till att få ett namn på det trådade värdet. Med ett namn blir det enklare att byta riktning och mycket annat. Jag kan däremot tänka mig att man mycket väl skulle göra ett ->->> macro som skulle vara precis vad du var ute efter.. Men second rule of Macros...

(->> {:a 1 :b 2}
        (->>as {:keys [a] :as all}
               (is (= 1 a))
               all))

(-> {:a 1 :b 2}
        (->as {:keys [a] :as all}
              (is (= 1 a))
              all))

Kanske lite elakt exempel, då exmplet visar med destructuring i namngivningen. all är här hela mappen

@U04JJEM2X1V Kanske:

(-> [1 2 3]
  (conj 4)
  (->as all
    (->> all 
      (map inc)
      (filter even?)))
  (conj 1))

Ja exemplen är inte självklara. Nu ser jag hur det ska användas, tack. Ja precis, det är ett ->->> och ->>-> som jag eftersöker. Om det går så hade det vart najs om man kan skippa nesting också, tänker att det skulle så ut så här

(-> [1 2 3]
    (conj 4)
    (->->>)
    (map inc)
    (filter even?)
    (conj 1)

Pillade ihop ett uttryck med ->>-> också

(->> (map vector (map #(Math/round (Math/sin %)) (range 5)) (range 5))
     (filter (comp neg? first))
     (first)
     (->>->)
     (get 1)

Hmm..

(macroexpand '(-> 1
                inc
                ->-->
                (dec 3)))

(dec (->--> (inc 1)) 3)

(defmacro ->->> [value & form]
  `(let [value# ~value]
     (->> value#
          ~@form)))

(defmacro ->>-> [& form]
  (let [real-form (butlast form)
        value (last form)]
    `(let [value# ~value]
       (-> value#
           ~@real-form))))

(-> [1 2 3]
   (conj 4)
   (->->> (map inc)
          (filter even?)
          (->>-> vec
                 (conj 5)))
   (conj 6))

Nej du har rätt, man behöver definiera om -> och ->> för att få det att funka.

as-> är väldigt likt ->as i arrowish, och bra hjälp till konversationen med @U04JJEM2X1V. Saknar vi en as->> som namnger sista parametern?. Är cond->, cond->> och as-> tillräckligt för att skriva skön kod med inbäddade conditionals i threading uttryck?

Förstår inte varför man skulle behöva as->> :melting_face:

@U0545PBND as-> [expr name & forms] namnger den första parametern, expr, så att den är tillgänglig i forms. Den passar således bra att bryta ut det trådade värdet ur ett -> uttryck, som t.ex.:

(-> [10 11]
    (conj 12)
    (as-> xs (map inc xs))
    (vec))

(->> [10 11]    
     (#(if (< 1 (count %))
         (conj % (inc (last %)))
         %))
     (map inc)) 

Så att det blir

(->> [10 11]
  (as->> x (if (< 1 (count x))
              (conj x (inc (last x)))
              x))
  (map inc))

Varför bara inte göra?

(as-> [10 11] $
    (conj $ 12)
    (map inc $)
    (vec $))

Det kanske är det bästa sättet, att alltid utgå från as-> i grunduttrycket

Misstänker att man gärna gärna använder -> för att få till pointfree, eller tacit stil. Med as-> måste vi nämna punkten, $, hela tiden. Jämför att använda currying i ML språken. Men jag ska nog tänka på att börja använda as-> i grunduttrycket när jag ser dessa komplexa -> uttryck. Tack