Protocol @fallback_to_any true not working as expected: making methods optional


I want to have a protocol with 3 methods with 2 optional having the following logic:

defprotocol MyRepo.Render do
  @fallback_to_any true
  def to_string(data)
  def to_index_string(data)
  def to_show_string(data)

# some custom implementations

defimpl MyRepo.Render, for: Any do
  def to_index_string(data), do: MyRepo.Render.to_string(data)
  def to_show_string(data), do: MyRepo.Render.to_string(data)
  def to_string(data), do: MyRepo.Render.to_index_string(data) || "#{inspect data}"

So that I can have for some data structures:

  defimpl MyApp.Render, for: __MODULE__ do
    def to_index_string(data) do
      "get something"

    def to_show_string(booklet_1) do
      "get something else"

And for others:

  defimpl MyApp.Render, for: __MODULE__ do
    def to_string(data) do
      "get something general"

It seems like for modules with no def impl is present, it works as expected, but when I define either to_index_string and to_show_string or to_string, the compiler complains that the other methods are missing:

** (UndefinedFunctionError) function MyRepo.Render.MyApp.MyDataStruct.to_show_string/1 is undefined or private, but the behaviour MyRepo.Render expects it to be present. Did you mean one of:

      * to_string/1

    (vae) MyRepo.Render.MyApp.MyDataStruct.to_show_string(%MyApp.MyDataStruct{})

How can I achieve what I want?


You can’t.

A protocol always requires you to implement all associated functions. There are no optionals.

Fallback to any is an all or nothing. Either you have implemented the protocol for a given type or it will use Anys implementation.

Thanks @NobbZ for getting back!

Wow, this feels like a limitation, doesn’t it?

Ain’t there any solution so I can circumvent my problem? Like using something else than defprotocol?

1 Like

I never hit that limitation, but perhaps @OvermindDL1 library protocol_ex can help you?

I never actually looked at it, but I know he developed it because he found the original protocols quite limiting.

You can do this explicitly with relative ease by just defdelegateing the functions you don’t want to implement to the Any implementation. EG: defdelegate to_index_string, to: MyRepo.Render.Any.

Yep mine can do it. ProtocolEx supports not just implementation on specific types but even specific matchspecs so you could match even on specific values if you want (with a full priority system), along with features of being able to inline the implementations into a single module if you need absolute speed, supports optional callbacks, fallback callbacks, a testing structure, etc… And of course all of the extra stuff is optional.

But yeah, if all you need is ‘just’ an optional kind of thing, defdelegate is easy enough to use at each site, which can be wrapped up in a use with override and so forth perhaps?

1 Like