jaaa, brukeren returnerer en liste av lister, så "flates" den ned til én liste?

stemmer 👍

særlig kjekt når man driver og komponerer f.eks funksjoner som returnerer ting som skal sendes inn til datomic/datascript transactions 😄

er egentlig generelt mange settinger hvor det er digg å kunne ha en samling funksjoner som returnerer lister, så du kan ha funksjoner som returnerer 0, 1 eller mange av noe uten å endre for mye på ting, og så mapcatte det sammen til slutt etterpå

FC/IS 🥳

Sant!

Gjør ikke clojure.core/flatten noe lignende? :thinking_face:

flatten går all the way (rekursiv)

Flatten går all the way ( ͡° ͜ʖ ͡°)

Du vil nesten aldri ha flatten .

Jeg fikk en "dobbel liste" i min funksjon sh->out når den ble kalt fra sh-out->json:

(defn sh->out
  [opts & args]
  (-> (apply process/sh opts (flatten args))
      :out))

(defn sh-out->json
  [opts & args]
  (-> (sh->out opts args)
      (json/parse-string true)))

nei, den er vel så godt som et anti-pattern og kan fort by på overraskelser

nemlig, ofte så vet du hvor mange nivåer du vil “ta bort”, og kan bruke f.eks mapcat i stedet for

dobbel liste her kommer vel forøvrig fra & args “to ganger. Ved første kall er args en liste, så sender du den inn til en annen som er & args og da får en liste med det første argumentet, som er en liste 😄

#newbieproblems

((fn [& args] (prn args)) 1 2 3) => (1 2 3)

((fn [& args1] ((fn [& args2] args2) args1)) 1 2 3) => ((1 2 3))

Men hvorfor blir lista pakken inn i en annen liste når den allerede var en liste? 😅

& args er ikke “smart”, den får inn et agument som er en liste, og vil ikke automatisk explode den basert på type

kan eventuelt bruke apply - ((fn [& args1] (apply (fn [& args2] args2) args1)) 1 2 3) => (1 2 3)

eller la være å bruke & args da, hvis du faktisk ikke tenker å kalle den variadic

(altså sende inn N argumenter, i stedet for å sende inn en liste som ett argument)

sh-out->json brukes slik, så tror den må være variadic:

(defn get-devops-project-repo-data
  [project-id]
  (sh-out->json "az" "repos" "list"
                "--project" project-id))

(defn get-github-repo-data
  []
  (sh-out->json "gh" "repo" "list" (:github/org-name settings)
                "--language" (:github/repo-language-filter settings)
                "--source"
                "--no-archived"
                "--limit" "1000"
                "--json" "sshUrl"))

stemmer 👍

men sh->out trenger kanskje ikke å være det?

det er ihvertfall der det blir “feil” og den kommer dobbelt

sh->out brukes slik nå:

defn clone-repo
  [repo-url]
  (let [path (get-repo-root-path)]
    (if-not (file/exists? path) (file/create-dir path) nil)
    (sh->out {:dir path} "git" "clone" repo-url)))

