chore: fix credo issues surfaced by 1.7.18 upgrade

Credo 1.7.18 tightens default checks compared to 1.7.7. All issues are
pre-existing but were hidden by the older version.

- Replace `length(list) > 0` with `list != []` in colset and doc_fields
- Name unused match variables (`_occurrence`, `_args`) to follow repo
  convention
- Flatten three too-deeply-nested function bodies by extracting helpers
  in arc, binding, and computation modules; behavior unchanged

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: fahchen

lib/coloured_flow/definition/arc.ex

@@ -88,16 +88,21 @@ defmodule ColouredFlow.Definition.Arc do
 
   def build_expression(:p_to_t, code) do
     with {:ok, expression} <- Expression.build(code) do
-      case validate_bind_exprs(expression.expr) do
-        [] ->
-          {:error, {[], "missing `bind` in expression", code}}
-
-        validations ->
-          case Enum.find(validations, &match?({:error, _reason}, &1)) do
-            nil -> {:ok, expression}
-            {:error, reason} -> {:error, reason}
-          end
-      end
+      validate_p_to_t_bindings(expression, code)
+    end
+  end
+
+  defp validate_p_to_t_bindings(expression, code) do
+    case validate_bind_exprs(expression.expr) do
+      [] -> {:error, {[], "missing `bind` in expression", code}}
+      validations -> first_binding_error(expression, validations)
+    end
+  end
+
+  defp first_binding_error(expression, validations) do
+    case Enum.find(validations, &match?({:error, _reason}, &1)) do
+      nil -> {:ok, expression}
+      {:error, reason} -> {:error, reason}
     end
   end
 

lib/coloured_flow/enabled_binding_elements/binding.ex

@@ -71,15 +71,20 @@ defmodule ColouredFlow.EnabledBindingElements.Binding do
   """
   @spec combine(bindings_list :: [[[binding()]]]) :: [[binding()]]
   def combine(bindings_list) do
-    Enum.reduce(bindings_list, [[]], fn bindings, prevs ->
-      for prev <- prevs, binding <- bindings, reduce: [] do
-        acc ->
-          case get_conflicts(prev, binding) do
-            [] -> [Keyword.merge(prev, binding) | acc]
-            _other -> acc
-          end
-      end
-    end)
+    Enum.reduce(bindings_list, [[]], &combine_step/2)
+  end
+
+  defp combine_step(bindings, prevs) do
+    for prev <- prevs, binding <- bindings, reduce: [] do
+      acc -> merge_if_compatible(acc, prev, binding)
+    end
+  end
+
+  defp merge_if_compatible(acc, prev, binding) do
+    case get_conflicts(prev, binding) do
+      [] -> [Keyword.merge(prev, binding) | acc]
+      _other -> acc
+    end
   end
 
   @doc """

lib/coloured_flow/enabled_binding_elements/computation.ex

@@ -51,37 +51,43 @@ defmodule ColouredFlow.EnabledBindingElements.Computation do
     binding_combinations = Binding.combine(arc_bindings)
 
     Enum.flat_map(binding_combinations, fn binding ->
-      inputs
-      |> Enum.reduce_while([], fn {arc, place}, acc ->
-        arc_binding = merge_constants(binding, arc, constants)
-
-        with(
-          {:ok, {coefficient, value}} <- eval_arc(arc, arc_binding),
-          colour_set = fetch_colour_set!(place.colour_set, cpnet),
-          of_type_context = build_of_type_context(cpnet),
-          {:ok, ^value} <- ColourSet.Of.of_type(value, colour_set.type, of_type_context),
-          guard_binding = merge_constants(binding, transition, constants),
-          {:ok, true} <- eval_transition_guard(transition, guard_binding),
-          marking = get_marking(place, markings),
-          tokens = MultiSet.duplicate(value, coefficient),
-          true <- MultiSet.include?(marking.tokens, tokens)
-        ) do
-          {:cont, [%Marking{place: place.name, tokens: tokens} | acc]}
-        else
-          _other -> {:halt, :error}
-        end
-      end)
-      |> case do
-        :error ->
-          []
+      build_binding_element(inputs, binding, transition, constants, markings, cpnet)
+    end)
+  end
 
