Using defprotocol with defstruct for "data inheritance"

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)    

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

defprotocol Zoo do
  defstruct [:foo, :some]

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

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)

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

  def to_str(person)

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

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

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

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

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
iex(23)> Person.to_str employee
"Giorgio 30+ @ IT"

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

From the guide:

dispatching on a protocol is available to any data type that has implemented the protocol

That is not true for your protocol. Only data types that have a specific shape would work.