# credence v0.2.0 - Table of Contents

An Elixir semantic linter that detects performance issues and non-idiomatic code via AST analysis.

## Modules

- [Credence](Credence.md): Credence (Semantic Linter for Elixir)
Main entry point for analyzing Elixir code.

- [Credence.Issue](Credence.Issue.md): Defines the structured issue format for any rule violations.

- [Credence.Rule](Credence.Rule.md): Behaviour for all Credence semantic rules.

- [Credence.Rule.AvoidGraphemesEnumCount](Credence.Rule.AvoidGraphemesEnumCount.md): Performance rule: warns when `String.graphemes/1 |> Enum.count()` is used.
- [Credence.Rule.AvoidGraphemesLength](Credence.Rule.AvoidGraphemesLength.md): Performance rule: warns when `String.graphemes/1 |> length()` is used.
- [Credence.Rule.DescriptiveNames](Credence.Rule.DescriptiveNames.md): Maintainability rule: Flags single-letter variable names in function signatures.
- [Credence.Rule.InconsistentParamNames](Credence.Rule.InconsistentParamNames.md): Detects functions where the same positional parameter uses different
variable names across clauses.
- [Credence.Rule.NoAnonFnApplicationInPipe](Credence.Rule.NoAnonFnApplicationInPipe.md): Readability rule: Detects anonymous functions applied with `.()` inside
a pipeline.
- [Credence.Rule.NoDestructureReconstruct](Credence.Rule.NoDestructureReconstruct.md): Detects patterns where a list is destructured into individual variables
and then immediately reassembled into the same list.
- [Credence.Rule.NoDocFalseOnPrivate](Credence.Rule.NoDocFalseOnPrivate.md): Style rule: Detects `@doc false` placed before private functions (`defp`).
- [Credence.Rule.NoDoubleSortSameList](Credence.Rule.NoDoubleSortSameList.md): Performance rule: Detects sorting the same list twice — once ascending and
once descending — when a single sort plus `Enum.reverse/1` would suffice.
- [Credence.Rule.NoEagerWithIndexInReduce](Credence.Rule.NoEagerWithIndexInReduce.md): Performance rule: Detects `Enum.with_index/1` passed directly as the
enumerable argument to `Enum.reduce/3` (or piped into it).
- [Credence.Rule.NoEnumAtBinarySearch](Credence.Rule.NoEnumAtBinarySearch.md): Performance rule: Flags potential binary search patterns using `Enum.at/2`.
- [Credence.Rule.NoEnumAtInLoop](Credence.Rule.NoEnumAtInLoop.md): Performance rule: Detects `Enum.at/2` inside looping constructs
(`Enum.reduce`, `Enum.map`, `Enum.each`, `Enum.filter`, `Enum.flat_map`,
`for` comprehensions) or recursive functions.
- [Credence.Rule.NoEnumAtLoopAccess](Credence.Rule.NoEnumAtLoopAccess.md): Performance heuristic rule: warns when `Enum.at/2` is used inside loops.
- [Credence.Rule.NoEnumCountForLength](Credence.Rule.NoEnumCountForLength.md): Detects `Enum.count/1` (without a predicate) and suggests `length/1`
or a more specific size function.
- [Credence.Rule.NoEnumDropNegative](Credence.Rule.NoEnumDropNegative.md): Performance rule: Detects `Enum.drop(list, -n)` where `n` is a positive
integer literal.
- [Credence.Rule.NoEnumTakeNegative](Credence.Rule.NoEnumTakeNegative.md): Performance rule: Detects `Enum.take(list, -n)` where `n` is a positive
integer literal.
- [Credence.Rule.NoExplicitMaxReduce](Credence.Rule.NoExplicitMaxReduce.md): Strict semantic rule: Flags ONLY explicit max-reduction patterns inside `Enum.reduce/3`.
- [Credence.Rule.NoExplicitMinReduce](Credence.Rule.NoExplicitMinReduce.md): Flags explicit min-reduction patterns inside Enum.reduce/3.
- [Credence.Rule.NoExplicitSumReduce](Credence.Rule.NoExplicitSumReduce.md): Flags explicit sum-reduction patterns inside Enum.reduce/3.
- [Credence.Rule.NoGraphemePalindromeCheck](Credence.Rule.NoGraphemePalindromeCheck.md): Readability & performance rule: Detects the pattern of decomposing a string
into graphemes or a charlist, only to compare it with its own `Enum.reverse`.
- [Credence.Rule.NoGuardEqualityForPatternMatch](Credence.Rule.NoGuardEqualityForPatternMatch.md): Readability rule: Detects guard clauses that compare a parameter to a
literal value with `==` when pattern matching in the function head would
be clearer and more idiomatic.
- [Credence.Rule.NoIntegerToStringDigits](Credence.Rule.NoIntegerToStringDigits.md): Performance rule: Detects converting an integer to a string representation
in a given base and then to a charlist, when `Integer.digits/2` can extract
the digits directly as a list of integers.
- [Credence.Rule.NoIsPrefix](Credence.Rule.NoIsPrefix.md): Style rule: Detects functions named with an `is_` prefix that are not
guard-safe BIFs.
- [Credence.Rule.NoIsPrefixForNonGuard](Credence.Rule.NoIsPrefixForNonGuard.md): Detects `def`/`defp` functions with an `is_` prefix, which in Elixir
is reserved for guard-safe functions defined with `defguard`.
- [Credence.Rule.NoKernelShadowing](Credence.Rule.NoKernelShadowing.md): Idiomatic rule: warns when variables shadow `Kernel` functions.
- [Credence.Rule.NoLengthInGuard](Credence.Rule.NoLengthInGuard.md): Performance rule: Detects the use of `length/1` inside guard clauses (`when`).
- [Credence.Rule.NoListAppendInLoop](Credence.Rule.NoListAppendInLoop.md): Performance rule: Detects the use of `++` inside looping constructs
(`Enum.reduce`, `for` comprehensions) and inside recursive functions.
- [Credence.Rule.NoListDeleteAtInLoop](Credence.Rule.NoListDeleteAtInLoop.md): Performance rule: Detects `List.delete_at/2` inside looping constructs
(`for`, `Enum.reduce`, `Enum.map`, `Enum.flat_map`) or recursive functions.
- [Credence.Rule.NoListFold](Credence.Rule.NoListFold.md): Detects usage of `List.foldl/3` and `List.foldr/3` and suggests
`Enum.reduce/3` instead.
- [Credence.Rule.NoListLast](Credence.Rule.NoListLast.md): Performance rule: Flags usage of `List.last/1`.
- [Credence.Rule.NoListToTupleForAccess](Credence.Rule.NoListToTupleForAccess.md): Performance & style rule: Detects converting a list to a tuple via
`List.to_tuple/1` and then accessing elements with `elem/2`.
- [Credence.Rule.NoManualEnumUniq](Credence.Rule.NoManualEnumUniq.md): Performance and idiomatic code rule: warns when `Enum.uniq/1` is manually
reimplemented using `Enum.reduce/3` and `MapSet`.
- [Credence.Rule.NoManualFrequencies](Credence.Rule.NoManualFrequencies.md): Readability rule: Detects manual frequency counting with
`Enum.reduce(list, %{}, fn x, acc -> Map.update(acc, x, 1, ...) end)`.
- [Credence.Rule.NoManualListLast](Credence.Rule.NoManualListLast.md): Detects hand-rolled reimplementations of `List.last/1`.
- [Credence.Rule.NoManualMax](Credence.Rule.NoManualMax.md): Detects `if` expressions that manually reimplement `Kernel.max/2`.
- [Credence.Rule.NoManualMin](Credence.Rule.NoManualMin.md): Detects `if` expressions that manually reimplement `Kernel.min/2`.
- [Credence.Rule.NoManualStringReverse](Credence.Rule.NoManualStringReverse.md): Readability & performance rule: Detects the pattern
`String.graphemes(s) |> Enum.reverse() |> Enum.join()` which is a manual
reimplementation of `String.reverse/1`.
- [Credence.Rule.NoMapAsSet](Credence.Rule.NoMapAsSet.md): Style rule: Detects using a `Map` with boolean literal values (`true`/`false`)
purely for membership tracking, when `MapSet` is more appropriate.
- [Credence.Rule.NoMapKeysEnumLookup](Credence.Rule.NoMapKeysEnumLookup.md): Detects `Map.keys(var)` piped into an `Enum` function whose callback
also looks up values from the same map variable.
- [Credence.Rule.NoMapKeysOrValuesForIteration](Credence.Rule.NoMapKeysOrValuesForIteration.md): Performance rule: Detects `Map.values(map)` or `Map.keys(map)` passed
directly into an `Enum` function, which creates an unnecessary intermediate
list.
- [Credence.Rule.NoMapThenAggregate](Credence.Rule.NoMapThenAggregate.md): Detects `Enum.map/2` immediately followed by a terminal aggregation
like `Enum.max/1`, `Enum.min/1`, or `Enum.sum/1`, which creates an
unnecessary intermediate list.
- [Credence.Rule.NoMapUpdateThenFetch](Credence.Rule.NoMapUpdateThenFetch.md): Performance rule: Detects calling `Map.update/4` (or `Map.update!/3`) on a
map variable and then immediately reading the same key back with
`Map.fetch!/2` or `Map.get/2`.
- [Credence.Rule.NoMultipleEnumAt](Credence.Rule.NoMultipleEnumAt.md): Readability & performance rule: Detects multiple `Enum.at/2` calls on the
same variable with literal indices. Each `Enum.at/2` traverses the list
from the head, so N calls cost O(N × len). Pattern matching destructures
the list in a single pass.
- [Credence.Rule.NoNestedEnumOnSameEnumerable](Credence.Rule.NoNestedEnumOnSameEnumerable.md)
- [Credence.Rule.NoParamRebinding](Credence.Rule.NoParamRebinding.md): Style & correctness rule: Detects rebinding of parameter names inside
anonymous function (`fn`) bodies.
- [Credence.Rule.NoRedundantEnumJoinSeparator](Credence.Rule.NoRedundantEnumJoinSeparator.md): Readability rule: Detects `Enum.join("")` where the empty-string separator
is passed explicitly.
- [Credence.Rule.NoRedundantNegatedGuard](Credence.Rule.NoRedundantNegatedGuard.md): Detects guard clauses that are logically redundant because a preceding
clause of the same function already handles the complementary case.
- [Credence.Rule.NoRepeatedEnumTraversal](Credence.Rule.NoRepeatedEnumTraversal.md)
- [Credence.Rule.NoSortForTopK](Credence.Rule.NoSortForTopK.md): Detects inefficient patterns where a full sort is performed only to
retrieve a small number of elements (top-k).
- [Credence.Rule.NoSortThenAt](Credence.Rule.NoSortThenAt.md): Performance rule: Detects sorting an entire list only to retrieve a single
element by index via `Enum.at/2`.
- [Credence.Rule.NoSortThenReverse](Credence.Rule.NoSortThenReverse.md): Performance & readability rule: Detects the pattern of calling `Enum.sort/1`
followed by `Enum.reverse/1` on the result.
- [Credence.Rule.NoStringConcatInLoop](Credence.Rule.NoStringConcatInLoop.md): Performance rule: Detects string concatenation with `<>` inside looping
constructs (`Enum.reduce`, `Enum.reduce_while`, `for` comprehensions) or
recursive functions.
- [Credence.Rule.NoStringLengthForCharCheck](Credence.Rule.NoStringLengthForCharCheck.md): Performance rule: Detects `String.length(x) == 1` (or `!= 1`) used to
validate that a string is a single character.
- [Credence.Rule.NoTakeWhileLengthCheck](Credence.Rule.NoTakeWhileLengthCheck.md): Detects `Enum.take_while/2` piped into `length/1` or `Enum.count/1`,
which materializes an intermediate list only to count it.
- [Credence.Rule.NoUnderscoreFunctionName](Credence.Rule.NoUnderscoreFunctionName.md): Detects function names that use a leading underscore to indicate privacy,
a convention borrowed from Python that is non-idiomatic in Elixir.
- [Credence.Rule.NoUnnecessaryCatchAllRaise](Credence.Rule.NoUnnecessaryCatchAllRaise.md): Detects function clauses where every argument is a wildcard and the
body does nothing but `raise`.
- [Credence.Rule.PreferDescSortOverNegativeTake](Credence.Rule.PreferDescSortOverNegativeTake.md): Prefer `Enum.sort(nums, :desc) |> Enum.take(n)`
over `Enum.sort(nums) |> Enum.take(-n)`.
- [Credence.Rule.PreferEnumReverseTwo](Credence.Rule.PreferEnumReverseTwo.md): Performance rule: Flags `Enum.reverse(list) ++ other_list`.
- [Credence.Rule.PreferEnumSlice](Credence.Rule.PreferEnumSlice.md): Readability and Intent rule: Flags usage of `Enum.drop/2` followed by `Enum.take/2`.
- [Credence.Rule.RedundantListGuard](Credence.Rule.RedundantListGuard.md): Detects redundant `is_list/1` guards on variables already bound by a
cons pattern (`[head | tail]`).
- [Credence.Rule.UnnecessaryGraphemeChunking](Credence.Rule.UnnecessaryGraphemeChunking.md): Detects inefficient string transformation pipelines that
- [Credence.Rule.UseMapJoin](Credence.Rule.UseMapJoin.md): Detects `Enum.map/2` chained into `Enum.join/1` or `Enum.join/2`,
and suggests `Enum.map_join/3` instead.