-        to_consume ->
-          # binding here should not contain constants
-          [BindingElement.new(transition.name, binding, to_consume)]
-      end
+  defp build_binding_element(inputs, binding, transition, constants, markings, cpnet) do
+    case collect_consumption(inputs, binding, transition, constants, markings, cpnet) do
+      :error -> []
+      to_consume -> [BindingElement.new(transition.name, binding, to_consume)]
+    end
+  end
+
+  defp collect_consumption(inputs, binding, transition, constants, markings, cpnet) do
+    Enum.reduce_while(inputs, [], fn {arc, place}, acc ->
+      try_consume(arc, place, binding, transition, constants, markings, cpnet, acc)
     end)
   end
 
+  defp try_consume(arc, place, binding, transition, constants, markings, cpnet, acc) do
+    arc_binding = merge_constants(binding, arc, constants)
+
+    with(
+      {:ok, {coefficient, value}} <- eval_arc(arc, arc_binding),
+      colour_set = fetch_colour_set!(place.colour_set, cpnet),
+      of_type_context = build_of_type_context(cpnet),
+      {:ok, ^value} <- ColourSet.Of.of_type(value, colour_set.type, of_type_context),
+      guard_binding = merge_constants(binding, transition, constants),
+      {:ok, true} <- eval_transition_guard(transition, guard_binding),
+      marking = get_marking(place, markings),
+      tokens = MultiSet.duplicate(value, coefficient),
+      true <- MultiSet.include?(marking.tokens, tokens)
+    ) do
+      {:cont, [%Marking{place: place.name, tokens: tokens} | acc]}
+    else
+      _other -> {:halt, :error}
+    end
+  end
+
   @spec reject_invalid_bandings([[[BindingElement.binding()]]], ColouredPetriNet.t()) ::
           [[[BindingElement.binding()]]]
   defp reject_invalid_bandings(bindings_list, cpnet) do

lib/coloured_flow/notation/colset.ex

@@ -173,7 +173,7 @@ defmodule ColouredFlow.Notation.Colset do
   defp decompose_union([], acc) do
     duplicate_tags = find_duplicate_tags(acc)
 
-    if length(duplicate_tags) > 0 do
+    if duplicate_tags != [] do
       raise """
       Invalid union tags, duplicate tags found: `#{type_to_string(duplicate_tags)}`
       """

lib/coloured_flow/runner/enactment/workitem_calibration.ex

@@ -134,7 +134,7 @@ defmodule ColouredFlow.Runner.Enactment.WorkitemCalibration do
     workitem_occurrences = Keyword.fetch!(options, :workitem_occurrences)
 
     to_consume_markings =
-      Enum.flat_map(workitem_occurrences, fn {workitem, _} ->
+      Enum.flat_map(workitem_occurrences, fn {workitem, _occurrence} ->
         workitem.binding_element.to_consume
       end)
 
@@ -170,7 +170,8 @@ defmodule ColouredFlow.Runner.Enactment.WorkitemCalibration do
           ColouredPetriNet.t()
         ) :: {enactment_state(), MultiSet.t(BindingElement.t())}
   defp produce_workitems(%Enactment{} = state, workitem_occurrences, %ColouredPetriNet{} = cpnet) do
-    completed_workitem_ids = Enum.map(workitem_occurrences, fn {workitem, _} -> workitem.id end)
+    completed_workitem_ids =
+      Enum.map(workitem_occurrences, fn {workitem, _occurrence} -> workitem.id end)
     occurrences = Enum.map(workitem_occurrences, &elem(&1, 1))
 
     {steps, markings} =

lib/coloured_flow/runner/storage/schemas/json_instance/codec/colour_set.ex

@@ -151,7 +151,7 @@ defmodule ColouredFlow.Runner.Storage.Schemas.JsonInstance.Codec.ColourSet do
   Converts the `descr` to a JSON representation.
   """
   @spec encode_descr(ColourSet.descr()) :: map()
-  def encode_descr({primitive, _}) when primitive in @primitive_types do
+  def encode_descr({primitive, _args}) when primitive in @primitive_types do
     %{
       "type" => Atom.to_string(primitive),
       "args" => []

lib/typed_structor/plugins/doc_fields.ex

@@ -35,7 +35,7 @@ defmodule TypedStructor.Plugins.DocFields do
       end)
 
     parameters_docs =
-      if length(parameters) > 0 do
+      if parameters != [] do
         """
         ## Parameters
 
@@ -64,7 +64,7 @@ defmodule TypedStructor.Plugins.DocFields do
       end)
 
     fields_docs =
-      if length(fields) > 0 do
+      if fields != [] do
         """
         ## Fields