Hey guys,

I was trying Protocols and I saw a possibility I’ve never saw before, the use of defprotocol with defstruct.
I haven’t gone too much further on the implications, but the code below works fine.

defprotocol Foo do
  defstruct [:bar]
  def bar(foo)    
end

defimpl Foo, for: Foo do
  def bar(foo), do: foo.bar
end

defprotocol Zoo do
  defstruct [:foo, :some]
end

defimpl Foo, for: Zoo do
  def bar(zoo), do: zoo.foo.bar
end

With the code above we can notice that the Foo protocol will also behave like a module, i.e., the functions can have a body.

This “pattern” could be useful for data inheritance/composition where we have an is relationship, like for instance when we have a case where Person “is a” User and Employee “is a” Person, and both Employee and Person structs would “inherit” (sorry the OO term) User’s attributes.

So, by using Protocols we could do:

defprotocol User do
  defstruct [:username, :password]

  def get_username(user)
end

defprotocol Person do
  defstruct [:user, :name, :age, :birth_date]

  def to_str(person)
end

# Here I could've also modeled Employee using defprotocol too
defmodule Employee do
  defstruct [:person, :wage, :department]
end

defimpl User, for: Person do
  def get_username(person), do: person.user.username
end

defimpl User, for: Employee do
  def get_username(employee), do: employee.person.user.username
end

defimpl Person, for: Employee do
  def to_str(employee) do
    "#{employee.person.name} #{employee.person.age} @ #{employee.department}"
  end
end

To be used like this:

iex(21)> employee = %Employee{person: %Person{user: %User{username: "gio"}, name: "Giorgio", age: "30+"}, department: "IT"}

iex(22)> User.get_username employee
"gio"
iex(23)> Person.to_str employee
"Giorgio 30+ @ IT"

My question is if Protocols were designed to be used this way too?