Here’s a slightly-different implementation that uses a protocol for polymorphic dispatch:

defprotocol InfoProtocol do
  def key(data)
  def initial_value(data)
  def current_value(data)
  def updated_value(data, input)
end

defmodule Info.DayNumber do
  defstruct [:value]

  defimpl InfoProtocol do
    def key(_), do: :day_number
    def initial_value(data), do: %{data | value: 0}
    def current_value(data), do: data.value
    def updated_value(data, _input), do: %{data | value: data.value + 1}
  end
end

defmodule Info.News do
  defstruct [:value]

  defimpl InfoProtocol do
    def key(_), do: :news
    def initial_value(data), do: %{data | value: nil}
    def current_value(data), do: data.value
    def updated_value(data, input), do: %{data | value: input}
  end
end

defmodule InfoManager do
  def initial_state(queried_info) do
    Map.new(
      queried_info,
      fn mod ->
        empty = struct(mod)
        {InfoProtocol.key(empty), InfoProtocol.initial_value(empty)}
      end
    )
  end

  def query(state, info) do
    state
    |> Map.take(info)
    |> Map.new(fn {k, v} ->
      {k, InfoProtocol.current_value(v)}
    end)
  end

  def receive(state, news) do
    Map.new(state, fn {k, v} ->
      {k, InfoProtocol.updated_value(v, news)}
    end)
  end
end

Usage:

state = InfoManager.initial_state([Info.DayNumber, Info.News])
state = InfoManager.receive(state, "irrelevant_news")
info = InfoManager.query(state, [:day_number])

The only API change is that InfoManager.initial_state expects a list of atoms that can be passed to struct, rather than trying to inflect the appropriate name from a lowercased/underscored atom.

I also added current_value, so InfoManager doesn’t need to know anything about the structs it manipulates besides “they implement InfoProtocol”.

Thank you for each suggestion of yours, I’ll keep them in mind next time I need something similiar.

@al2o3cr I like your solution, but I am a little unconfortable with the amount of boiler plate required to write an individual Info. I think I could do some macro to fill it, but I think I am too much early in the project to use them.

@mpope In the end I chose something very similar to your solution, with the only difference that I keep the cache inside the “state” variable, as I think it is the simplest solution. Right now I am not concerned with performance, I was just wandering what is the idiomatic way to express this kind of computation.

Thank you all for the precious suggestions, as I my elixir is still very basic.