FxFasterList - High-performance effectful list operations.

An optimized variant of FxList that uses Enum.reduce_while for better performance. Best for computations that don't need resumable Yield/Suspend semantics.

When to Use FxFasterList vs FxList

*FxFasterList suspends but loses list context - resume returns only the single element's result, not the full list.

Use FxFasterList when:

• Performance is critical
• You only use Throw for error handling (not Yield)
• You don't need to resume suspended computations

Use FxList when:

• You need resumable Yield/Suspend semantics (recommended default)
• You want natural control effect propagation

Operations

• fx_map(enumerable, f) - Map effectful function over enumerable
• fx_reduce(enumerable, init, f) - Reduce with effectful function
• fx_each(enumerable, f) - Execute effectful function for each element (returns :ok)
• fx_filter(enumerable, pred) - Filter with effectful predicate

Example

import Skuld.Syntax

defcomp process_users(user_ids) do
  users <- FxFasterList.fx_map(user_ids, fn id ->
    comp do
      user <- fetch_user(id)
      count <- State.get()
      _ <- State.put(count + 1)
      return(user)
    end
  end)
  return(users)
end

Implementation

FxFasterList uses Enum.reduce_while to iterate, running each element's computation to completion before moving to the next. This avoids building continuation chains, providing ~0.1 µs/op constant cost.

Control effects (Throw, Cancelled, Suspend) are detected via ISentinel predicates (error?/1 and suspend?/1) and handled explicitly - errors propagate correctly, but Suspend loses the iteration context.