It’s possible to use a less generic version of callable_once which instead of creating new atomics at every step uses a single atomics reference for the entire stream and increments it. I think the performance impact of such a thing is negligible. But I’m no expert on low-level erlang/elixir performance issues. Just wanted to mention this for completeness (I did write the code for this and then later simplified it).
liskin
1
sasajuric
Author of Elixir In Action
Personally, I would write a small abstraction around puzzle sequence, with the following operations:
PuzzleSequence.new(seed)PuzzleSequence.next_puzzle(sequence)
From there, I’d write the rest of the system and see how it unfolds. If I notice that there is some significant overlap between what I wrote and Stream/Enum functions, I’d try to see if I can somehow reuse the existing enum logic, e.g. by doing some trickery proposed here. But before that, I’d just stick with this simple interface.
4
tomekowal
Yep, if I was doing it for work, I wouldn’t think twice about it and went with PuzzleSequence.new(seed) and PuzzleSequence.next_puzzle(sequence). But I am doing it mostly for fun and learning. I am totally aware I am over-engineering but just from those discussions I understood Streams and Enumerables better and learned about :atomics 
I feel that was worth it
3
BorjaEst
Pobably for simplicity, the developers set the definition of Stream to a function:
Stream :: function(_,_)
Which is used together with fold (wich iterates until the end).
When I try to do lazy generations in erlang, I use the following construction:
Stream :: [term() | function()]
Where the tail is the function that will generate the next iteration.
Here an example (in elixir):
def lazy_seq(cycle) do
lazy_queue(:queue.from_list(cycle))
end
defp lazy_queue(queue) do
{{:value, h}, queue} = :queue.out(queue)
[h | fn -> lazy_queue(:queue.in(h, queue)) end]
end
To use it you have to trigger the function at the tail:
iex(1)> [_|lz] = Test.lazy_seq([1,2,3,4])
[1 | #Function<0.133222699/0 in Test.lazy_queue/1>]
iex(2)> [_|lz] = lz.()
[2 | #Function<0.133222699/0 in Test.lazy_queue/1>]
iex(3)> [_|lz] = lz.()
[3 | #Function<0.133222699/0 in Test.lazy_queue/1>]
iex(4)> [_|lz] = lz.()
[4 | #Function<0.133222699/0 in Test.lazy_queue/1>]
iex(5)> [_|lz] = lz.()
[1 | #Function<0.133222699/0 in Test.lazy_queue/1>]
iex(6)> [_|lz] = lz.()
[2 | #Function<0.133222699/0 in Test.lazy_queue/1>]
...
1
evadne
Enjoy the updated version… forgot to add clause for {:halted, item}
defmodule StreamIterator.Suspension do
defstruct continuation: nil
def start(stream) do
reduce_fun = fn item, _acc -> {:suspend, item} end
{:suspended, nil, continuation} = Enumerable.reduce(stream, {:suspend, nil}, reduce_fun)
%__MODULE__{continuation: continuation}
end
def next(state)
def next(%{continuation: nil} = state) do
{:eof, state}
end
def next(state) do
case state.continuation.({:cont, nil}) do
{:suspended, item, continuation} -> {:next, item, %{state | continuation: continuation}}
{:halted, item} -> {item, %{state | continuation: nil}}
{:done, nil} -> {:eof, %{state | continuation: nil}}
end
end
end
1