lazy_seq_demo.ex

defrecord LazySeq, [:state, :generator, :limit, {:step, 0}] do
  def next(LazySeq[] = current) do
    {value, new_state} = current.generator.(current.state)
    {value, current.state(new_state).update_step(&1 + 1)}
  end
end


defimpl Enum.Iterator, for: LazySeq do
  def count(LazySeq[] = lseq), do: lseq.limit
  
  def iterator(LazySeq[] = lseq) do
    {iterate(&1), iterate(lseq)}
  end

  defp iterate(LazySeq[step: step, limit: limit]) 
  when is_number(limit) and step >= limit do
    :stop
  end
  
  defp iterate(LazySeq[] = lseq) do
    lseq.next
  end
end


defmodule LazyFibSeq do
  defp next(nil, nil), do: 0
  defp next(nil, _), do: 1
  defp next(previous, current), do: previous + current
  
  defp return(current, next), do: {next, {current, next}}
  
  defp generator({previous, current}) do
    return(current, next(previous, current))
  end
  
  def new do
    LazySeq.new(
      state: {nil, nil},
      generator: function(:generator, 1)
    )
  end
end

IO.inspect(Enum.take(LazyFibSeq.new, 10))
IO.inspect(LazyFibSeq.new.limit(20) |> Enum.drop(10))