lein new app hello-clojure

cd hello-clojure
lein run
# Hello, World!と表示される。

.
├── CHANGELOG.md
├── LICENSE
├── README.md
├── doc
│   └── intro.md
├── project.clj
├── resources
├── src
│   └── hello_clojure
│       └── core.clj
├── target
│   ├── classes
│   │   └── META-INF
│   │       └── maven
│   │           └── hello-clojure
│   │               └── hello-clojure
│   │                   └── pom.properties
│   └── stale
│       └── leiningen.core.classpath.extract-native-dependencies
└── test
    └── hello_clojure
        └── core_test.clj

14 directories, 9 files

(ns hello-clojure.core
  (:gen-class))

(defn -main
  "I don't do a whole lot ... yet."
  [& args]
  (println "Hello, World!"))

(defn fizzbuzz [n]
  (cond
    (and (zero? (mod n 3)) (zero? (mod n 5))) "FizzBuzz"
    (zero? (mod n 3)) "Fizz"
    (zero? (mod n 5)) "Buzz"
    :else (str n)))

(doseq [i (range 20)]
  (println (fizzbuzz i)))

# ディレクトリは一部のみ抜粋しているので、実際のディレクトリ構成とは異なることに注意
├── src
│   └── hello_clojure
│       └── core.clj
└── test
    └── hello_clojure
        └── core_test.clj

(ns hello-clojure.core-test
  (:require [clojure.test :refer :all]
            [hello-clojure.core :refer :all]))

(deftest fizzbuzz-test
  (testing "FizzBuzzの動作")
  (is (= "Fizz" (fizzbuzz 3)))
  (is (= "Buzz" (fizzbuzz 5)))
  (is (= "FizzBuzz" (fizzbuzz 15)))
  (is (= "2" (fizzbuzz 2))))

(ns hello-clojure.core
  (:gen-class)
  (:require [clojure.test :refer :all]))


(defn -main
  [& args]
  (println "Hello, Clojure!"))


(defn fizzbuzz [n]
  (cond
    (and (zero? (mod n 3)) (zero? (mod n 5))) "FizzBuzz"
    (zero? (mod n 3)) "Fizz"
    (zero? (mod n 5)) "Buzz"
    :else (str n)))

(doseq [i (range 20)]
  (println (fizzbuzz i)))

(deftest fizzbuzz-test
  (testing "FizzBuzzの動作")
  (is (= "Fizz" (fizzbuzz 3)))
  (is (= "Buzz" (fizzbuzz 5)))
  (is (= "FizzBuzz" (fizzbuzz 15)))
  (is (= "2" (fizzbuzz 2))))

(ns hello-clojure.core
  (:gen-class)
  (:require [clojure.test :refer :all]))

(defn calculation [op a b]
  (cond
    (= op "+") (+ a b)
    (= op "-") (- a b)
    (= op "*") (* a b)
    (= op "/") (cond
                  (= b 0) (str "Division by 0 is not allowed.")
                  :else (/ a b))
    :else "The operator is incorrect."))

(deftest calculation-test
  (testing "四則演算関数のテスト"
    (is (=(calculation "+" 1 2) 3))
    (is (=(calculation "-" 2 1) 1))
    (is (=(calculation "*" 2 3) 6))
    (is (=(calculation "/" 10 2) 5))
    (is (=(calculation "/" 2 10) 2/10))
    (is (=(calculation "/" 10 0) "Division by 0 is not allowed."))
    (is (=(calculation "n" 1 2) "The operator is incorrect."))
    ))

(defn calculation 
  [op a b]
  (let [operations {"+" + 
                    "-" - 
                    "*" * 
                    "/" (fn [a b] (if (= b 0)
                                    "Division by 0 is not allowed."
                                    (/ a b)))}]
    (if-let [operation (operations op)]
      (operation a b)
      "Invalid operator.")))

(deftest calculation-test
  (testing "四則演算関数のテスト"
    (is (=(calculation "+" 1 2) 3))
    (is (=(calculation "-" 2 1) 1))
    (is (=(calculation "*" 2 3) 6))
    (is (=(calculation "/" 10 2) 5))
    (is (=(calculation "/" 2 10) 2/10))
    (is (=(calculation "/" 10 0) "Division by 0 is not allowed."))
    (is (=(calculation "n" 1 2) "Invalid operator."))
    ))

