Or, with a generator:

defmodule Generator do
  def new(start) do
    Agent.start_link(fn -> start end)
  end

  def next(generator) do
    Agent.get_and_update(generator, fn value -> {value, value + 1} end)
  end
end

defmodule RoomBuilder do
  def build([{:rooms, n} | rooms], built, generator) do
    room_numbers =
      Stream.repeatedly(fn -> Generator.next(generator) end)
      |> Enum.take(n)
    build(rooms, [room_numbers | built], generator)
  end
  def build([ ], built, _generator), do: Enum.reverse(built)
end

{:ok, generator} = Generator.new(0)
reservations = [rooms: 1, rooms: 2, rooms: 3]
RoomBuilder.build(reservations, [ ], generator)
|> IO.inspect

One thing that isn’t clear is if we want a pure or impure solution. The original post had both. They’re wildly different solutions and people need to be aware of that.

I believe this shows another use case for a function like Stream.split/2 - similar to Enum.split/2, but one that would leave the “rest” part as a stream. This would allow for the most natural way to solve this:

ids = Stream.itrerate(1, &(&1 + 1))
Enum.map_reduce(reservations, ids, fn reservation, ids ->
  {room_numbers, rest} = Stream.split(ids, reservation.rooms)
  {Map.put(reservation, :room_numbers, room_numbers), rest}
end) |> elem(0)

It requires more code, but I tend to wrap such reductions in separate modules. Not sure about the wider context of your problem, so let’s say that multiple reservations make a singe “booking”. Then, I can have the booking module:

defmodule Booking do
  def new(), do: %{offset: 0, reservations: []}

  def reserve(booking, rooms) do
    reservation =
      %{rooms: rooms, room_numbers: Enum.map(1..rooms, &(&1 + booking.offset))}

    %{booking |
      reservations: [reservation | booking.reservations],
      offset: booking.offset + rooms
    }
  end

  def reservations(booking), do: Enum.reverse(booking.reservations)
end

That’s more LOC, but on the upside, the client code can IMO become more readable:

[%{rooms: 1}, %{rooms: 2}, %{rooms: 3}]
|> Enum.reduce(Booking.new(), &Booking.reserve(&2, &1.rooms))
|> Booking.reservations()

# [%{room_numbers: [1], rooms: 1}, %{room_numbers: [2, 3], rooms: 2},
# %{room_numbers: [4, 5, 6], rooms: 3}]

If the module functionality is small, and it’s used in only one place, I just “inline” these funs (in this case new/0, reserve/2, reservations/1), i.e. implement them as private in the same module where I use them.

for Stream.split/2.