Write idiomatic Elixir/Erlang with efficiency patterns

Elixir / Erlang: Idiomatic Efficiency Reference is a skill of before/after Elixir coding guidelines across seven areas: pattern matching and guards, the pipe operator, processes and OTP, error handling, collections and Enum, structs and protocols, and a summary anti-pattern table.

Use this when writing or reviewing Elixir or Erlang code and want idiomatic BEAM-platform patterns applied consistently. It's language-specific guidance, not an architectural framework, and the skill notes over-compression can hurt readability, so judgement still applies.

Pattern matching: destructure directly with case or pattern match instead of Map.get plus a nil check, use a with clause instead of nested case blocks for chained {:ok, _} and {:error, _} steps, and prefer multi-clause functions with pattern-matched arguments and guard clauses, such as when is_integer(x) and x > 0, over if/else branching on a value's shape or type. Pipes: chain two or more transforms with |> instead of nesting function calls, use then/1 or a named function rather than an awkward inline anonymous-function pipe, and skip the pipe entirely for a single operation. Processes and OTP: use GenServer instead of raw spawn for stateful processes, use Task.start or Task.async/await instead of unlinked spawn for fire-and-forget or awaitable work, use Registry or a named GenServer instead of manual Process.register, and never wrap a GenServer callback in try/catch - "let it crash" and let the supervisor restart it, since defensive catching inside a GenServer breaks supervision. Error handling: return tagged tuples like {:error, :not_found} for expected failures instead of raising, always handle both branches of an {:ok, _} or {:error, _} result rather than pattern-matching only the success case, prefer atom or struct error reasons over free-text strings since they're matchable and cheap, and use with instead of deeply nested ok/error case blocks.

Collections: use a for comprehension when filtering and transforming together instead of chaining Enum.filter and Enum.map, use Enum.empty?/1 or a [] pattern match instead of Enum.count(x) == 0 which traverses the whole list, use Map.new/2 instead of Enum.reduce to build a map, and switch to Stream for lazy evaluation when chaining transforms over large or infinite collections, keeping Enum for small collections or the final step. Structs and protocols: use a defstruct with @enforce_keys instead of a plain map for domain entities, so a typo'd key fails instead of going unnoticed; skip defprotocol until a second implementation is actually needed; and use put_in or update_in instead of manually rebuilding nested structs. A closing anti-pattern table maps specific bad patterns - unlinked spawn, try/catch in a GenServer, string error reasons, length(list) > 0, raw PID passing, ETS without a GenServer or Agent wrapper - to their preferred replacements.

Elixir and Erlang developers writing or reviewing BEAM-platform code who want a concrete before/after reference for OTP process design, error handling, and idiomatic collection use instead of relying on habit or memory.