Clojurians Log v2

Kunne man brukt comp istedenfor juxt her? 🤔

Er på mobilen ellers hadde jeg testa.

Nei, comp hadde kjørt remove først og så filter på resultatet

uten riktig arity på noen av de

Men hva med å bruke group-by?

Du kan compe med boolean om du vil ha det i true/false.

(group-by (comp boolean :some/key) da-stuff)

{xs-med-k true xs-uten-k false} om du trenger destructuring.

Du kan bruke group-by, men da må du destrukturere eller get'e. Jeg ønsker meg bare to lister. Nuh!

Du bruker jo destructuring av en liste her også.

Ja, men enklere 😂

🤷

Synes group-by sier mer om hva den gjør. Tror filter+remove kanskje var et litt uheldig navn.

Du kan jo kalle den split-by eller noe sånt.

mapping-destructuren din er også ny for meg

group-by er også raskere.

Løper gjennom lista en gang istedenfor to.

Det er masse map-destructuring-greier i Clojure. For eksempel om du får noe drit fra et API, kan du gjøre {kult-navn :super_SuckyTulleSøppel-Navn}

Det er kult!

En annen effekt av group-by er at listene du får ut er vectorer 🤩 (eller antagelig samme collection type du putter inn?)

group-by gir bare vektorer tilbake ja, og den er følgelig eager. Syntes (juxt filter remove) er finfint jeg forsåvidt. Er ikke veldig dyrt å gå gjennom en liste to ganger, med mindre de er veldig lange. Hmm, når jeg tenker meg om, er det egentlig mulig å lage en versjon som er lazy og går gjennom lista en gang? Utenom kanskje en cursed iterator-hack da.

Ble nysgjerrig på destructuring, veldig mye nyttig her: https://clojure.org/guides/destructuring

Lærte flere nye ting

Det kuleste jeg ikke visste om på lenge var at sånn som man har :keys for nøkkelord (keys står for keywords, ikke for map-keys!), har man :syms for symboler og :strs for strings.

Det jeg likte med filter+remove var at den formidler "filter først, remove så", så du får det ut posisjonelt, som er litt mer kompakt. Kunne laget en lazy implementasjon av den, men til små collections har det nok lite å si

her er en som itererer over sekvensen én gang:

(defn filter+remove [f xs]
  (loop [fs []
         rs []
         remaining xs]
    (if (seq remaining)
      (let [x (first remaining)
            f? (f x)]
        (recur (cond-> fs f? (conj x))
               (cond-> rs (not f?) (conj x))
               (next remaining)))
      [fs rs])))

(filter+remove odd? (range 10))
;; => [[1 3 5 7 9] [0 2 4 6 8]]

Den er ikke lazy (som jeg var ute etter i alle fall)

Ah, skjønner. Lazy-sekvens føltes unaturlig når man har to returverdier.

Jepp

Det kuleste jeg ikke visste om på lenge

(let [{{gaten :street} :adresse
       {:person/keys [name age]}} nøsta-map]

Nøsta-map:

{:person/name "Jon"
 :person/age 34
 :adresse {:street "veien 45"}}

Hvis jeg finner sånne destruktureringer i koden vår så blir det rett i gapestokken 😂

Helt fuckings uleselig

Nå kom det tørt fra @mathias.iversen487 at eksempelet hans heller ikke virker. Noe ingen påpekte siden ingen klarer å lese det. Grei bekreftelse av min påstand 😄

Tar den

Dette skal fungere:

(let [{{gaten :street} :adresse
       :person/keys [name age]} nøsta-map]

Nå er det bare å committe og hoppe rett i gapestokken folkens

Eksempelet ditt kompilerer ikke engang @hypirion 😂

Jeg bare lukket ikke let-en 🤨 Her er noe som kompilerer:

(let [{{gaten :street} :adresse
       :person/keys [name age]} {:person/name "Jon"
                                 :person/age 34
                                 :adresse {:street "veien 45"}}]
  [gaten name age])

Jeg klarte ikke å dy meg 😄