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?
