Is there a simpler way to generate ids

Can be cleaned up a bit with functions something like:

def rwrn(reservations, start \\0, acc \\[])
def rwrn([],_,acc), do: Enum.reverse(acc)
def rwrn([%{rooms: rooms} | t], start, acc) do
  upto = start + rooms
  rwrn(t, upto, [%{rooms: rooms, room_numbers: Enum.to_list(start..upto - 1)} | acc])
end

Thanks this is definitely clearer than the first implementation

This would be easy in javascript with a simple generator function. I was hoping there would be some generator function which keeps giving new ids.

var makeGenerator = function(offset){
  return function(){
    offset += 1;
    return offset;
  }
};

var generator = makeGenerator(0);

var reservations = [{rooms: 1}, {rooms: 2}, {rooms: 3}];
reservations.map(x => {
  x.room_numbers = _.times(x.rooms, x => generator())
  return x;
})

Stream.iterate(offset, &(&1+1)) ?

The js code persists the state, so it can give new ids, However this code gives a new set of ids starting from 0 every time.

s = Stream.iterate(0, &(&1+1))

IO.inspect Enum.take(s, 2) #=> [0, 1]
IO.inspect Enum.take(s, 2) #=> [0, 1]

defmodule RoomBuilder do
  def build([{:rooms, n} | rooms], built, next_id) do
    room_numbers =
      Stream.iterate(next_id, &(&1 + 1))
      |> Enum.take(n)
    build(rooms, [room_numbers | built], next_id + n)
  end
  def build([ ], built, _generator), do: Enum.reverse(built)
end

reservations = [rooms: 1, rooms: 2, rooms: 3]
RoomBuilder.build(reservations, [ ], 0)
|> IO.inspect

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.

Thanks for sharing this solution.

I don’t quite understand how you mean starts again at 1. Documentation for :erlang.unique_interger, which I assume System.unique_integer calls, says:

“Generates and returns an integer unique on current runtime system instance. The integer is unique in the sense that this BIF, using the same set of modifiers, will not return the same integer more than once on the current runtime system instance.”

A simple test shows getting a different integer for each call.

Thanks for dropping in

You are right about System.unique_integer, It gives a stream of increasing numbers. However, I want my ids to reset for every function call. So, something like below:

reservations = [%{rooms: 1},
                %{rooms: 4}]
assert make_reservation(rooms) == [%{rooms: 1, ids: [1]},
                %{rooms: 4, ids: [2, 3, 4, 5]}]
# and a subsequent call
reservations = [%{rooms: 2},
                %{rooms: 3}]
assert make_reservation(rooms) == [%{rooms: 1, ids: [1, 2]},
                %{rooms: 4, ids: [3, 4, 5]}]