(defn calculation 
  [op a b]
  (let [operations {"+" + 
                    "-" - 
                    "*" * 
                    "/" (fn [a b] 
                          (if-not (= b 0)
                            (/ a b)
                            "Division by 0 is not allowed."))}
        default-fn (fn [_ _] "Invalid operator.")] 
    ((or (operations op) default-fn) a b)))

(deftest calculation-test
  (testing "四則演算関数のテスト"
    (is (=(calculation "+" 1 2) 3) "Addition test failed")
    (is (=(calculation "-" 2 1) 1) "Subtraction test failed")
    (is (=(calculation "*" 2 3) 6) "Multiplication test failed")
    (is (=(calculation "/" 10 2) 5) "Division test failed")
    (is (=(calculation "/" 2 10) 2/10) "Fraction division test failed")
    (is (=(calculation "/" 10 0) "Division by 0 is not allowed.") "Zero division test failed")
    (is (=(calculation "n" 1 2) "Invalid operator.") "Invalid operator test failed")
    ))

(deftest bubble-sort-test
  (testing "バブルソート関数のテスト"
    (is (= (bubble-sort []) []))))

(defn bubble-sort 
  [coll] 
  coll)

(deftest bubble-sort-test
  (testing "バブルソート関数のテスト"
    (is (= (bubble-sort []) []))
    (is (= (bubble-sort [1]) [1]))))

(deftest bubble-sort-test
  (testing "バブルソート関数のテスト"
    (is (= (bubble-sort []) []))
    (is (= (bubble-sort [1]) [1]))
    (is (= (bubble-sort [2 1]) [1 2]))
    (is (= (bubble-sort [1 2]) [1 2]))))

(defn bubble-sort 
  [coll] 
  (if (= (count coll) 2)
    (if (> (first coll) (second coll))
      [(second coll) (first coll)]
      coll)
    coll))

(defn bubble-sort-pass 
  [coll] 
  (loop [unsorted coll
          result []]
        (cond
          (empty? unsorted) result
          (empty? (rest unsorted)) (conj result (first unsorted))
          :else
            (let [[a b & rest] unsorted]
              (if (> a b)
                (recur (cons a rest) (conj result b))
                (recur (cons b rest) (conj result a)))))))

(defn bubble-sort [coll]
  (loop [coll coll]
    (let [sorted (bubble-sort-pass coll)]
      (if (= coll sorted)
        sorted
        (recur sorted)))))

(deftest bubble-sort-test
  (testing "バブルソート関数のテスト"
    (is (= (bubble-sort []) []))
    (is (= (bubble-sort [1]) [1]))
    (is (= (bubble-sort [2 1]) [1 2]))
    (is (= (bubble-sort [1 2]) [1 2]))
    (is (= (bubble-sort [2 1 3]) [1 2 3]))
    ))

(defn selection-sort [coll]
  (loop [unsorted coll
        sorted []]
        (if (empty? unsorted)
        sorted
        (let [smallest (apply min unsorted)
              remainder (remove (fn [x] (= x smallest)) unsorted)]
          (recur remainder  (conj sorted smallest))))))

(deftest selection-sort-test
  (testing "選択ソート関数のテスト"
    (is (= (selection-sort []) []))
    (is (= (selection-sort [1]) [1]))
    (is (= (selection-sort [2 1]) [1 2]))
    (is (= (selection-sort [1 2]) [1 2]))
    (is (= (selection-sort [2 1 3]) [1 2 3]))
    (is (= (selection-sort [3 2 1]) [1 2 3]))
    (is (= (selection-sort [5 4 3 2 1]) [1 2 3 4 5]))))

;; modの場合
(mod 10 3)
;; 1
(mod -10 3)
;; 2
(mod 10 -3)
;; -2

;; remの場合
(rem 10 3)
;; 1
(rem -10 3)
;; -1
(rem 10 -3)
;; 1

(source mod)
; (defn mod
;   "Modulus of num and div. Truncates toward negative infinity."
;   {:added "1.0"
;    :static true}
;   [num div] 
;   (let [m (rem num div)] 
;     (if (or (zero? m) (= (pos? num) (pos? div)))
;       m 
;       (+ m div))))

;     (if (or (zero? m) (= (pos? num) (pos? div)))
;       m 
;       (+ m div))))

(rem -10 -3)
;; -1

;       (+ m div))))

;; numが-で、divが+
(rem -10 3)
;; -1

;; numが+で、divが-
(rem 10 -3)
;; 1

