her er forøvrig koden vi endte opp med: https://github.com/augustl/2023-10-kotlinmeetup/blob/28f9aeeafe60ef1214daab03ac69df7c89e74c08/src/main/kotlin/kotlinmeetup/Main.kt

(defn map-of-seqs->seq-of-maps [x]
  (for [values (apply map list (vals x))]
    (zipmap (keys x) values)))

@U0ESP0TS8 føler at du traff bedre enn meg, koden min var mindre konsis 🙂

@U3X7174KS erstattet anonym funksjon med list

Den er konsis, på bekostning av O(2n)

er det noe risiko for at keys returnerer keys i forskjellig rekkefølge når man kaller den flere ganger på samme map i Clojure? Magefølelsen min er “nei”, men jeg er litt usikker

Godt poeng. Jeg er ganske sikker på at den returnerer samme rekkefølge som vals 😅

fra doc'n til keys: > Returns a sequence of the map's keys, in the same order as (seq map). fra doc'n til vals: > Returns a sequence of the map's values, in the same order as (seq map).

Jeg har heller aldri observert noe annet i praksis, så har egentlig ikke noen grunn til å tvile. Man kan vel unngå det ved å kalle seq på hele greia først, så splitte i keys og values, men da blir mye av elegansen over borte.

Der har vi svar!

seq garanterer vel egentlig ikke at den returnerer map entries i samme rekkefølge, men ja

(let [{:keys [x y]} {:x [1 2 3] :y [10 20 30]}]
  (->> (interleave x y)
       (partition 2)
       (map (fn [[x' y']] {:x x' :y y'}))))

føler det map-kallet kan byttes ut med en av de fancy funksjonene i stdlib jeg ikke kan. Kanskje juxt elns

Den var kompakt! Koden blir mer eksplisitt når du snakker om x-er og y-er. Men da støtter den heller ikke z-er, skulle de dukke opp.

(defn map-of-seqs->seq-of-maps [map-of-seqs]
  (into []
    (mapcat
      (fn [[k vs]]
        (for [v vs]
          {k v})))
    map-of-seqs))

aha, den skal være helt generisk ja

@U06BEJGKD har du testet funksjonen din? 😅

en tilsvarende løsning som min forrige, som støtter N keys

