A better test might be to read and process your CSV using tools in Stream and then do it again without streaming (presumably you’re using functions in Enum).

Whether a tool will provide better performance depends on the sorts of problems you’re solving, and will probably be way more interesting than trying to benchmark working on a range of numbers! Definitely try it on some small, medium, and massive files and compare notes.

Good catch, always thought Stream MUCH faster than Enum. Made some additional research and have got:

  def process_stream(length) do
    1..length
    |> Stream.map(&:math.sqrt(&1))
    |> Stream.map(&:math.pow(&1, 2))
    |> Stream.map(&:math.sqrt(&1))
    |> Stream.map(&:math.pow(&1, 2))
    |> Stream.map(&:math.sqrt(&1))
    |> Stream.map(&:math.pow(&1, 2))
    |> Stream.run()
  end

  def process_enum(length) do
    1..length
    |> Enum.map(&:math.sqrt(&1))
    |> Enum.map(&:math.pow(&1, 2))
    |> Enum.map(&:math.sqrt(&1))
    |> Enum.map(&:math.pow(&1, 2))
    |> Enum.map(&:math.sqrt(&1))
    |> Enum.map(&:math.pow(&1, 2))
  end

length = 1000000

Only on that scale Stream becomes faster than Enum

Comparison: 
process_stream          1.74
process_enum            1.38 - 1.27x slower +152.30 ms

With two operations in a row(like in the first post) and with length equal 10000, i’ve got the same results(Stream is 1.33 slower), but with length equal 10, it’s almost twice slower

process_enum        439.61 K
process_stream      233.28 K - 1.88x slower +2.01 μs

To me streams were always about being more memory efficient and protecting the app against huge inputs that could bring down a node or a container.

Only from a certain scale and onwards do streams become a little bit faster as well but that’s very dependent on the task to be performed, as you yourself have discovered.

José Valim on this on this topic during this year’s Advent of Code: by streaming you’re trading CPU for memory. And yes, stream will be slower, depending on the input size.