Clojureスタイルガイド

;; 良い
(when something
  (something-else))

(with-out-str
  (println "Hello, ")
  (println "world!"))

;; 悪い - 4つのスペース
(when something
    (something-else))

;; 悪い - 1つのスペース
(with-out-str
 (println "Hello, ")
 (println "world!"))

;; 良い
(filter even?
        (range 1 10))

;; 悪い - 引数が関数名と揃っている（1つのスペースによるインデント）
(filter even?
 (range 1 10))

;; 悪い - 2つのスペースによるインデント
(filter even?
  (range 1 10))

;; 良い
(filter
 even?
 (range 1 10))

(or
 ala
 bala
 portokala)

;; 悪い - 2つのスペースによるインデント
(filter
  even?
  (range 1 10))

(or
  ala
  bala
  portokala)

;; リストリテラル
(1
 2
 3)

;; ベクターリテラル
[1
 2
 3]

;; セットリテラル
#{1
  2
  3}

;; 良い
(let [thing1 "some stuff"
      thing2 "other stuff"]
  (foo thing1 thing2))

;; 悪い
(let [thing1 "some stuff"
  thing2 "other stuff"]
  (foo thing1 thing2))

;; 良い
{:thing1 thing1
 :thing2 thing2}

;; 悪い
{:thing1 thing1
:thing2 thing2}

;; 悪い
{:thing1 thing1
  :thing2 thing2}

;; 良い
(foo (bar baz) quux)

;; 悪い
(foo(bar baz)quux)
(foo ( bar baz ) quux)

;; 良い
[1 2 3]
(1 2 3)

;; 悪い
[1, 2, 3]
(1, 2, 3)

;; 良い
{:name "Bruce Wayne" :alter-ego "Batman"}

;; 良い、ちょっと読みやすい
{:name "Bruce Wayne"
 :alter-ego "Batman"}

;; 良い、よりコンパクト
{:name "Bruce Wayne", :alter-ego "Batman"}

;; 良い。同じ行になっている。
(when something
  (something-else))

;; 悪い。別の行になっている。
(when something
  (something-else)
)

