conjure-js 0.0.1

package/src/playground/samples/02-higher-order-functions.clj

@@ -0,0 +1,215 @@
+(ns user.hof
+  (:require [clojure.string :as str]))
+
+;; Deep Dive: Higher-Order Functions & Transducers
+;;
+;; Press ⌘+Enter on any form to evaluate it.
+
+
+;; map
+
+(comment
+  ;; Basic: apply f to every element
+  (map inc [1 2 3 4 5])                  ;; => (2 3 4 5 6)
+  (map str [:a :b :c])                   ;; => ("a" "b" "c")
+  (map count ["hi" "hello" "hey"])        ;; => (2 5 3)
+
+  (map (fn [x] (* x x)) (range 1 6))    ;; => (1 4 9 16 25)
+  (map #(* % %) (range 1 6))            ;; same, shorter syntax
+
+  ;; Multi-collection: zips and stops at the shortest
+  (map + [1 2 3] [10 20 30])            ;; => (11 22 33)
+  (map vector [:a :b :c] [1 2 3])       ;; => ([:a 1] [:b 2] [:c 3])
+  (map + [1 2 3] [10 20 30] [100 200 300]) ;; => (111 222 333)
+
+  ;; map-indexed: f receives [index value]
+  (map-indexed vector [:a :b :c])        ;; => ([0 :a] [1 :b] [2 :c])
+  (map-indexed (fn [i v] (str i ": " v))
+               ["alice" "bob" "carol"])  ;; => ("0: alice" "1: bob" "2: carol")
+)
+
+
+;; filter / remove
+
+(comment
+  (filter even?  [1 2 3 4 5 6])         ;; => (2 4 6)
+  (filter string? [1 "a" :b "c" 2])     ;; => ("a" "c")
+  (filter :active [{:name "a" :active true}
+                   {:name "b" :active false}
+                   {:name "c" :active true}])
+  ;; => ({:name "a" :active true} {:name "c" :active true})
+
+  (remove even? [1 2 3 4 5 6])          ;; => (1 3 5)
+  (remove nil?  [1 nil 2 nil 3])        ;; => (1 2 3)
+
+  (filter #(> (count %) 3) ["hi" "hello" "hey" "howdy"])
+  ;; => ("hello" "howdy")
+)
+
+
+;; reduce
+;;
+;; The Swiss army knife — it can implement almost everything else.
+
+(comment
+  ;; Two-arity: uses first two elements to start
+  (reduce + [1 2 3 4 5])                 ;; => 15
+  (reduce * [1 2 3 4 5])                 ;; => 120
+  (reduce str ["a" "b" "c"])             ;; => "abc"
+
+  ;; Three-arity: explicit initial accumulator
+  (reduce + 100 [1 2 3])                 ;; => 106
+  (reduce conj [] '(1 2 3))              ;; => [1 2 3]
+  (reduce (fn [m [k v]] (assoc m k v))
+          {}
+          [[:a 1] [:b 2] [:c 3]])        ;; => {:a 1 :b 2 :c 3}
+
+  ;; Building a frequency map from scratch
+  (reduce (fn [acc x]
+            (update acc x (fnil inc 0)))
+          {}
+          [:a :b :a :c :b :a])           ;; => {:a 3 :b 2 :c 1}
+
+  ;; Early termination with `reduced` — wraps a value to signal "stop now"
+  (reduce (fn [acc x]
+            (if (nil? x)
+              (reduced acc)
+              (conj acc x)))
+          []
+          [1 2 3 nil 4 5])               ;; => [1 2 3]  (stopped at nil)
+
+  (reduce (fn [_ x]
+            (when (> x 100) (reduced x)))
+          nil
+          (range 1000))                  ;; => 101
+)
+
+
+;; apply, partial, comp
+
+(comment
+  ;; apply — call f with a collection as its argument list
+  (apply + [1 2 3 4])             ;; => 10
+  (apply str ["a" "b" "c"])       ;; => "abc"
+  (apply max [3 1 4 1 5 9 2 6])   ;; => 9
+
+  ;; Leading fixed args before the collection
+  (apply str "prefix-" ["a" "b"]) ;; => "prefix-ab"
+
+  ;; partial — fix some leading arguments
+  (def add10 (partial + 10))
+  (add10 5)                        ;; => 15
+  (map add10 [1 2 3])              ;; => (11 12 13)
+
+  (def greet (partial str "Hello, "))
+  (greet "World!")                  ;; => "Hello, World!"
+
+  ;; comp — compose right-to-left
+  (def clean (comp str/trim str/lower-case))
+  (clean "  HELLO  ")              ;; => "hello"
+
+  ((comp inc inc inc) 0)           ;; => 3
+  ((comp str/upper-case str/trim) "  hello  ") ;; => "HELLO"
+
+  ;; identity — returns its argument unchanged
+  (filter identity [1 nil 2 false 3]) ;; => (1 2 3)
+
+  ;; constantly — returns a function that always returns the same value
+  ((constantly 42) 1 2 3)          ;; => 42
+  (map (constantly :x) [1 2 3])    ;; => (:x :x :x)
+)
+
+
+;; complement, juxt, some, every?
+
+(comment
+  ;; complement — logical NOT of a predicate
+  (def not-even? (complement even?))
+  (filter not-even? [1 2 3 4 5])   ;; => (1 3 5)
+
+  ;; juxt — call multiple functions on the same value, collect results
+  ((juxt :name :role) {:name "Alice" :role :admin}) ;; => ["Alice" :admin]
+  (map (juxt identity #(* % %)) [1 2 3 4 5])
+  ;; => ([1 1] [2 4] [3 9] [4 16] [5 25])
+
+  ;; some — return first truthy result of (f x), or nil
+  (some even? [1 3 5 6 7])         ;; => true
+  (some even? [1 3 5 7])           ;; => nil
+  (some #(when (> % 3) %) [1 2 3 4 5]) ;; => 4
+
+  ;; every? — true if (f x) is truthy for all elements
+  (every? even? [2 4 6])           ;; => true
+  (every? even? [2 4 5])           ;; => false
+
+  (not-any?   odd? [2 4 6])        ;; => true
+  (not-every? odd? [1 2 3])        ;; => true
+)
+
+
+;; sort, sort-by, group-by, frequencies
+
+(def people
+  [{:name "Carol" :age 32 :dept :eng}
+   {:name "Alice" :age 28 :dept :design}
+   {:name "Bob"   :age 35 :dept :eng}
+   {:name "Dave"  :age 28 :dept :design}])
+
+(comment
+  (sort [3 1 4 1 5 9 2 6])           ;; => (1 1 2 3 4 5 6 9)
+  (sort > [3 1 4 1 5 9 2 6])         ;; => (9 6 5 4 3 2 1 1)
+  (sort ["banana" "apple" "cherry"])  ;; => ("apple" "banana" "cherry")
+
+  (sort-by :age  people)             ;; youngest first
+  (sort-by :name people)             ;; alphabetical
+
+  (group-by :dept  people)           ;; => {:eng [...] :design [...]}
+  (group-by :age   people)           ;; groups by age
+
+  (frequencies [:a :b :a :c :b :a]) ;; => {:a 3 :b 2 :c 1}
+  (distinct [1 2 3 1 2 4])           ;; => (1 2 3 4)
+)
+
+
+;; Transducers
+;;
+;; Composable transformation pipelines decoupled from the source and sink.
+;; A 1-arg call to map/filter/etc returns a transducer instead of a result.
+;; Transducer `comp` applies LEFT-to-RIGHT (unlike function comp).
+
+(comment
+  ;; `into` with a transducer
+  (into [] (map inc) [1 2 3 4 5])             ;; => [2 3 4 5 6]
+  (into [] (filter even?) [1 2 3 4 5 6])      ;; => [2 4 6]
+
+  ;; Chain with comp — one pass, no intermediate sequences
+  (into []
+        (comp (filter odd?)
+              (map #(* % %)))
+        [1 2 3 4 5 6 7])
+  ;; => [1 9 25 49]  (squares of odd numbers)
+
+  ;; `transduce` — apply a transducer with reduce semantics
+  (transduce (comp (filter odd?)
+                   (map #(* % %)))
+             +
+             [1 2 3 4 5 6 7])
+  ;; => 84  (sum of squares of odds)
+
+  ;; `sequence` — lazy sequence from a transducer
+  (sequence (comp (filter even?)
+                  (map #(/ % 2)))
+            (range 1 11))
+  ;; => (1 2 3 4 5)
+
+  ;; partition-all — group into chunks
+  (into [] (partition-all 3) (range 10))
+  ;; => [[0 1 2] [3 4 5] [6 7 8] [9]]
+
+  ;; dedupe — remove consecutive duplicates
+  (into [] (dedupe) [1 1 2 3 3 3 4 1])
+  ;; => [1 2 3 4 1]
+
+  ;; take as a transducer — stops early, never touches the rest
+  (into [] (take 3) (range 1000))
+  ;; => [0 1 2]
+)

package/src/playground/samples/03-destructuring.clj

@@ -0,0 +1,194 @@
+(ns user.destructuring)
+
+;; Deep Dive: Destructuring
+;;
+;; Bind names to parts of a data structure in one step.
+;; Works in `let`, `fn` params, `defn` params, `loop`, and `defmacro`.
+;;
+;; Press ⌘+Enter on any form to evaluate it.
+
+
+;; Vector (Sequential) Destructuring
+;;
+;; Bind names to positions, left to right.
+
+(comment
+  (let [[a b c] [10 20 30]]
+    (+ a b c))           ;; => 60
+
+  ;; Skip positions with _
+  (let [[_ second _ fourth] [1 2 3 4]]
+    [second fourth])     ;; => [2 4]
+
+  ;; Fewer bindings than elements — extras are ignored
+  (let [[a b] [1 2 3 4 5]]
+    [a b])               ;; => [1 2]
+
+  ;; & rest — bind remaining elements as a sequence
+  (let [[first-item & the-rest] [1 2 3 4 5]]
+    {:first first-item
+     :rest  the-rest})   ;; => {:first 1 :rest (2 3 4 5)}
+
+  ;; :as — bind the whole collection in addition to parts
+  (let [[x y :as all] [1 2 3]]
+    {:x x :y y :all all}) ;; => {:x 1 :y 2 :all [1 2 3]}
+
+  ;; Nested vectors
+  (let [[a [b c] d] [1 [2 3] 4]]
+    [a b c d])           ;; => [1 2 3 4]
+)
+
+
+;; Map Destructuring
+;;
+;; Bind names to values by key.
+
+(comment
+  ;; Basic: bind local name to the value at a key
+  (let [{n :name a :age} {:name "Alice" :age 30 :role :admin}]
+    (str n " is " a))    ;; => "Alice is 30"
+
+  ;; :keys — shorthand when local name == keyword name
+  (let [{:keys [name age role]} {:name "Alice" :age 30 :role :admin}]
+    [name age role])     ;; => ["Alice" 30 :admin]
+
+  ;; :strs — like :keys but for string keys
+  (let [{:strs [name age]} {"name" "Bob" "age" 25}]
+    [name age])          ;; => ["Bob" 25]
+
+  ;; :as — bind the whole map too
+  (let [{:keys [name] :as person} {:name "Carol" :age 32}]
+    {:greeting (str "Hello " name)
+     :full     person})
+
+  ;; :or — default values when key is absent (NOT when value is nil)
+  (let [{:keys [name role] :or {role :guest}} {:name "Dave"}]
+    [name role])         ;; => ["Dave" :guest]  (:role was absent)
+
+  ;; :or does NOT apply when the key IS present but value is nil
+  (let [{:keys [role] :or {role :guest}} {:role nil}]
+    role)                ;; => nil  (key exists, :or doesn't fire)
+)
+
+
+;; Destructuring in Function Params
+
+;; Vector destructuring in fn params
+(defn sum-pair [[a b]]
+  (+ a b))
+
+;; Map destructuring in fn params
+(defn greet-user [{:keys [name role] :or {role :guest}}]
+  (str "Hello " name " (" (clojure.core/name role) ")"))
+
+;; Multi-arg with map destructuring
+(defn move [{:keys [x y]} {:keys [dx dy]}]
+  {:x (+ x dx) :y (+ y dy)})
+
+(comment
+  (sum-pair [3 7])                         ;; => 10
+  (greet-user {:name "Alice" :role :admin}) ;; => "Hello Alice (admin)"
+  (greet-user {:name "Bob"})               ;; => "Hello Bob (guest)"
+  (move {:x 0 :y 0} {:dx 3 :dy 5})        ;; => {:x 3 :y 5}
+)
+
+
+;; Nested Destructuring
+
+(comment
+  ;; Map inside vector
+  (let [[{:keys [name]} {:keys [score]}]
+        [{:name "Alice"} {:score 95}]]
+    (str name ": " score))    ;; => "Alice: 95"
+
+  ;; Vector inside map
+  (let [{:keys [name]
+         [first-score] :scores}
+        {:name "Bob" :scores [87 90 95]}]
+    (str name " first: " first-score)) ;; => "Bob first: 87"
+
+  ;; Deeply nested — a realistic API response shape
+  (def response
+    {:status 200
+     :body {:user {:id 42
+                   :name "Alice"
+                   :tags ["admin" "beta"]}}})
+
+  (let [{:keys [status]
+         {:keys [user]} :body} response
+        {:keys [id name]
+         [first-tag] :tags} user]
+    {:status status :id id :name name :first-tag first-tag})
+  ;; => {:status 200 :id 42 :name "Alice" :first-tag "admin"}
+)
+
+
+;; Destructuring in loop/recur
+
+(comment
+  (loop [[x & xs] [1 2 3 4 5]
+         acc      0]
+    (if x
+      (recur xs (+ acc x))
+      acc))                    ;; => 15
+
+  (loop [{:keys [n acc]} {:n 5 :acc 1}]
+    (if (zero? n)
+      acc
+      (recur {:n (dec n) :acc (* acc n)})))
+  ;; => 120  (5!)
+)
+
+
+;; Kwargs Destructuring (& {:keys})
+;;
+;; `& rest` where rest is treated as a flat key/value sequence.
+
+(defn configure [& {:keys [host port timeout]
+                    :or   {host "localhost"
+                           port 8080
+                           timeout 5000}}]
+  {:host host :port port :timeout timeout})
+
+(comment
+  (configure)                               ;; all defaults
+  (configure :port 3000)
+  (configure :host "prod.example.com" :port 443 :timeout 30000)
+)
+
+
+;; Qualified :keys
+;;
+;; When map keys are namespaced keywords, the local name is the unqualified part.
+
+(comment
+  (let [{:keys [user/name user/role]}
+        {:user/name "Alice" :user/role :admin}]
+    [name role])                            ;; => ["Alice" :admin]
+)
+
+
+;; Practical Patterns
+
+(defn summarize [{:keys [name scores]}]
+  {:name    name
+   :average (/ (reduce + scores) (count scores))
+   :best    (apply max scores)})
+
+(def students
+  [{:name "Alice" :scores [88 92 95]}
+   {:name "Bob"   :scores [75 80 78]}
+   {:name "Carol" :scores [95 98 100]}])
+
+(comment
+  (map summarize students)
+
+  (->> students
+       (map summarize)
+       (sort-by :average >)
+       (map :name))               ;; => ("Carol" "Alice" "Bob")
+
+  (let [{:keys [scores]} (first students)
+        [best & _] (sort > scores)]
+    best)                         ;; => 95
+)

package/src/playground/samples/04-strings-and-regex.clj

@@ -0,0 +1,202 @@
+(ns user.strings-regex
+  (:require [clojure.string :as str]))
+
+;; Deep Dive: Strings & Regex
+;;
+;; Press ⌘+Enter on any form to evaluate it.
+
+
+;; Building & Inspecting Strings
+
+(comment
+  ;; str — concatenate anything into a string
+  (str "hello" " " "world")         ;; => "hello world"
+  (str :keyword)                     ;; => ":keyword"
+  (str 42)                           ;; => "42"
+  (str nil)                          ;; => ""  (nil becomes empty string)
+  (str true false)                   ;; => "truefalse"
+
+  (subs "hello world" 6)             ;; => "world"
+  (subs "hello world" 0 5)           ;; => "hello"
+
+  (count "hello")                    ;; => 5
+  (count "")                         ;; => 0
+
+  (string? "hello")                  ;; => true
+  (string? :not-a-string)            ;; => false
+)
+
+
+;; clojure.string  (required as str)
+
+(comment
+  ;; Case
+  (str/upper-case "hello")          ;; => "HELLO"
+  (str/lower-case "WORLD")          ;; => "world"
+  (str/capitalize "hello world")    ;; => "Hello world"
+
+  ;; Trimming whitespace
+  (str/trim  "  hello  ")           ;; => "hello"
+  (str/triml "  hello  ")           ;; => "hello  "  (left only)
+  (str/trimr "  hello  ")           ;; => "  hello"  (right only)
+  (str/trim-newline "hello\n")      ;; => "hello"
+
+  ;; Joining
+  (str/join ", " ["one" "two" "three"])  ;; => "one, two, three"
+  (str/join ["a" "b" "c"])               ;; => "abc"
+
+  ;; Splitting
+  (str/split "a,b,c,d" #",")        ;; => ["a" "b" "c" "d"]
+  (str/split "hello world" #"\s+")  ;; => ["hello" "world"]
+  (str/split-lines "one\ntwo\nthree") ;; => ["one" "two" "three"]
+
+  ;; Search predicates
+  (str/includes?    "hello world" "world")  ;; => true
+  (str/starts-with? "hello world" "hello")  ;; => true
+  (str/ends-with?   "hello world" "world")  ;; => true
+  (str/blank?       "   ")                  ;; => true
+  (str/blank?       "  x  ")               ;; => false
+
+  (str/index-of      "hello world" "world")  ;; => 6
+  (str/last-index-of "abcabc" "b")           ;; => 4
+
+  (str/reverse "hello")             ;; => "olleh"
+)
+
+
+;; Replace
+
+(comment
+  ;; Literal match
+  (str/replace "hello world" "world" "Clojure") ;; => "hello Clojure"
+
+  ;; Regex — all matches
+  (str/replace "hello world" #"[aeiou]" "*")    ;; => "h*ll* w*rld"
+
+  ;; Regex + function — receives match vector, returns replacement string
+  (str/replace "hello world"
+               #"\b\w"
+               (fn [[match]] (str/upper-case match)))
+  ;; => "Hello World"
+
+  ;; replace-first — only the first occurrence
+  (str/replace-first "aabbaabb" "b" "X")        ;; => "aaXbaabb"
+  (str/replace-first "hello" #"[aeiou]" "*")    ;; => "h*llo"
+
+  ;; escape — apply a substitution map to every character
+  (str/escape "hello & <world>" {\& "&amp;" \< "&lt;" \> "&gt;"})
+  ;; => "hello &amp; &lt;world&gt;"
+)
+
+
+;; Strings as Sequences
+;;
+;; Strings are seqable — all sequence functions work on them.
+
+(comment
+  (seq "hello")                      ;; => ("h" "e" "l" "l" "o")
+
+  (first "hello")                    ;; => "h"
+  (rest  "hello")                    ;; => ("e" "l" "l" "o")
+  (last  "hello")                    ;; => "o"
+
+  (count "hello")                    ;; => 5
+
+  (map str/upper-case (seq "hello")) ;; => ("H" "E" "L" "L" "O")
+
+  ;; Set literals not supported yet — use an explicit membership check:
+  (filter (fn [c] (some #(= c %) ["a" "e" "i" "o" "u"])) (seq "hello world"))
+  ;; => ("e" "o" "o")  (vowels only)
+
+  ;; Rebuild a string after seq manipulation
+  (apply str (filter (fn [c] (some #(= c %) ["a" "e" "i" "o" "u"])) (seq "hello world")))
+  ;; => "eoo"
+
+  (count "café")                     ;; => 4  (not byte count)
+  (seq "café")                       ;; => ("c" "a" "f" "é")
+)
+
+
+;; Regex Literals
+;;
+;; Patterns follow JavaScript regex rules.
+
+(comment
+  #"[0-9]+"                          ;; => #"[0-9]+"
+
+  ;; re-find — first match (string if no groups, vector if groups)
+  (re-find #"\d+" "abc123def456")    ;; => "123"
+  (re-find #"(\w+)@(\w+)" "me@example.com")
+  ;; => ["me@example.com" "me" "example"]  (full match + groups)
+
+  ;; re-matches — match against the ENTIRE string
+  (re-matches #"\d+" "123")          ;; => "123"
+  (re-matches #"\d+" "123abc")       ;; => nil  (not entire string)
+  (re-matches #"(\d{4})-(\d{2})-(\d{2})" "2024-03-15")
+  ;; => ["2024-03-15" "2024" "03" "15"]
+
+  ;; re-seq — all matches as a lazy sequence
+  (re-seq #"\d+" "abc123def456ghi789")   ;; => ("123" "456" "789")
+  (re-seq #"\b\w{4}\b" "the quick brown fox")
+  ;; => ("quick" "brown")  (4-letter words)
+
+  ;; re-pattern — create a regex from a string (useful when dynamic)
+  (re-find (re-pattern "hello") "say hello!")  ;; => "hello"
+)
+
+
+;; Inline Regex Flags
+;;
+;;   (?i)  case-insensitive
+;;   (?m)  multiline  (^ and $ match line boundaries)
+;;   (?s)  dotAll     (. matches newlines too)
+
+(comment
+  (re-find #"(?i)hello" "say HELLO!")     ;; => "HELLO"
+  (re-matches #"(?i)[a-z]+" "HeLLo")     ;; => "HeLLo"
+
+  (re-seq #"(?m)^\w+" "one\ntwo\nthree") ;; => ("one" "two" "three")
+
+  (re-seq #"(?im)^hello" "Hello\nHELLO\nhello")
+  ;; => ("Hello" "HELLO" "hello")
+)
+
+
+;; Practical Patterns
+
+(comment
+  ;; Parse a CSV row
+  (defn parse-csv [line]
+    (str/split line #","))
+
+  (parse-csv "alice,30,admin")           ;; => ["alice" "30" "admin"]
+
+  ;; Extract structured data with groups
+  (defn parse-date [s]
+    (let [[_ y m d] (re-matches #"(\d{4})-(\d{2})-(\d{2})" s)]
+      {:year y :month m :day d}))
+
+  (parse-date "2024-03-15")
+  ;; => {:year "2024" :month "03" :day "15"}
+
+  ;; Slugify — URL-safe string
+  (defn slugify [s]
+    (-> s
+        str/trim
+        str/lower-case
+        (str/replace #"[^a-z0-9\s-]" "")
+        (str/replace #"\s+" "-")))
+
+  (slugify "  Hello, World! It's Clojure  ")
+  ;; => "hello-world-its-clojure"
+
+  ;; Template substitution — replace {{key}} placeholders
+  (defn render [template data]
+    (str/replace template
+                 #"\{\{(\w+)\}\}"
+                 (fn [[_ key]] (get data key ""))))
+
+  (render "Hello, {{name}}! You have {{count}} messages."
+          {"name" "Alice" "count" "3"})
+  ;; => "Hello, Alice! You have 3 messages."
+)