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))

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

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

(or
 ala
 bala
 portokala)

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

(or
  ala
  bala
  portokala)

;; 良い
(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)
)

;; 良い
(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)

;; 良い
(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]))

;; 良い
(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)))

;; ok - 他のアリティは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 foo [x]
  {:pre [(pos? x)]}
  (bar x))

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

;; 非常に悪い
(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)

;; 良い
(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)

;; ok
(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))

;; 良い
(filter (complement some-pred?) coll)

;; 悪い
(filter #(not (some-pred? %)) coll)

;; `(:require [clojure.string :as str])` を仮定して...

;; 良い
(map #(str/capitalize (str/trim %)) ["top " " test "])

;; より良い
(map (comp str/capitalize str/trim) ["top " " test "])

;; 良い
(map #(+ 5 %) (range 1 10))

;; (きっと) より良い
(map (partial + 5) (range 1 10))

;; 良い
(-> [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)))

;; 良い
(->> (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

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

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

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

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

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

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

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

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

;; 良い
(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))

;; 良い
{: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) だったら実行時例外が投げられる

(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"})

(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.string/upper-case "bruce")

;; 悪い
(.toUpperCase "bruce")

;;;; Frob Grovel

;;; This section of code has some important implications:
;;;   1. Foo.
;;;   2. Bar.
;;;   3. Baz.

(defn fnord [zarquon]
  ;; If zob, then veeblefitz.
  (quux zot
        mumble             ; Zibblefrotz.
        frotz))

;; 悪い
(inc counter) ; increments counter by one

;; 良い
(+ foo #_(bar x) delta)

;; 悪い
(+ foo
   ;; (bar x)
   delta)

;; 良い
(defn foo
  "This function doesn't do much."
  []
  ...)

(ns foo.bar.core
  "That's an awesome library.")

;; 悪い
(defn foo
  ^{:doc "This function doesn't do much."}
  []
  ...)

(ns ^{:doc "That's an awesome library.")
  foo.bar.core)

;; 良い
(defn frobnitz
  "This function does a frobnitz.
  It will do gnorwatz to achieve this, but only under certain
  circumstances."
  []
  ...)

;; 悪い
(defn frobnitz
  "This function does a frobnitz. It will do gnorwatz to
  achieve this, but only under certain circumstances."
  []
  ...)

;; 良い
(defn qzuf-number
  "Computes the [Qzuf number](https://wikipedia.org/qzuf) of the `coll`.
  Supported options in `opts`:

  | key           | description |
  | --------------|-------------|
  | `:finite-uni?`| Assume finite universe; default: `false`
  | `:complex?`   | If OK to return a [complex number](https://en.wikipedia.org/wiki/Complex_number); default: `false`
  | `:timeout`    | Throw an exception if the computation doesn't finish within `:timeout` milliseconds; default: `nil`

  Example:
  ```clojure
  (when (neg? (qzuf-number [1 2 3] {:finite-uni? true}))
    (throw (RuntimeException. "Error in the Universe!")))
  ```"
  [coll opts]
  ...)

;; 良い
(defn watsitz
  "Watsitz takes a `frob` and converts it to a znoot.
  When the `frob` is negative, the znoot becomes angry."
  [frob]
  ...)

;; 悪い
(defn watsitz
  "Watsitz takes a frob and converts it to a znoot.
  When the frob is negative, the znoot becomes angry."
  [frob]
  ...)

;; 良い
(defn wombat
  "Acts much like `clojure.core/identity` except when it doesn't.
  Takes `x` as an argument and returns that. If it feels like it.
  See also [[kangaroo]]."
  [x]
  ...)

;; 悪い
(defn wombat
  "Acts much like clojure.core/identity except when it doesn't.
  Takes `x` as an argument and returns that. If it feels like it.
  See also kangaroo."
  [x]
  ...)

;; 良い
(def foo
  "All sentences should end with a period (or maybe an exclamation mark).
  The sentence should be followed by a space, unless it concludes the docstring.")

;; 悪い
(def foo
  "all sentences should end with a period (or maybe an exclamation mark).
  The sentence should be followed by a space, unless it concludes the docstring.")

;; 良い
(ns my.ns
  "It is actually possible to document a ns.
  It's a nice place to describe the purpose of the namespace and maybe even
  the overall conventions used. Note how _not_ indenting the docstring makes
  it easier for tooling to display it correctly.")

;; 悪い
(ns my.ns
  "It is actually possible to document a ns.
It's a nice place to describe the purpose of the namespace and maybe even
the overall conventions used. Note how _not_ indenting the docstring makes
it easier for tooling to display it correctly.")

;; 良い
(def foo
  "I'm so awesome."
  42)

;; 悪い
(def silly
  "    It's just silly to start a docstring with spaces.
  Just as silly as it is to end it with a bunch of them.      "
  42)

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

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

;; 良い
(deftest something-test ...)

;; 悪い
(deftest something-tests ...)
(deftest test-something ...)
(deftest something ...)