(+ -1 3)
;; 2

(+ 1 -3)
;; -2

; (defn rem
;   "remainder of dividing numerator by denominator."
;   {:added "1.0"
;    :static true
;    :inline (fn [x y] `(. clojure.lang.Numbers (remainder ~x ~y)))}
;   [num div]
;     (. clojure.lang.Numbers (remainder num div)))

;; rem and mod are commonly used to get the remainder.
;; mod means Knuth's mod (truncating towards negativity). 
;; rem implements  ANSI C's % operator
;; Absolute value stays the same, always the distance
;; towards zero.
;; sign depends on dividend.

(doc mod)
; -------------------------
; clojure.core/mod
; ([num div])
;   Modulus of num and div. Truncates toward negative infinity.

(source mod)
; (defn mod
;   "Modulus of num and div. Truncates toward negative infinity."
;   {:added "1.0"
;    :static true}
;   [num div] 
;   (let [m (rem num div)] 
;     (if (or (zero? m) (= (pos? num) (pos? div)))
;       m 
;       (+ m div))))

(find-doc "mod")

;; 表示多いため、一部のみ
; -------------------------
; clojure.test/set-test
; ([name & body])
; Macro
;   Experimental.
;   Sets :test metadata of the named var to a fn with the given body.
;   The var must already exist.  Does not modify the value of the var.
; 
;   When *load-tests* is false, set-test is ignored.
; -------------------------
; cider.nrepl.middleware.debug/skip-breaks!
; ([mode] [mode coor code force?])
;   Set the value of *skip-breaks* for the top-level breakpoint.
;   Additional arguments depend on mode, and should be:
;    - empty for :all or :trace
;    - coordinates, code, and force for :deeper or :before
;   See `skip-breaks?`.
; -------------------------
; cider.nrepl.middleware.debug/skip-breaks?

(apropos "selection")
(hello-clojure.core/selection-sort hello-clojure.core/selection-sort-test)

;; import
(require '[clojure.spec.alpha :as s])

;; nameが文字列であることを定義
;; 型でいうとstring相当
(s/def ::name string?)

;; 正のintであることを定義
;; 型でいうとuint相当
(s/def ::age pos-int?)

;; データを定義
(def alice {:name "Alice" :age 30}) 
(s/valid? ::name (:name alice))
;; true
(s/valid? ::age (:age alice))
;; true

;; データを定義
(def bob {:name "Bob" :age -5}) 
(s/valid? ::name (:name bob))
;; true
(s/valid? ::age (:age bob))
;; false

(def text " hello world ")

;; threading macroを使う場合
(-> text
    clojure.string/trim
    clojure.string/upper-case
    (str "!!!"))

;; threading macroを使わない場合
(str (clojure.string/upper-case (clojure.string/trim text)) "!!!")

(def person {:name "Alice" :age 28 :city "New York"})

(str "Age in 10 years: " (+ 10 (:age person)))
;; "Age in 10 years: 38" 

(-> person
    (:age)
    (+ 10)
    (str "Age in 10 years: "))
;; "38Age in 10 years: "

;; どうやら各処理の結果は第一引数に渡されるようだ
;; 第二引数に渡すようにするコードは以下になる
(->> person
     (:age)
     (+ 10)
     (str "Age in 10 years: "))

(:require [cheshire.core :as json])

(deftest test-handler-json
  (testing "GET /json"
    (let [response (app (mock/request :get "/json"))
          body (json/parse-string (bs/to-string (:body response)) true)]
      (is (= 200 (:status response)))
      (is (= "application/json;charset=UTF-8" (get-in response [:headers "Content-Type"])))
      (is (= {:message "これはJSONレスポンスです" :status "success"} body)))))

; ; expected:
; {:message "これはJSONレスポンスです", :status "success"}
; 
; ; actual:
; {"message" "これはJSONレスポンスです", "status" "success"}

(def json-string "{\"message\": \"これはJSONレスポンスです\", \"status\": \"success\"}")

;; trueを指定せずパースする
(def parsed-without-true (json/parse-string json-string))

;; trueを指定してパースする
(def parsed-true (json/parse-string json-string true))

;; 出力を確認
(prn parsed-without-true)
;; => {"message" "これはJSONレスポンスです", "status" "success"}
(prn parsed-true)
;; => {:message "これはJSONレスポンスです", :status "success"}

(defn fibonacci [n]
  (cond (= n 0) 0
        (= n 1) 1
        :else (+ (fibonacci (- n 2)) (fibonacci (- n 1)))))

(deftest fibonacci-helper-test
  (testing "フィボナッチ関数のテスト"
    (is (= (fibonacci 0) 0))
    (is (= (fibonacci 1) 1))
    (is (= (fibonacci 2) 1))
    (is (= (fibonacci 3) 2))
    (is (= (fibonacci 4) 3))
    (is (= (fibonacci 5) 5))
    (is (= (fibonacci 6) 8))
    (is (= (fibonacci 7) 13))
    (is (= (fibonacci 8) 21))))

(defn fibonacci-seq [n]
  (letfn [(fib-helper [a b count]
            (if (zero? count)
              []
              (cons a (fib-helper b (+ a b) (dec count)))))]
    (fib-helper 0 1 n)))

(deftest fibonacci-seq-test
  (testing "リストを返すフィボナッチ関数のテスト"
    (is (= (fibonacci-seq 0) []))
    (is (= (fibonacci-seq 1) [0]))
    (is (= (fibonacci-seq 2) [0 1]))
    (is (= (fibonacci-seq 3) [0 1 1]))
    (is (= (fibonacci-seq 4) [0 1 1 2]))
    (is (= (fibonacci-seq 5) [0 1 1 2 3]))
    (is (= (fibonacci-seq 6) [0 1 1 2 3 5]))
    (is (= (fibonacci-seq 7) [0 1 1 2 3 5 8]))
    (is (= (fibonacci-seq 8) [0 1 1 2 3 5 8 13]))
    (is (= (fibonacci-seq 9) [0 1 1 2 3 5 8 13 21]))
    (is (= (fibonacci-seq 10) [0 1 1 2 3 5 8 13 21 34]))))

(defn fibonacci-toc [n]
  (letfn [(fib-helper [a b count]
            (if (zero? count)
              a
              (recur b (+ a b) (dec count))))]
    (fib-helper 0 1 n)))

(deftest fibonacci-toc-test
  (testing "フィボナッチ関数(TOC)のテスト"
    (is (= (fibonacci-toc 0) 0))
    (is (= (fibonacci-toc 1) 1))
    (is (= (fibonacci-toc 2) 1))
    (is (= (fibonacci-toc 3) 2))
    (is (= (fibonacci-toc 4) 3))
    (is (= (fibonacci-toc 5) 5))
    (is (= (fibonacci-toc 6) 8))
    (is (= (fibonacci-toc 7) 13))
    (is (= (fibonacci-toc 8) 21))))

 brew install borkdude/brew/clj-kondo

(require '[clojure.edn :as edn]
         '[clojure.java.io :as io])

;; EDNファイルを読み込む
(defn load-edn [file]
  (with-open [r (io/reader file)]
    (edn/read (java.io.PushbackReader. r))))

;; 関数呼び出し関係をDOT形式に変換する
(defn generate-dot [analysis]
  (let [usages (:var-usages analysis)
        edges (map (fn [{:keys [name to]}] [name to]) usages)]
    (str "digraph G {\n"
         (apply str (map (fn [[from to]]
                           (str "  \"" from "\" -> \"" to "\";\n"))
                         edges))
         "}")))

;; EDNファイルからDOTファイルを生成
(defn edn-to-dot [edn-file dot-file]
  (let [analysis (load-edn edn-file)
        dot-data (generate-dot analysis)]
    (spit dot-file dot-data)))

(edn-to-dot "analysis.edn" "graph.dot")

(defn factorial [n]
  (if (= n 0)
    1
    (* n (factorial (dec n)))))

(factorial 5)
;; 120

(defn factorial-tco [n]
  (letfn [(fact-helper [n sum]
            (if (zero? n)
              sum
              (recur (dec n) (* sum n))))]
    (fact-helper n 1)))

(factorial-tco 5)
;; 120

(for [x [1 2 3]]
  x)

(let [x (doall (map identity [1 2 3]))]
  x)

(for [x [1 2 3 4 5 6]
      :when (even? x)]
  x)

(let [x (doall (map identity (filter even? [1 2 3 4 5 6])))]
  x)

(for [x [1 2 3]
      :let [y (* x x)]]
  (+ x y))
;; (2 6 12)

(let [x (doall (map (fn [x]
                      (let [y (* x x)]
                        (+ x y))) [1 2 3]))]
  x)
;; (2 6 12)