;; 良い。リッチコメントの最後の閉じ括弧は次の行に記述。
(comment
  (range 5)
  (interpose '* (range 5))
  (->> (range 5) (interpose '*))
  (= *1 *2)
  )

;; 良い
(def x ...)

(defn foo ...)

;; 悪い
(def x ...)
(defn foo ...)

;; 悪い
(def x ...)


(defn foo ...)

;; 良い
(def min-rows 10)
(def max-rows 20)
(def min-cols 15)
(def max-cols 30)

;; 良い
(defn fibo-iter
  ([n] (fibo-iter 0 1 n))
  ([curr nxt n]
   (cond
     (zero? n) curr
     :else (recur nxt (+' curr nxt) (dec n)))))

;; まあ大丈夫 - 空行は cond のペアを分けている
(defn fibo-iter
  ([n] (fibo-iter 0 1 n))
  ([curr nxt n]
   (cond
     (zero? n)
     curr

     :else
     (recur nxt (+' curr nxt) (dec n)))))

;; 悪い
(defn fibo-iter
  ([n] (fibo-iter 0 1 n))

  ([curr nxt n]
   (cond
     (zero? n) curr

     :else (recur nxt (+' curr nxt) (dec n)))))

;; 良い
(ns foo.bar)

;; 悪い
(ns foo.bar)
(ns baz.qux)

;; 悪い
(in-ns quux.quuz)
(in-ns quuz.corge)

;; 悪い
;; (ns foo.bar) や (in-ns foo.bar) を複数のファイル内で用いる

;; 良い
(ns example.ns)

;; 悪い
(ns example)

(ns examples.ns
  (:refer-clojure :exclude [next replace remove])
  (:require [clojure.string :as s :refer [blank?]])
  (:import java.util.Date))

;; より良い
(ns examples.ns
  (:require
   [clojure.string :as s :refer [blank?]]
   [clojure.set :as set]
   [clojure.java.shell :as sh])
  (:import
   java.util.Date
   java.text.SimpleDateFormat
   [java.util.concurrent Executors
                         LinkedBlockingQueue]))

;; 良い
(ns examples.ns
  (:require [clojure.string :as s :refer [blank?]]
            [clojure.set :as set]
            [clojure.java.shell :as sh])
  (:import java.util.Date
           java.text.SimpleDateFormat
           [java.util.concurrent Executors
                                 LinkedBlockingQueue]))

;; 悪い
(ns examples.ns
  (:require [clojure.string :as s :refer [blank?]] [clojure.set :as set] [clojure.java.shell :as sh])
  (:import java.util.Date java.text.SimpleDateFormat [java.util.concurrent Executors LinkedBlockingQueue]))

;; 良い
(ns examples.ns
  (:require [clojure.zip :as zip]))

;; 良い
(ns examples.ns
  (:require [clojure.zip :refer [lefts rights]]))

;; 正当な理由があれば使ってもよい
(ns examples.ns
  (:require [clojure.zip :refer :all]))

;; 悪い
(ns examples.ns
  (:use clojure.zip))

;; 良い
(ns examples.ns
  (:require
   [baz.core :as baz]
   [clojure.java.shell :as sh]
   [clojure.set :as set]
   [clojure.string :as s :refer [blank?]]
   [foo.bar :as foo]))

;; 悪い
(ns examples.ns
  (:require
   [clojure.string :as s :refer [blank?]]
   [clojure.set :as set]
   [baz.core :as baz]
   [foo.bar :as foo]
   [clojure.java.shell :as sh]))

;; 良い
(ns ... (:require [clojure.string :as str] ...)

(str/join ...)

;; あまり良くない - 慣用的に `str/` を使うべきだ
(ns ... (:require [clojure.string :as string] ...)

(string/join ...)

;; 良い
(def some-var ...)
(defn some-fun ...)

;; 悪い
(def someVar ...)
(defn somefun ...)
(def some_fun ...)

;; 良い
(defprotocol Serializable ...)
(defrecord HttpRequest ...)
(deftype XMLParser ...)

;; 悪い
(defprotocol serializable ...)
(defrecord http-request ...)
(deftype xml_parser ...)

;; 良い
(defn palindrome? ...)

;; 悪い
(defn palindrome-p ...) ; Common Lisp スタイル
(defn is-palindrome ...) ; Java スタイル

;; 良い
(defn save-user! [user]
  (db/insert! user))

;; 悪い - 副作用を持つ関数の名前が ! で終わっていない
(defn save-user [user]
  (db/insert! user))

;; 良い
(defn f->c ...)

;; あまり良くない
(defn f-to-c ...)

;; 良い
(def ^:dynamic *a* 10)

;; 悪い
(def ^:dynamic a 10)

;; 良い
(def max-size 10)

;; 悪い
(def MAX-SIZE 10) ; Java スタイル
(def +max-size+ 10) ; Common Lisp スタイル、グローバル定数
(def *max-size* 10) ; Common Lisp スタイル、グローバル変数

;; 良い
(let [[a b _ c] [1 2 3 4]]
  (println a b c))

(dotimes [_ 3]
  (println "Hello!"))

;; 悪い
(let [[a b c d] [1 2 3 4]]
  (println a b d))

(dotimes [i 3]
  (println "Hello!"))

;; 良い
(defn myfun1 [context _]
  (assoc context :foo "bar"))

(defn myfun2 [context {:keys [id]}]
  (assoc context :user-id id))

;; より良い
(defn myfun1 [context _user]
  (assoc context :foo "bar"))

(defn myfun2 [context {:keys [id] :as _user}]
  (assoc context :user-id id))

;; 良い
(defn foo
  [x]
  (bar x))

;; 良い
(defn foo [x]
  (bar x))

;; 悪い
(defn foo
  [x] (bar x))

;; 良い
(defmethod foo :bar [x] (baz x))

(defmethod foo :bar
  [x]
  (baz x))

;; 悪い
(defmethod foo
  :bar
  [x]
  (baz x))

(defmethod foo
  :bar [x]
  (baz x))

;; 良い
(defn foo [x]
  (bar x))

;; 関数本体が短い場合に良い
(defn foo [x] (bar x))

;; 複数アリティの関数に良い
(defn foo
  ([x] (bar x))
  ([x y]
   (if (predicate? x)
     (bar x)
     (baz x))))

;; 悪い
(defn foo
  [x] (if (predicate? x)
        (bar x)
        (baz x)))

;; 良い
(defn foo
  "I have two arities."
  ([x]
   (foo x 1))
  ([x y]
   (+ x y)))

;; 悪い - 余分なインデント
(defn foo
  "I have two arities."
  ([x]
    (foo x 1))
  ([x y]
    (+ x y)))

;; 良い - n番目のアリティを見つけやすい
(defn foo
  "I have two arities."
  ([x]
   (foo x 1))
  ([x y]
   (+ x y)))

;; まあ大丈夫 - 他のアリティは2引数のアリティの応用
(defn foo
  "I have two arities."
  ([x y]
   (+ x y))
  ([x]
   (foo x 1))
  ([x y z & more]
   (reduce foo (foo x (foo y z)) more)))

;; 悪い - 明確な理由のない順序
(defn foo
  ([x] 1)
  ([x y z] (foo x (foo y z)))
  ([x y] (+ x y))
  ([w x y z & more] (reduce foo (foo w (foo x (foo y z))) more)))

;; 良い
(defn create-user [{:keys [name email role admin?]}]
  ...)

;; 悪い - 呼び出し側は正確な順序を覚えていなければならない
(defn create-user [name email role admin?]
  ...)

;; 良い
(defn foo [x]
  {:pre [(pos? x)]}
  (bar x))

;; 悪い
(defn foo [x]
  (if (pos? x)
    (bar x)
    (throw (IllegalArgumentException. "x must be a positive number!")))

;; 良い - ns フォームを使う
(ns my-app.core
  (:require [clojure.string :as str]))

;; 悪い - ソースファイル内で require を関数として呼んでいる
(require '[clojure.string :as str])

;; 良い - 本当に前方参照が必要なら declare を使う
(declare process-children)

(defn process-node [node]
  (when (:children node)
    (process-children node)))

(defn process-children [node]
  (mapv process-node (:children node)))

;; 良い
(map inc [1 2 3 4 5])

;; 悪い - 同じことを行うために、わざわざループを使っている
(loop [xs [1 2 3 4 5] result []]
  (if (empty? xs)
    result
    (recur (rest xs) (conj result (inc (first xs))))))

;; 非常に悪い
(defn foo []
  (def x 5)
  ...)

;; 悪い - 関数内では clojure.core/map を完全修飾しなければならなくなる
(defn foo [map]
  ...)

;; 良い
(def thing 1) ; thingの値は1
; thingを用いた何らかの処理
(alter-var-root #'thing (constantly nil)) ; thingの値はnil

;; 悪い
(def thing 1)
; thingを用いた何らかの処理
(def thing nil)
; thingの値はnil

;; 良い
(defn print-seq [s]
  (when (seq s)
    (prn (first s))
    (recur (rest s))))

;; 悪い
(defn print-seq [s]
  (when-not (empty? s)
    (prn (first s))
    (recur (rest s))))

;; 良い
(vec some-seq)

;; 悪い
(into [] some-seq)

;; 良い
(boolean (foo bar))

;; 悪い
(if (foo bar) true false)

;; 良い
(when pred
  (foo)
  (bar))

;; 悪い
(if pred
  (do
    (foo)
    (bar)))

;; 良い
(if-let [result (foo x)]
  (something-with result)
  (something-else))

;; 悪い
(let [result (foo x)]
  (if result
    (something-with result)
    (something-else)))

;; 良い
(when-let [result (foo x)]
  (do-something-with result)
  (do-something-more-with result))

;; 悪い
(let [result (foo x)]
  (when result
    (do-something-with result)
    (do-something-more-with result)))

;; 良い
(if-not pred
  (foo))

;; 悪い
(if (not pred)
  (foo))

;; 良い
(when-not pred
  (foo)
  (bar))

;; 悪い
(when (not pred)
  (foo)
  (bar))

;; 良い
(when-not pred
  (foo)
  (bar))

;; 悪い
(if-not pred
  (do
    (foo)
    (bar)))

;; 良い
(not= foo bar)

;; 悪い
(not (= foo bar))

;; 良い
(printf "Hello, %s!\n" name)

;; 大丈夫
(println (format "Hello, %s!" name))

;; 良い
(< 5 x 10)

;; 悪い
(and (> x 5) (< x 10))

;; 良い
#(Math/round %)

;; 悪い
#(Math/round %1)

;; 良い
#(Math/pow %1 %2)

;; 悪い
#(Math/pow % %2)

;; 良い
(filter even? (range 1 10))

;; 悪い
(filter #(even? %) (range 1 10))

;; 良い
(fn [x]
  (println x)
  (* x 2))

;; 悪い (doフォームを明示的に使わなければならない)
#(do (println %)
     (* % 2))

;; 良い
(-> [1 2 3]
    reverse
    (conj 4)
    prn)

;; あまり良くない
(prn (conj (reverse [1 2 3])
           4))

;; 良い
(->> (range 1 10)
     (filter even?)
     (map (partial * 2)))

;; あまり良くない
(map (partial * 2)
     (filter even? (range 1 10)))

;; 良い
(-> x fizz :foo first frob)

;; 悪い。括弧は見づらくなるだけで不要だ。
(-> x (fizz) (:foo) (first) (frob))

;; 良い。引数がある場合に括弧は必要だ。
(-> x
    (fizz a b)
    :foo
    first
    (frob x y))

;; 良い
(->> (range)
     (filter even?)
     (take 5))

;; 悪い
(->> (range)
  (filter even?)
  (take 5))

;; 良い
(cond
  (neg? n) "negative"
  (pos? n) "positive"
  :else "zero")

;; 悪い
(cond
  (neg? n) "negative"
  (pos? n) "positive"
  true "zero")

;; 良い
(cond
  (= x 10) :ten
  (= x 20) :twenty
  (= x 30) :thirty
  :else :dunno)

;; ずっと良い
(condp = x
  10 :ten
  20 :twenty
  30 :thirty
  :dunno)

;; 良い
(cond
  (= x 10) :ten
  (= x 20) :twenty
  (= x 30) :forty
  :else :dunno)

;; より良い
(condp = x
  10 :ten
  20 :twenty
  30 :forty
  :dunno)

;; 最も良い
(case x
  10 :ten
  20 :twenty
  30 :forty
  :dunno)

;; 良い
(cond
  (test1) (action1)
  (test2) (action2)
  :else   (default-action))

;; まあまあ
(cond
  ;; test case 1
  (test1)
  (long-function-name-which-requires-a-new-line
    (complicated-sub-form
      (-> 'which-spans multiple-lines)))

  ;; test case 2
  (test2)
  (another-very-long-function-name
    (yet-another-sub-form
      (-> 'which-spans multiple-lines)))

  :else
  (the-fall-through-default-case
    (which-also-spans 'multiple
                      'lines)))

;; 良い
(remove #{1} [0 1 2 3 4 5])

;; 悪い
(remove #(= % 1) [0 1 2 3 4 5])

;; 良い
(count (filter #{\a \e \i \o \u} "mary had a little lamb"))

;; 悪い
(count (filter #(or (= % \a)
                    (= % \e)
                    (= % \i)
                    (= % \o)
                    (= % \u))
               "mary had a little lamb"))

;; 良い
(list* 1 2 3 [4 5])

;; 悪い
(cons 1 (cons 2 (cons 3 [4 5])))

;;; オブジェクト生成
;; 良い
(java.util.ArrayList. 100)

;; 悪い
(new java.util.ArrayList 100)

;;; 静的メソッドの呼び出し
;; 良い
(Math/pow 2 10)

;; 悪い
(. Math pow 2 10)

;;; インスタンスメソッドの呼び出し
;; 良い
(.substring "hello" 1 3)

;; 悪い
(. "hello" substring 1 3)

;;; 静的フィールドへのアクセス
;; 良い
Integer/MAX_VALUE

;; 悪い
(. Integer MAX_VALUE)

;;; インスタンスフィールドへのアクセス
;; 良い
(.someField some-object)

;; 悪い
(. some-object someField)

;; 良い
(def ^:private a 5)

;; 悪い
(def ^{:private true} a 5)

;; 良い
(defn- private-fun [] ...)

(def ^:private private-var ...)

;; 悪い
(defn private-fun [] ...) ; 全くプライベートでない

(defn ^:private private-fun [] ...) ; 冗長な記述だ

(def private-var ...) ; 全くプライベートでない

;; `a` で参照されるvarにメタデータを付加している
(def ^:private a {})
(meta a) ;=> nil
(meta #'a) ;=> {:private true}

;; 空のハッシュマップ値にメタデータを付加している
(def a ^:private {})
(meta a) ;=> {:private true}
(meta #'a) ;=> nil

;; 良い
[1 2 3]

;; 悪い - 単なる格納容器として使われるリスト
'(1 2 3)

;; 良い
{:name "Bruce" :age 30}

;; 悪い
{"name" "Bruce" "age" 30}

;; 良い
[1 2 3]
#{1 2 3}
(hash-set (func1) (func2)) ; 実行時に決定する値

;; 悪い
(vector 1 2 3)
(hash-set 1 2 3)
#{(func1) (func2)} ; もし (func1) = (func2) だったら実行時例外が投げられる

;; 良い - 分配束縛は意図が明確
(let [[x y] point]
  (process x y))

;; 悪い - 不安定で、インデックス0と1の要素が何なのか不明
(process (nth point 0) (nth point 1))

(def m {:name "Bruce" :age 30})

;; 良い
(:name m)

;; 必要以上の冗長な記述だ
(get m :name)

;; 悪い - NullPointerException の影響を受けやすい
(m :name)

;; 良い
(filter #{\a \e \o \i \u} "this is a test")

;; 悪い - 汚すぎて書けない

((juxt :a :b) {:a "ala" :b "bala"})

;; 良い - 通常のコードは永続的コレクションで十分
(reduce conj [] (range 1000))

;; ベンチマークの結果が一時的コレクションの使用を正当化するホットパスでの使用なら大丈夫
(persistent! (reduce conj! (transient []) (range 1000)))

;; 良い
{:name "Bruce" :age 30}

;; 悪い
(doto (java.util.HashMap.)
  (.put :name "Bruce")
  (.put :age 30))

;; 良い
[1 2 3]

;; 悪い - Javaとの相互運用性やプリミティブ型の性能が必要でない限り使わない
(int-array [1 2 3])

(defrecord Foo [a b])
(deftype Bar [a b])

;; 良い
(->Foo 1 2)
(map->Foo {:b 4 :a 3})
(->Bar 1 2)

;; 悪い
(Foo. 1 2)
(Bar. 1 2)

(defrecord Customer [id name phone email])

(defn make-customer
  "Creates a new customer record."
  [{:keys [name phone email]}]
  {:pre [(string? name)
         (valid-phone? phone)
         (valid-email? email)]}
  (->Customer (next-id) name phone email))

(defrecord Foo [num])

;; 良い
(defn make-foo
  [num]
  {:pre [(pos? num)]}
  (->Foo num))

;; 悪い
(defn ->Foo
  [num]
  {:pre [(pos? num)]}
  (Foo. num))

;; 良い
(clojure.math/pow 2 5)

;; まあまあ
(Math/pow 2 5)

;; 良い
(clojure.string/upper-case "bruce")

;; 悪い
(.toUpperCase "bruce")

;; 良い - データを運ぶ例外（clojure.lang.ExceptionInfo）の生成には ex-info を使う
(throw (ex-info "Invalid input" {:value x :reason :negative}))

;; 良い - Javaの標準例外型を使う
(throw (IllegalArgumentException. "x must be positive"))

;; 悪い - さしたる理由もなく独自の例外型を定義している
(deftype MyCustomException [msg]
  ...)

;; 良い
(with-open [rdr (clojure.java.io/reader "file.txt")]
  (slurp rdr))

;; 悪い - 冗長で、間違えやすい
(let [rdr (clojure.java.io/reader "file.txt")]
  (try
    (slurp rdr)
    (finally
      (.close rdr))))

;; 良い
(try (foo)
  (catch ExceptionInfo ex ...)
  (catch AssertionError t ...))

;; 悪い
(try (foo)
  (catch Throwable t ...))

;; 良い - 単純な関数で問題なく実現できます
(defn square [x]
  (* x x))

;; 悪い - 関数で実現できることをマクロで実装
(defmacro square [x]
  `(* ~x ~x))

;; Step 1: マクロをどのように使いたいかを書く
(with-retry {:retries 3 :delay 1000}
  (fetch-data url))

;; Step 2: 次に、その使い方を実現するためのマクロを作る
(defmacro with-retry [{:keys [retries delay]} & body]
  ...)

;; 良い - ヘルパー関数がコード生成の一部を担当する
(defn- emit-constructor [name fields]
  `(defn ~(symbol (str "make-" name)) [~@fields]
     (new ~name ~@fields)))

(defn- emit-predicate [name]
  `(defn ~(symbol (str name "?")) [x#]
     (instance? ~name x#)))

(defmacro defentity [name & fields]
  `(do
     (defrecord ~name [~@fields])
     ~(emit-constructor name fields)
     ~(emit-predicate name)))

;; 悪い - すべてを含んだ一つの大きなマクロ
(defmacro defentity [name & fields]
  `(do
     (defrecord ~name [~@fields])
     (defn ~(symbol (str "make-" name)) [~@fields]
       (new ~name ~@fields))
     (defn ~(symbol (str name "?")) [x#]
       (instance? ~name x#))))