It only reads the elements it needs:

• find is lazy and will halt as soon as it finds something
• it doesn’t need to build a new list

You can confirm it as follows (plus the fact it doesn’t consume infinite time and memory ):

Stream.cycle([1, 2, 5, 6, 23, 42, 19]) 
|> Stream.map(&IO.inspect/1)
|> Enum.find(& rem(&1, 7) == 0)

The only issue is a potential infinite loop, if the condition is never met.

Enum and Stream both work with any enumerable inputs including streams, but you can think of most functions as roughly part of one of its categories:

• “producer” Enum functions like map/2 / filter/2 that are returning a new list => the Stream equivalent would avoid building the list and return a new stream instead
• “consumer” Enum functions like reduce/3, sum/1, max/1, that are returning an accumulator and not a list => can be used to consume non-infinite streams, they have no equivalent in the Stream module.
• “lazy consumer” Enum functions like reduce_while/2, find/2, any?/2, that halt early to return a value => can be used to consume potential infinite streams, they have no equivalent in the Stream module.

This?

[1, 2, 3, 4, 5]
|> Stream.transform(false, fn
  x, false -> {[x], x == 3}
  _, true -> {:halt, true}
end)
|> Enum.into([])
# [1, 2, 3]

No, it won’t. Both Enum and Stream iterate their inputs reduction by reduction/enumeration by enumeration. The difference is their output. Stream apis return lazy enumerables. Enum api eagerly calculate their results.