(defn run-git-command
  ([command]
   (run-git-command (find-repo-paths (get-repo-root-path)) command))

  ([root-path command]
   (->> root-path
        (pmap #(sh->out {:dir %} "git" command))
        (doall))))

ah den brukes også direkte sånn ja

Ja, men det er kanskje dårlig design når jeg tenker meg om…

(defn sh-out->json
  [opts & args]
  (-> (apply sh->out opts args)
      (json/parse-string true)))

Det er noen ganger jeg må ha JSON, og andre ganger ikke.

Lurte på om jeg kanskje kunne brukt multiple arities eller multimethods for å unngå to separate funksjoner.

Eller kanskje partial på et vis.

synes egentlig det virker greit å ha to funksjoner sånn, en for et “rent” kall, og en som kaller den rene og gjør noko attått

Men fikla med det lenge og slo meg til ro med to funksjoner for å komme videre med det jeg prøvde å oppnå 😅

i JS har man syntaks for sånt, man kan explode med … . apply gjør samme nytta i clj 😄

men, ofte synes jeg det er greit å rett og slett bare sende inn ei liste, nettopp pga ting som dette, og at noen ganger kan det være kjekt å kunne bygge opp en liste programmatisk og sende det inn til funksjonen uten å måtte kalle apply på den først osv

altså at man bare kaller den med (sh-out->json "gh" ["repo" "list" x "--source"]) etc. En smakssak 👍

Jeg tror ikke det vil fungere pga. Babashka sin interne "tokenizer" gjør noe fancy shit for å konvertere lista med strenger til shell script stuff. Men jeg skal teste litt!

Fikk litt hjelp i #CLX41ASCS tidligere og selveste borkdude sa jeg bare burde sende inn en liste med strenger til babashka/sh.

bør vel ikke ha noe å si om du sender inn en “args” som en liste sånn, eller varargs med “& args” (om det ga mening)

selve kallet til sh må kanskje kalles med varargs ja, men du kan jo velge å gjøre det annerledes i dine egne funksjoner

Aha, sånn, ja. Tror jeg skjønner hva du mener!

du står fritt til hvordan du vil gjøre det med dine egne wrapper-funksjoner lizm!

Hva er det den gjør?

(with-test-system [sys (test-system)]
  ,,,)

(let [sys (test-system)]
  ,,,)

Den gjør det, pluss at den stenger ned ting på slutten.

Aaah, skjønner 👍

> konteksten var REPL-poking > Jaaa, sant. Da gir det jo mer mening, jeg ønsker å sjekke hva mellomverdiene var.

Tufte var spennende! 💯

man klarer stort sett å komme seg unna loop ja! Utrolig hva som finnes i core fra før

Yeah! Og dette kjører typ 10x raskere enn Bash scriptet jeg hadde, antagelig pga. pmap

synes det gir veldig mening å lage toolinga si i noe annet enn shellscript!

Indeed! Babashka er helt rått. Det har sikkert tatt meg 10x lengre tid å oppnå sluttresultatet jeg prøver å oppnå (😳), men nå lærer jeg litt Clojure samtidig og får noen utils som er enklere å gjenbruke for lignende oppgaver i fremtiden 😁

Pluss at kollegaer går forbi, ser på skjermen min og spør "hva i all verden er det der?!" 😂 Fin anledning til å vise litt!

det som er litt festlig der er at du redder deg inn med en (into []) på slutten

ja, en doall ville vel gjort samme nytta

med mindre du trenger at det er en vector av en eller annen grunn

Så for å ta tak i denne problematikken, fordi den kommer til å bite deg. I gamle dager, var Hibernate kult. Hibernate hadde lazy loading av relasjoner, som også var kult, men som også var tidenes foot gun. Et av problemene var at du måtte ha en åpen connection til databasen når man realiserte lazyness’en. Enter open-session-in-View eller deromkring. Grunnen til at jeg tar det opp er at vi treffer det samme problemet i Clojure med lazy seqs. I koden over bruker du with-open-et-eller-annet. Når du er ferdig med den (leksikalske) bindingen er filen din lukket. Hvis du d prøver å realisere seq’en din, går ting normalt til helvete. En annen artig felle der er hvis du bruker with-redefs og returnerer en lazy seq, så vil redef’en ikke være synlig når den realiseres. Har tapt litt tid på akkurat det.

nesten så core kunne hatt with-open2 og with-redefs2 som sjekket om du returnerte en LazySeq og automatisk realiserte den for deg som en del av “pakka”

samme med with-connection og generelt alskens with-X der ute

(eventuelt bare bruke Datomic hvor database-viewet ditt også er lazy 😎)

Jeg setter pris på innspillene deres! Det er den beste måten å lære på når folk peker ut dumme ting jeg gjør.

..og dumme ting Clojure gjør :S Ble sittende å tenke på hvordan Pinnacle Of Dev Experience next.js 100% hadde hatt en linter eller runtime-sjekk eller bare automatisk realiserte lazy-seqs i with-open osv. Clojure har liksom bestemt seg for å ikke være sånn “lett” å ha med å gjøre, men heller la foot gunsa ligge

Er dette litt bedre? :thinking_face:

(defn find-in-file [file-path pattern]
  (->> (io/file file-path)
       (io/reader)
       (line-seq)
       (map-indexed #(when (str/includes? %2 pattern)
                       {:path file-path
                        :line (inc %1)
                        :column (inc (.indexOf %2 pattern))}))
       (filter identity)))

Kanskje enda litt bedre 🙂

(defn find-in-file [file-path pattern]
  (->> file-path
       (file/read-all-lines)
       (map-indexed #(when (str/includes? %2 pattern)
                       {:directory (str (file/parent file-path))
                        :filename (file/file-name file-path)
                        :pattern pattern
                        :line (inc %1)
                        :column (inc (.indexOf %2 pattern))}))
       (filter identity)))

hva er file/read-all-lines ?

Det er en Babashka-greie, babashka.fs :as file

https://github.com/babashka/fs/blob/master/API.md

en eventuell fordel med io/reader og line-seq er at den såvidt jeg vet er lazy

så om du leser ei svær fil så trenger du ikke laste inn hele fila i RAM først, den kan streames inn mens den prosesseres

hilsen August “Kongen Av Premature Optimization” Lilleaas 😄