Quokka Elixir Formatter Plugin

Quokka automatically converts checks for empty enums (like length() == 0 or Enum.count() > 0) into the more idiomatic and efficient Enum.empty?/1 or Enum.any?/2. This addresses Credo.Check.Warning.ExpensiveEmptyEnumCheck and is not configurable.

# Given:
if enum |> MyModule.transform() |> length() == 0, do: "empty"
# Styled:
if enum |> MyModule.transform() |> Enum.empty?(), do: "empty"

# Given:
if Enum.count(enum) > 0, do: "not empty"
# Styled:
if not Enum.empty?(enum), do: "not empty"

Beyond Credo-inspired rewrites, Quokka provides built-in support for:

• Test Styling: Rewrites tests to be efficient and idiomatic.
• Unnecessary reduces: Automatically rewrites eligible Enum.reduce/3 calls to more appropriate functions, such as Map.new/2 or other purpose-built functions from the Enum module.

Quokka rewrites Enum.reduce/2,3 calls to more efficient, purpose-built functions like Enum.sum/1, Enum.count/2, or Map.new/2 when the reducer follows specific patterns (e.g., simple addition or map insertion).

# Before
Enum.reduce(items, 0, fn item, acc -> acc + item.count end)
# Styled
Enum.sum_by(items, fn item -> item.count end)

# Before
Enum.reduce(items, %{}, fn item, acc -> Map.put(acc, item.id, item) end)
# Styled
Map.new(items, fn item -> {item.id, item} end)

Quokka rewrites functions where the entire body is a try/do block to use the implicit try syntax. This addresses Credo.Check.Readability.PreferImplicitTry. This behavior is not configurable.

# Before
def foo() do
  try do
    uh_oh()
  rescue
    exception -> {:error, exception}
  catch
    :a_throw -> {:error, :threw!}
  else
    try_has_an_else_clause? -> {:did_you_know, try_has_an_else_clause?}
  after
    :done
  end
end

# After
def foo() do
  uh_oh()
rescue
  exception -> {:error, exception}
catch
  :a_throw -> {:error, :threw!}
else
  try_has_an_else_clause? -> {:did_you_know, try_has_an_else_clause?}
after
  :done
end

Quokka rewrites pattern matching to ensure the variable being assigned is on the right-hand side of the = operator. This applies to case statements, with expressions, and function arguments. This addresses Credo.Check.Consistency.ParameterPatternMatching but is not configurable; Quokka always moves matches to the right.

# Before
case foo do
  bar = %{baz: baz? = true} -> :baz?
  opts = [[a = %{}] | _] -> a
end
# Styled:
case foo do
  %{baz: true = baz?} = bar -> :baz?
  [[%{} = a] | _] = opts -> a
end

Quokka automatically expands multi-alias and multi-import statements into explicit, single-line forms. This helps with searchability and addresses Credo readability checks.

Note: Quokka only expands these statements; it does not compress multiple individual aliases into a single multi-alias statement. The behavior is configurable via your Credo configuration for Credo.Check.Readability.MultiAlias.

# Before
import Foo.{Bar, Baz, Bop}
alias Foo.{Bar, Baz.A, Bop}

# After
import Foo.Bar
import Foo.Baz
import Foo.Bop

alias Foo.Bar
alias Foo.Baz.A
alias Foo.Bop

On Elixir 1.18+, Quokka collapses nested Enum.map/2 or Stream.map/2 calls consumed by Enum.sum/1 or Enum.product/1 into the purpose-built aggregate functions. This avoids allocating an intermediate list.

# Before
Enum.sum(Enum.map(groups, fn group -> length(group.rows) end))
# Styled
Enum.sum_by(groups, fn group -> length(group.rows) end)

When possible, Quokka will compress multi-line function definitions into a single line if they fit within the configured line length limit.

# Before
def save(
       %Socket{assigns: %{user: user, live_action: :new}} = initial_socket,
       params
     ),
     do: :ok

# Styled
def save(%Socket{assigns: %{user: user, live_action: :new}} = initial_socket, params), do: :ok

Quokka simplifies Map and Keyword operations when they involve a single key literal:

• Map.merge(map, %{key: value}) $\rightarrow$ Map.put(map, :key, value)
• Map.drop(map, [key]) $\rightarrow$ Map.delete(map, key)
• Map.get(map, key, nil) $\rightarrow$ Map.get(map, key)

# Before
Map.merge(map, %{key: :value})
# Styled
Map.put(map, :key, :value)

# Before
Map.drop(map, [key])
# Styled
Map.delete(map, key)