(let [x {:x [1 2 3] :y [10 20 30] :z ['a 'b 'c]}]
  (->> (apply interleave (vals x))
       (partition (count x))
       (map (fn [xs] (zipmap (keys x) xs)))))

Heh, nei. Tok den på øyemål, men ser at den har helt feil resultat!

MORE THREADING

(let [x {:x [1 2 3] :y [10 20 30] :z ['a 'b 'c]}]
  (->> (vals x)
       (apply interleave)
       (partition (count x))
       (map (fn [xs] (zipmap (keys x) xs)))))

Her er min egen! Fikk det først ikke til. Så trodde jeg jeg hadde fått det til, men jeg ga feil resultat. Da skrev jeg en test! Liker både løsningen til @U0ESP0TS8 og løsningen til @U0MKRS1FX bedre enn min. Fant ikke noe godt navn på “applesauce”.

(defn map-of-seqs->seq-of-maps [map-of-seqs]
  (let [ks (keys map-of-seqs)
        applesauce (apply map vector (map #(get map-of-seqs %) ks))]
    (map (fn [tuple] (zipmap ks tuple))
         applesauce)))

En litt annen tilnærming:

(defn map-of-seqs->seq-of-maps [m]
  (when (some seq (vals m))
    (cons (update-vals m first)
          (map-of-seqs->seq-of-maps (update-vals m next)))))

@U024X3V2YN4 lurt! Jeg klarer å lese koden din lettere enn min egen 😅

@U3X7174KS her er din løsning med threading macro, så slipper man å gi navn på ting 😄

(let [map-of-seqs {:x [1 2 3] :y [10 20 30] :z ['a 'b 'c]}]
  (let [ks (keys map-of-seqs)]
    (->> ks
         (map #(get map-of-seqs %))
         (apply map vector)
         (map #(zipmap ks %)))))

Der hjelper å unngå nøsting!

@U3X7174KS Den anonyme funksjonen er faktisk unøvdvending siden hash-maps er sjøl funksjoner, så det kan skrives

(let [map-of-seqs {:x [1 2 3] :y [10 20 30] :z ['a 'b 'c]}]
  (let [ks (keys map-of-seqs)]
    (->> ks
         (map map-of-seqs)
         (apply map vector)
         (map #(zipmap ks %))))) 

(let [map-of-seqs {:x [1 2 3] :y [10 20 30] :z ['a 'b 'c]}]
  (let [ks (keys map-of-seqs)]
    (->> (vals map-of-seqs)
         (apply map vector)
         (map #(zipmap ks %)))))

kanskje det er forsvarlig å bruke partial her også?

(let [map-of-seqs {:x [1 2 3] :y [10 20 30] :z ['a 'b 'c]}]
  (let [ks (keys map-of-seqs)]
    (->> (vals map-of-seqs)
         (apply map vector)
         (map (partial zipmap ks)))))

Jeg tror jeg foretrekker å ha innholdet i et separat content namespace. Da ser det litt røddigere ut i handlers namespacet:

(ns handlers
  (:require [content :as c]
            [hiccup2.core :as h]))

(def http-headers-default {"Content-Type" "text/html; charset=UTF-8"})

(defn build-page
  ([page-body]
   (build-page page-body c/default-head))
  ([page-body page-head]
   [:html
    [:head (seq page-head)]
    [:body (seq page-body)]]))

(defn hiccup-html->str [hiccup]
  (-> hiccup (h/html) (str)))

(defn home []
  {:status 200
   :headers http-headers-default
   :body (-> c/home-body
             build-page
             hiccup-html->str)})

(defn greet [request]
  {:status 200
   :headers http-headers-default
   :body (->  (c/build-greet-body (get-in request [:params "name"]))
              build-page
              hiccup-html->str)})

(defn not-found []
  {:status 404
   :headers http-headers-default
   :body (-> c/not-found-body
             build-page
             hiccup-html->str)})

(ns content)

(def default-head
  [[:meta {:charset "utf-8"}]
   [:meta {:name "viewport"
           :content "width=device-width, initial-scale=1"}]
   [:title "My App"]
   [:link {:rel "stylesheet"
           :href ""}]])

(def home-body
  [[:section.section
    [:div.container
     [:h1.title "Front Page"]
     [:p.subtitle "You are now on the front page."]]]])

(defn build-greet-body [name]
  [[:section.section
    [:div.container [:h1.title "Greeting Page"]
     [:p.subtitle "Hello, " name "!"]]]])

(def not-found-body
  [[:section.section
    [:div.container [:h1.title "Page Not Found"]
     [:p.subtitle "This page does not exist."]]]])

Hiccup, som du bruker, har denne fine makroen html som pre-kompilerer hiccup til strenger. Jeg bruker den via min egen makro (for å gi den et kortere navn, og for å ha den tilgjengelig fra et ns med mange andre nyttige funksjoner, ikke vist her):

(ns web
  (:require [hiccup2.core :as hiccup]))

(defmacro h
  [content]
  (list `hiccup/html content))

(ns content
  (:require [web :refer [h]]))

(defn build-greet-body [name]
  (h
    [:section.section
     [:div.container [:h1.title "Greeting Page"]
      [:p.subtitle "Hello, " name "!"]]]))

(macroexpand
  `(h
     [:section.section
      [:div.container [:h1.title "Greeting Page"]
       [:p.subtitle "Hello, " name "!"]]]))
=>
(hiccup.util/raw-string
 (clojure.core/str
  "<section"
  " class=\"section\""
  ">"
  "<div"
  " class=\"container\""
  ">"
  "<h1 class=\"title\">Greeting Page</h1>"
  "<p"
  " class=\"subtitle\""
  ">"
  "Hello, "
  (hiccup.compiler/render-html clojure.core/name)
  "!"
  "</p>"
  "</div>"
  "</section>"))

Du kan selvfølgelig leve et helt fint og ukomplisert liv uten denne typen optimalisering! 🙂

Ellers vil jeg si at det kanskje er mer idiomatisk Hiccup å skrive

(list
  [:div.foo "foo"]
  [:div.bar "bar"])

[[:div.foo "foo"]
 [:div.bar "bar"]]

Andre hiccup-bibliotek har popularisert :<>til dette formålet, men Hiccup (med stor H) støtter ikke dette:

[:<>
 [:div.foo "foo"]
 [:div.bar "bar"]]

Kult, takk for tipsene, @U06BEJGKD! Jeg bruker faktisk hiccup2.core/html i mitt handlers namespace (se koden i min opprinnelige post, i funksjonen jeg har gitt det noe kryptiske navnet hiccup-html->str). Men det er kanskje feil sted å gjøre sånt når jeg tenker meg om. Hmmm. Jeg tenkte ikke på å lage en makro! Har ikke vært innom det temaet enda. Kult eksempel du har! Interessant at du nevner det med list vs. vector literals. Jeg brukte lists i starten. Kanskje jeg går tilbake til det, da! 😁

Du må bruke hiccup2.core/html i alle HTML-produserende funksjoner for at den skal prekompilere (den “trår ikke over” funksjonskallgrenser). Og du må bruke den i den “ytterste” funksjonen, etterfulgt av str, slik du gjør, for at den skal produsere en streng. Men dette er som sagt en optimalisering, og ikke akkurat nødvendig.

Ja, jeg prøvde å flytte funksjonen hiccup-html->str inn i mitt content namespace tidligere, og da ble det bare lok.

Ja, den må være helt ytterst. “Innenfor” der kan velge å bare jobbe med hiccup, altså vektorer (eventuelt i lister, som ovenfor). Og så kan du optimalisere med prekompilering, ved hjelp av den samme hiccup2.core/html hvis du trenger det.

Spesielt fornøyd med at man kan implementere ting som input-fokus og at alt er valgt on-fokus uten nesten noe javascript (annet enn hele HTMX da 😬 )

Liker også at man kan legge til elementer som skal insertes andre steder (det er slik jeg nullstiller skjemaet for å legge til oppgave), eller at man alternativt kan dispatche events for å trigge kall andre steder. Kanskje interessant for deg også, @leif.eric.fredheim? Out of band swap: https://htmx.org/docs/#oob_swaps https://github.com/Oddsor/clojure-web-backend-template/blob/bfe9d89145a0b782247c9aefba0059cc5058a420/examples/todo-app/src/todo_app/core.clj#L114 Events: https://htmx.org/docs/#the-hx-on-attribute https://github.com/Oddsor/clojure-web-backend-template/blob/bfe9d89145a0b782247c9aefba0059cc5058a420/examples/todo-app/src/todo_app/core.clj#L85

Hei @UDB2Q0W13, hilsen fra Island. Fikk todo appen til a kjöre. Hvis jeg önsker a bruke den template og utvikle i IntelliJ, hvordan faar jeg det til?

Hei! Jeg kan dessverre ikke hjelpe med IntelliJ siden jeg ikke har brukt det på en stund, men hvis det er noe likt flyten i Calva så har jeg lagt ved en video som viser hvordan jeg starter opp appen for utvikling iallefall! Man må være nødt til å kunne starte opp med et alias (`:dev`) slik at dev-mappen med user-namespace blir mounted, så kan man starte appen for lokal utvikling ved å evaluere “reset”-kommandoen.

vil tippe man kan “jack-in” i Cursive med et valgt alias 😊

Takk for det. Jeg pröver Calva.

Apropos tester mot hiccup så skrev jeg denne for mange herrans år siden: https://github.com/cjohansen/hiccup-find

Heftig! Tusen takk for rådet og info om testing, @U9MKYDN4Q

den hiccup-sjekken mot body er egentlig god nok til at du kan kutte sjekken på content-type, og heller legge på headeren også i middlewaren om du så skulle ønske

Wow, jeg digger den rekursive funksjonen hiccup? Så kompakt og elegant.

😊

Jeg kopierte koden din rått og det fungerte på første forsøk uten issues. Smooth. Nå må jeg bare lese nøye for å forstå alt som skjer der, hehe.

Bare å spørre 🙂

Det var ikke vanskelig å forstå! Jeg slet litt med disse forms bare: (filter (comp #{"content-type"} s/lower-case)) comp er grei, men #{"content-type"} synes jeg var litt rar. Jeg forstår hva som skjer, men ikke helt hvordan det funker. (re-find #"text/html") #"text/html" var litt rar syntax, før jeg kom på at det er sånn regex literals ser ut. Jeg leste først re-find med "re" som i "repeat," altså "find it again," og ikke "re" som i "regex," som det antagelig betyr 😅 (update :body #(str (h/html %))) update hadde jeg ikke sett før, men det var greit å forstå etter å ha lest litt om funksjonen.

Denne var lur. Jeg stjeler den jeg óg 😁

Angående update: https://www.kodemaker.no/blogg/2019-07-gammelt-triks-ny-kontekst/

(filter (comp #{"content-type"} s/lower-case)) Comp kaller funksjonene fra høyre til venstre. Først gjør om til lowercase, deretter test verdien for medlemsskap i settet #{"content-type"} - med andre ord, sjekk om strengen er lik den

å skrive færre egne funksjoner som lener seg mer på innebygde funksjoner kan jeg lære én og annen ting om også. > Med andre ord: Når byggeklossene er gode nok, kan man øke lesbarheten ved å unngå navngitte funksjoner. 💯

> […] test verdien for medlemsskap i settet #{"content-type"} Aha! Da falt det på plass. Det var den biten jeg ikke forstod.

Et set i Clojure er en funksjon - de implementerer IFn og kan brukes som en funksjon som tar ett argumentet. Denne funksjonen slår opp argumentet i “seg selv” (altså settet), og returnerer denne verdien, eller nil hvis verdien ikke fins i settet. Dette er et mye brukt idiom for å teste om en verdi er lik én eller flere andre verdier. Uten denne teknikken ville det blitt: (filter (comp #(= "content-type" %) s/lower-case))

Ahaaa, kult! Litt som måten et keyword kan brukes som en funksjon til å slå opp seg selv i et map.

Nettop, og keywords kan også brukes på mengder: (:foo #{:foo :bar}) => :foo, her er et eksempel som illustrerer både comp og keywords brukt på hash-maps og mengder

(let [foo {:name "foo"
           :skills #{:typing :singing :sprinting}}
      bar {:name "bar"
           :skills #{:sprinting :knitting}}
      baz {:name "baz"
           :skills #{:singing :whittling}}]
  ;; find those who can sprint
  (filter (comp :sprinting :skills) [foo bar baz]))