🔄 Traductor: | Paradigm Bridge | From Python to Elixir | 📊 Level: Intermediate | 🌐 Coding5s.com

Tema/Contexto: Filtering, averaging, and ranking structured data through immutable transformations

🧠 El Choque de Mentalidad

In Python, ReadingAnalyzer combines data and behavior: the object stores readings in self, and rank_active() operates on that internal state. Elixir asks you to separate those ideas. A module contains behavior, while the data remains an explicit value passed into a function. Therefore, self does not need an equivalent—it disappears because no mutable object owns the readings.

The two intermediate lists also become stages in a data pipeline. Each stage receives a value and returns a new value: filter the maps, transform them into scored tuples, and sort those tuples. Nothing is modified in place. The pipeline is not merely alternative syntax; it exposes the direction in which data flows through the algorithm.

🗺️ Mapa de Conceptos

💀 Esqueleto Guía

defmodule ReadingAnalyzer do
  @moduledoc """
  Transforms structured readings into a descending ranking.
  """

  @spec rank_active([map()]) :: [{String.t(), float()}]
  def rank_active(readings) when is_list(readings) do
    # TODO: Pass the input through the filtering stage.
    # TODO: Transform each remaining map into a scored tuple.
    # TODO: Sort the tuples by their calculated score.
  end

  defp active?(reading) do
    # TODO: Decide whether the structure represents an active entry.
  end

  defp score(reading) do
    # TODO: Extract the required values through pattern matching.
    # TODO: Calculate and return the scored tuple.
  end
end

👑 The ELIXIR Way

defmodule ReadingAnalyzer do
  @moduledoc """
  Filters active readings, calculates their averages, and ranks them.
  """

  @type reading :: %{
          required(:id) => String.t(),
          required(:status) => String.t(),
          required(:values) => [number()]
        }

  @spec rank_active([reading()]) :: [{String.t(), float()}]
  def rank_active(readings) when is_list(readings) do
    readings
    |> Enum.filter(&active?/1)
    |> Enum.map(&score/1)
    |> Enum.sort_by(&elem(&1, 1), :desc)
  end

  defp active?(%{status: "offline"}), do: false
  defp active?(%{status: _status}), do: true

  defp score(%{id: id, values: [_ | _] = values}) do
    average =
      values
      |> Enum.sum()
      |> Kernel./(length(values))
      |> Float.round(1)

    {id, average}
  end

  defp score(%{id: id, values: []}) do
    raise ArgumentError, "values cannot be empty for #{id}"
  end
end

readings = [
  %{id: "R-01", status: "ok", values: [21, 23, 22]},
  %{id: "R-02", status: "offline", values: [99]},
  %{id: "R-03", status: "warning", values: [30, 32, 31]}
]

readings
|> ReadingAnalyzer.rank_active()
|> IO.inspect()

💻 Expected Output

[{"R-03", 31.0}, {"R-01", 22.0}]

🩺 La Autopsia Técnica

The Python object stores readings as mutable instance state. Even if this particular method never mutates it, another method could modify self.readings, meaning that the result may depend on the object’s history. In the Elixir version, rank_active/1 receives everything it needs. The same input produces the same result, making the transformation easier to test, reason about, and execute concurrently.

The pipeline preserves the original algorithmic progression:

1. Enum.filter/2 corresponds to the first comprehension and removes "offline" entries.
2. Enum.map/2 corresponds to the second comprehension and creates {id, average} tuples.
3. Enum.sort_by/3 reproduces the descending sort based on each tuple’s second element.

Pattern matching moves structural assumptions into function heads. %{status: "offline"} describes the exact case that must be rejected. %{id: id, values: [_ | _] = values} simultaneously verifies that values is nonempty and extracts the fields required by the calculation. The separate empty-list clause converts an implicit division failure into an intentional, descriptive error.

Immutability does not mean Elixir creates a complete deep copy after every pipe stage. BEAM data structures share unchanged internal data where possible. Processes also have isolated heaps, so mutable state cannot be accidentally shared between concurrent workers. When values cross process boundaries, this isolation greatly reduces the locking and race-condition problems common to shared-memory designs.

However, this module does not automatically execute concurrently merely because it is written in Elixir. Concurrency should be introduced only when the scoring operation is sufficiently expensive, potentially through Task.async_stream/3. For three small records, concurrent execution would add more overhead than value.

The Enum.filter/2 and Enum.map/2 stages create intermediate lists. A Stream could lazily combine those stages, although sorting ultimately requires materializing the complete result. Here, the explicit Enum stages are preferable because they preserve the conceptual progression and remain easy to inspect.

If the readings genuinely needed long-lived mutable state, a senior Elixir developer would not imitate self with global variables. They would place that state behind a supervised GenServer or Agent. This calculation is deterministic, so introducing a stateful process would add unnecessary architectural complexity.

🏛️ Consejo del Arquitecto

Do not search for Elixir replacements for class and self one keyword at a time. First ask: “Does this operation truly require persistent state, or is it only transforming a value?” When the answer is transformation, let the data travel openly through pure functions. That shift—from hidden object history to visible data flow—is where functional clarity begins.