Programming-Idioms.org

(println "Hello World")

(dotimes [_ 10]
  (println "Hello"))

(defn main- [& args]
  (println "I got all this arguments " args " and now I'm returning nil. Peace out!"))

(defn square [x]
  (* x x))

[x y]

(vector-of :double x y)

(map do-something items)

(doseq [[i x] (map-indexed vector items)]
  (println i ":" x))

(def x {"One" 1
	"Two" 2
	"Three" 3})

(shuffle x)

(rand-nth x)

(some (partial = x) list)

(some #{x} list)

(doseq [[k x] mymap]
  (println k ":" x))

  (defn rand-between [a b]
    (+ a (* (- b a) (rand))))

(+ a (rand-int (- b a)))

(reverse x)

  (defn find-in-2d-matrix [m x]
    (for [i (range (count m))
          j (range (count (first m)))
          :when (= x (-> m (nth i) (nth j)))]
      [i j]))

(defn swap [a b]
  [b a])

(def i (Integer/parseInt s))

(def i (Integer. s))

(def s "ネコ")

(def c (chan 1))

(go (println "Hello," (<! c)))

(>!! c "Alan")

(for [i (range 1 (inc m))]
  (for [j (range 1 (inc n))]
    (* i j)))

(sort-by :p items)

(defn remove-idx [i items]
    (keep-indexed #(when-not (= i %1) %2) items))

(dorun (pmap f (range 1 1001)))

(defn f [i]
  (loop [cnt i, acc 1N]
    (if (zero? cnt) acc
      (recur (dec cnt) (* cnt acc)))))

(defn exp [x n]
  (let [x-squared (* x x)]
    (cond
      (= n 0) 1
      (= n 1) x
      (= (mod n 2) 0) (exp x-squared (/ n 2))
      :else (* x (exp x-squared (/ (- n 1) 2))))))

(def x (atom 0))
(def f inc)
(swap! x f)

(defn compose [f g]
   (comp g f))

(comp g f)

(def add5 (partial + 5))

(def rev-key #(update %2 %1 reverse))

(def rev-a (partial rev-key :a))

(def t (subs s i j))

(def ok (string/includes? word s))

(let [s "hello"
      t (apply str (reverse s))]
  t)

(def t (str/reverse s))

(loop [rows m]
  (if-let [v (some #(when (neg? %) %) (first rows))]
    v
    (recur (rest rows))))

(Thread/sleep 5000)

(<! (timeout 5000))

(def t (apply str (take 5 s)))

(let [t (clojure.string/join (take-last 5 s))])

(def t 
  (when (string? s)
    (let [from (-> s (count) (- 5) (max 0))]
      (subs s from))))

(def s "Murs, ville,
Et port,
Asile
De mort,
Mer grise
Où brise
La brise,
Tout dort.")

(def chunks (split s #"\s+"))

(loop []
  ;; do something
  (recur))

(contains? m k)

(boolean (some #{v} (vals m)))

(clojure.string/join "," '("abc" "def" "ghi") )

(defn sum [x] (reduce + x))

(sum [1 20 300])
;;=> 321

(let [s (str i)])

(def y (filter p x))

(def lines (slurp f))

(binding [*out* *err*]
  (println (str x " is negative")))

(def d #(java.util.Date.))

(defn binom [n k]
  (let [fact #(apply * (range 1 (inc %)))]
    (/ (fact n)
       (* (fact k) (fact (- n k))))))

(println (clojure.string/join " " *command-line-args*))

(defn gcd [a b]
  (if (zero? b)
    a
    (recur b (mod a b))))

(defn s
  [x]
  (pprint/cl-format nil "~b" x))

(loop []
  (do something)
  (when c
    (recur)))

(def y (float x))

(defn rnd [y] (int (+ y 0.5)))

(count (re-seq t s))

(def r #"htt+p")

(def c (count (re-seq #"1" (Integer/toBinaryString i))))

(System/exit 0)

(def x (read-value (file "data.json")))

(write-value (file "data.json") x)

(type x)

(def b (starts-with? s prefix))

(let [b (str/ends-with? s suffix)]
   ; ...  
 )

(def x (.format (java.text.SimpleDateFormat. "yyyy-MM-dd") d))

(sort c items)

(def s (slurp u))

(blank? s)

(def b (= x y))

(def b (identical? x y))

(def s2 (clojure.string/replace s1 w ""))

(def n (count x))

(def y (set x))

(distinct x)

(def n (Integer/parseInt (read-line)))

(def suit #{:SPADES :HEARTS :DIAMONDS :CLUBS})

(def Suit #{"Spades" "Hearts"  "Diamonds" "Clubs"})

(assert (isConsistent))

(assert (true? (isConsistent)))

(time (foo))

(defn foo
  []
  ["bar" true])

(def foo (load-file "foobody.txt"))

(cond 
    c1 (f1)
    c2 (f2)
    c3 (f3))

(time (f))

(def items (list a b c))

(let [[n m]
      (split-with (partial not= x) items)]
  (concat n (rest m)))

(remove #{x} items)

(def b (every? #(Character/isDigit %) s))

(File/createTempFile "prefix" "suffix")

(File/createTempFile "prefix" "suffix" (new File "/tmp"))

(dissoc m k)

;; for side effects
(doseq [x (concat items1 items2)]
   (println x))

(doseq [i (interleave items1 items2)]
  (println i))

(.exists (io/file fp))

(Float/parseFloat s)

(read-string s)

(parse-double s)

(def t (clojure.string/replace s #"[^\x00-\x7F]" ""))

(defn remove-ending-slash
  [p]
  (if (clojure.string/ends-with? p "/")
    (subs p 0 (dec (count p)))
    s))

(clojure.string/replace p #"/$" "")

(def s (str c))

(def t (str s i))

(def s (format "%03d" i))

(def planet "Earth")

(def y (->> x shuffle (take k)))

(map (partial * c) elements)

(map (fn [e] (* c e)) elements)

(map #(* c %) elements)

(map #(* c %1) elements)

(defn -main [arg & _]
  (case arg
    "b" (bat)
    "f" (fox)
    (nothing)))

(doseq [xs (partition 2 list)]
  (apply println xs))

(def x (last items))

(def x (peek items))

(def ab (concat a b))

(def n (.codePointCount s 0 (count s)))

(defn n[s] (.codePointCount s 0 (count s)))

(def n (count mymap))

(conj s x)

(assoc m k v)

(defn c 
  "calculates the center c of a rectangle of coordinates(x1, y1, x2, y2)" 
  [x1 y1 x2 y2]
  {:x (/ (+ x1 x2) 2)
   :y (/ (+ y1 y2) 2)})

(def x ((comp file-seq clojure.java.io/file) d))

(do (Thread/sleep 30000)
    (f 42))

(defn t [x] (apply (partial mapv vector) x))
(defn v* [u v] (reduce + (mapv * u v)))
(defn shape [a] (comp (partition-all (count a)) (map vec)))

(defn mm [a b]
    (into [] (shape a)
        (for [line a col (t b)]
            (v* line col))))

(def c (mm a b))

(def c (mmul a b))

(def y 
  (eduction (filter P)
            (map T))
            x)

(when (seq (filter #(> % x) a)) (f))

(def a 1234567890.12345678901M)

(def a [[1 2 3] [4 5 6] [7 8 9]])
(def b (apply (partial mapv vector) a))

(defn square [x] (* x x))

(def s (reduce + (map square data)))

(defn square [x] (* x x))

(def s (->> data (map square) (reduce +)))

(defn square [x] (* x x))

(def s (transduce (map square) + data))

(def foo
  (or (System/getenv "FOO") "none"))

(some-> str {"foo" foo "bar" bar "baz" baz "barfl" barfl} (.call))

(def whitelist #{#'foo #'bar #'baz #'barfl})
(some-> str symbol resolve whitelist (.call))

(def c (clojure.set/intersection (set a) (set b)))

(def t (clojure.string/replace s #"\s+" " "))

(let [s "1a22b3c4de5f6"
      t (str/replace s #"[^\d]" "")]
  (println t))

(defn find-index [x items]
  (or (->> items
           (map-indexed vector)
           (filter #(= x (peek %)))
           ffirst)
      -1))

(defn find-index [x items]
  (reduce-kv
    #(if (= x %3) (reduced %2) %1) -1 items))

(if (seq (filter odd? my-col))
  "contains odds"
  "no odds found")

(def items2 (conj items x))

(defn f 
  ([] (println "Not present"))
  ([x] (println "Present" x)))

(defn f [& [x]]
  (if (integer? x)
    (println "Present" x)
    (println "Not present")))

(drop-last items)

(def c (bit-xor a b))

(->> (map vector a b)
     (sort-by first)
     (apply (partial mapv vector)))

(doseq [e x]
  (f e))

(print a)

(def items [1 2 3 4 4 5 5 5])

(def c (count (set items)))

(def i (read-string (str "2r" s)))

(def x (if condition
         "a"
         "b"))

(replace {"foo" "bar"} x)

(doseq [n (range 5 0 -1)]
  (println n))

(def items '())

(def s (apply str (repeat n v)))

(def s (clojure.string/join "" (repeat n v)))

(defn foo [x]
  (println (if (string? x) x "Nothing.")))

(foo "Hello, world!")
(foo 42)

(disj x e)

(def parts (clojure.string/split s sep))

(def a (repeatedly n #(identity 0)))

(dorun (map-indexed (fn [i c] (println "Char" i "is" c)) s))

(def s (str a b))

;This is a comment.

;;This is a comment.

;;;This is a comment.

(def b (nil? s))