Liking cljdoc? Tell your friends :D

Lint

lint/assoc-fn

Enabled by default	Version Added	Version Updated
true	0.1	0.1

assoc-ing an update with the same key is hard to read. update is known and idiomatic.

Examples

; avoid
(assoc coll :a (+ (:a coll) 5))
(assoc coll :a (+ (coll :a) 5))
(assoc coll :a (+ (get coll :a) 5))

; prefer
(update coll :a + 5)

lint/body-unquote-splicing

Enabled by default	Version Added	Version Updated
true	1.0	1.0

A macro that nests an unquote-splicing in a macro with a & body can lead to subtle hard to debug errors. Better to wrap the unquote-splicing in a do to force it into 'expression position'.

Examples

; avoid
`(binding [max mymax] ~@body)

; prefer
`(binding [max mymax] (let [res# (do ~@body)] res#))

Reference

https://blog.ambrosebs.com/2022/09/08/break-your-macros.html

lint/divide-by-one

Enabled by default	Version Added	Version Updated
true	0.1	0.1

Checks for (/ x 1).

Examples

; avoid
(/ x 1)

; prefer
x

lint/dorun-map

Enabled by default	Version Added	Version Updated
true	0.1	1.2.1

map is lazy, which carries a performance and memory cost. dorun uses seq iteration to realize the entire sequence, returning nil. This style of iteration also carries a performance and memory cost. dorun is intended for more complex sequences, whereas a simple map can be accomplished with reduce + conj.

run! uses reduce which non-lazy and has no seq overhead.

Examples

; avoid
(dorun (map println (range 10)))

; prefer
(run! println (range 10))

lint/dot-class-method

Enabled by default	Version Added	Version Updated
true	0.1	0.1

Using the Obj/staticMethod form maps the method call to Clojure's natural function position.

NOTE: This rule is disabled if lint/prefer-method-values is enabled to prevent conflicting disagnostics.

Examples

; avoid
(. Obj staticMethod args)
(. Obj (staticMethod) args)

; prefer
(Obj/staticMethod args)

lint/dot-obj-method

Enabled by default	Version Added	Version Updated
true	0.1	1.15.2

Using the .method form maps the method symbol to Clojure's natural function position.

NOTE: This rule is disabled if lint/prefer-method-values is enabled to prevent conflicting disagnostics.

Examples

; avoid
(. obj method args)

; prefer
(.method obj args)

Configurable Attributes

Name	Default	Options
`:chosen-style`	`:dot`	`:dot`, `:method-value`

lint/duplicate-field-name

Enabled by default	Version Added	Version Updated
true	0.1.119	0.1.119

deftype and defrecord will throw errors if you define multiple fields with the same name, but it's good to catch these things early too.

Examples

; avoid
(defrecord Foo [a b a])

; prefer
(defrecord Foo [a b c])

lint/fn-wrapper

Enabled by default	Version Added	Version Updated
true	0.1	0.1

Avoid wrapping functions in pass-through anonymous function defitions.

Examples

; avoid
(fn [num] (even? num))

; prefer
even?

; avoid
(let [f (fn [num] (even? num))] ...)

; prefer
(let [f even?] ...)

Reference

https://guide.clojure.style/#no-useless-anonymous-fns

lint/if-else-nil

Enabled by default	Version Added	Version Updated
true	0.1	0.1

Idiomatic if defines both branches. when returns nil in the else branch.

Examples

; avoid
(if (some-func) :a nil)

; prefer
(when (some-func) :a)

Reference

https://guide.clojure.style/#when-instead-of-single-branch-if

lint/if-let-else-nil

Enabled by default	Version Added	Version Updated
true	0.1	0.1

Idiomatic if-let defines both branches. when-let returns nil in the else branch.

Examples

; avoid
(if-let [a 1] a nil)

; prefer
(when-let [a 1] a)

lint/if-nil-else

Enabled by default	Version Added	Version Updated
true	0.1	0.1

Idiomatic if defines both branches. when-not returns nil in the truthy branch.

Examples

; avoid
(if (some-func) nil :a)

; prefer
(when-not (some-func) :a)

lint/if-not-both

Enabled by default	Version Added	Version Updated
true	0.1	0.1

if-not exists, so use it.

Examples

; avoid
(if (not x) y z)

; prefer
(if-not x y z)

Reference

https://guide.clojure.style/#if-not

lint/if-not-do

Enabled by default	Version Added	Version Updated
true	0.1	0.1

when-not already defines an implicit do. Rely on it.

Examples

; avoid
(if-not x (do (println :a) (println :b) :c))

; prefer
(when-not x (println :a) (println :b) :c)

lint/if-not-not

Enabled by default	Version Added	Version Updated
true	0.1	0.1

Two nots cancel each other out.

Examples

; avoid
(if-not (not x) y z)

; prefer
(if x y z)

lint/if-same-truthy

Enabled by default	Version Added	Version Updated
true	0.1	0.1

or exists so use it lol.

Examples

; avoid
(if x x y)

; prefer
(or x y)

lint/into-literal

Enabled by default	Version Added	Version Updated
true	0.1	0.1

vec and set are succinct and meaningful.

Examples

; avoid
(into [] coll)

; prefer
(vec coll)

; avoid
(into #{} coll)

; prefer
(set coll)

lint/let-if

Enabled by default	Version Added	Version Updated
true	0.1.69	0.1.69

if-let exists so use it. Suggestions can be wrong as there's no code-walking to determine if result binding is used in falsy branch.

Examples

; avoid
(let [result (some-func)] (if result (do-stuff result) (other-stuff)))

; prefer
(if-let [result (some-func)] (do-stuff result) (other-stuff))

Reference

https://guide.clojure.style/#if-let

lint/let-when

Enabled by default	Version Added	Version Updated
true	0.1.69	0.1.69

when-let exists so use it.

Examples

; avoid
(let [result (some-func)] (when result (do-stuff result)))

; prefer
(when-let [result (some-func)] (do-stuff result))

Reference

https://guide.clojure.style/#when-let

lint/loop-do

Enabled by default	Version Added	Version Updated
true	0.1	0.1

loop has an implicit do. Use it.

Examples

; avoid
(loop [] (do (println 1) (println 2)))

; prefer
(loop [] (println 1) (println 2))

lint/loop-empty-when

Enabled by default	Version Added	Version Updated
true	0.1	0.1

Empty loops with nested when can be while.

Examples

; avoid
(loop [] (when (some-func) (println 1) (println 2) (recur)))

; prefer
(while (some-func) (println 1) (println 2) (recur))

lint/missing-body-in-when

Enabled by default	Version Added	Version Updated
true	0.1.69	0.1.69

when calls should have at least 1 expression after the condition.

Examples

; avoid
(when true)
(when (some-func))

; prefer
(when true (do-stuff))
(when (some-func) (do-stuff))

lint/not-empty?

Enabled by default	Version Added	Version Updated
true	0.1	1.2.0

seq returns nil when given an empty collection. empty? is implemented as (not (seq coll)) so it's best and fastest to use seq directly.

Examples

; avoid
(not (empty? coll))

; prefer (chosen style :seq (default))
(seq coll)

; prefer (chosen style :not-empty)
(not-empty coll)

Configurable Attributes

Name	Default	Options
`:chosen-style`	`:seq`	`:seq`, `:not-empty`

Reference

https://guide.clojure.style/#nil-punning

lint/prefer-method-values

Enabled by default	Version Added	Version Updated
true	1.13	1.13

NOTE: Requires Clojure version 1.12.0.

Uniform qualified method values are a new syntax for calling into java code. They must resolve to a single static or instance method and to help with that, a new metadata syntax can be used: ^[] aka ^{:param-tags []}. Types are specified with classes, each corrosponding to an argument in the target method: (^[long String] SomeClass/.someMethod 1 "Hello world!"). It compiles to a direct call without any reflection, guaranteeing optimal performance.

If it doesn't resolve to a single method, then the Clojure compiler throws a syntax error (IllegalArgumentException). Such ahead-of-time compilation checking is a powerful and helpful tool in writing correct and performant code. Given that, it is preferable to exclusively use method values.

Examples

; avoid
(.toUpperCase "noah")
(. "noah" toUpperCase)

; prefer
(^[] String/toUpperCase "noah")

Reference

https://clojure.org/news/2024/04/28/clojure-1-12-alpha10#method_values

lint/prefer-require-over-use

Enabled by default	Version Added	Version Updated
true	1.3.0	1.3.0

In the ns form prefer :require :as over :require :refer over :require :refer :all. Prefer :require over :use; the latter form should be considered deprecated for new code.

Examples

; avoid
(ns examples.ns
  (:use clojure.zip))

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

Configurable Attributes

Name	Default	Options
`:chosen-style`	`:as`	`:as`, `:refer`, `:all`

Reference

https://guide.clojure.style/#prefer-require-over-use

lint/redundant-call

Enabled by default	Version Added	Version Updated
true	0.1	0.1

A number of core functions take any number of arguments and return the arg if given only one. These calls are effectively no-ops, redundant, so they should be avoided.

Current list of clojure.core functions this linter checks:

->, ->>
cond->, cond->>
some->, some->>
comp, partial, merge
min, max, distinct?

Examples

; avoid
(-> x)
(->> x)
(cond-> x)
(cond->> x)
(some-> x)
(some->> x)
(comp x)
(partial x)
(merge x)
(min x)
(max x)
(distinct? x)

; prefer
x

lint/require-explicit-param-tags

Enabled by default	Version Added	Version Updated
false	1.13	1.13

NOTE: Requires Clojure version 1.12.0.

If :param-tags is left off of a method value, then the compiler treats it as taking no arguments (a 0-arity static method or a 1-arity instance method with the instance being the first argument). And an _ can be used as a wild-card in the cases where there is only a single applicable method (no overloads).

These last two features are where there can be trouble. If, for whatever reason, the Java library adds an overload on type, then both the lack of :param-tags and a wild-card can lead to ambiguity. This is a rare occurence but risky/annoying enough that it's better to be explicit overall.

The styles are named after what they're looking for:

:missing checks that there exists a :param-tags on a method value.
:wildcard checks that there are no usages of _ in an existing :param-tags.
:both checks both conditions.

Examples

; avoid (chosen style :both or :missing)
(java.io.File/mkdir (clojure.java.io/file "a"))

; avoid (chosen style :both or :wildcard)
(^[_ _] java.io.File/createTempFile "abc" "b")

; prefer (chosen style :both or :missing)
(^[] java.io.File/mkdir (clojure.java.io/file "a"))

; prefer (chosen style :both or :wildcard (default))
(^[String String] java.io.File/createTempFile "abc" "b")

Configurable Attributes

Name	Default	Options
`:chosen-style`	`:wildcard`	`:both`, `:missing`, `:wildcard`

Reference

https://insideclojure.org/2024/02/12/method-values

lint/take-repeatedly

Enabled by default	Version Added	Version Updated
true	0.1	0.1

repeatedly has an arity for limiting the number of repeats with take.

Examples

; avoid
(take 5 (repeatedly (range 10))

; prefer
(repeatedly 5 (range 10))

lint/thread-macro-one-arg

Enabled by default	Version Added	Version Updated
true	0.1	1.2.1

Threading macros require more effort to understand so only use them with multiple args to help with readability.

Examples

; avoid
(-> x y)
(->> x y)

; prefer
(y x)

; avoid
(-> x (y z))

; prefer
(y x z)

; avoid
(->> x (y z))

; prefer
(y z x)

Configurable Attributes

Name	Default	Options
`:chosen-style`	`:inline`	`:inline`, `:avoid-collections`

lint/try-splicing

Enabled by default	Version Added	Version Updated
true	1.0	1.0

A macro that wraps a splicing unquote in a try-catch or try-finally can lead to subtle hard to debug errors. Better to wrap the splicing unquote in a do to force it into 'expression position'.

Examples

; avoid
`(try ~@body (finally :true))

; prefer
`(try (do ~@body) (finally :true))

Reference

https://blog.ambrosebs.com/2022/09/08/break-your-macros.html

lint/underscore-in-namespace

Enabled by default	Version Added	Version Updated
true	1.11	1.11

Due to munging rules, underscores in namespaces can confuse tools and libraries which expect that underscores in class names should be dashes in Clojure.

Examples

; avoid
(ns foo_bar.baz_qux)

; prefer
(ns foo-bar.baz-qux)

lint/warn-on-reflection

Enabled by default	Version Added	Version Updated
false	1.8.0	1.8.0

Because we can't (or won't) check for interop, *warn-on-reflection* should be at the top of every file out of caution.

Examples

; avoid
(ns foo.bar)
(defn baz [a b] (+ a b))

; prefer
(ns foo.bar)
(set! *warn-on-reflection* true)
(defn baz [a b] (+ a b))

Reference

http://clojure-goes-fast.com/blog/performance-nemesis-reflection

❮Rules Overview Metrics❯

Can you improve this documentation?Edit on GitHub

cljdoc is a website building & hosting documentation for Clojure/Script libraries

Keyboard shortcuts Report a problem cljdoc on GitHub

× close