Is that easier than %Currency{denomination: "HKD", amount: amount}?
I think the flaw with @lessless’s plan honesty is making a struct per denomination.
benwilson512
Author of Craft GraphQL APIs in Elixir with Absinthe
dimitarvp
lessless
Guys, just for the clarity - this is not the code I’m writing for the production system.
I’m just following the Money example in the TDD by Example book.
The reason why I asked about generic structure is that I saw how useful similar concepts are in Rust and wondered to which extend we can do such thing in Elixir.
Thanks for the replies everyone! 
1
yurko
Another option is something like this in the generic module (would be Currency):
@base_map [
%{
key: "for-db",
module: EuroOrSomething,
name: "For UI"
},
...
]
and then among others
@modules Enum.reduce(@base_map, [], &[&1.module | &2])
with that you’d have @modules compiled which you can use for such “generics”. The function head that uses it would look like
def func(%{__struct__: module} = struct, params) when module in @modules
0
dimitarvp
If it’s for educational purposes only, I’d do this:
defmodule Money do
defstruct [:currency, :amount]
def work_with_francs(%{currency: "FRF", amount: amount}) do
end
def work_with_dollars(%{currency: "USD", amount: amount}) do
end
end
No need for protocols, normal pattern-matching will get you a long way. Additionally, those functions will work not only with the struct but with any map that has the currency and amount keys.
0
jmnsf
Did you find a solution for this? I’ve the same issue where I have many structs that all implement the same protocol and would like a catch all to pattern match on them.
0
lucaong
The solution in the case exposed here was probably to not use different structs for different currencies, but rather one struct with a field for the currency, as @benwilson512 and @dimitarvp noted. That makes it easy to pattern match.
Elixir protocols and pattern matching are both very powerful features, but they work fundamentally differently than the type system and dispatching in, say, Rust.
What is your specific case @jmnsf?
1
jmnsf
I have several Ops (sum, subtract, multiply, add, reverse, etc.) who all implement the protocol Calculable. I also have other, fundamentally different things that implement the protocol Calculable, for example an AverageWeeklyTemperature module. One might make the case of putting all ops in the same module (lets call it Op) and pattern matching on the type, but we’d be hard-pressed to mix those with an API call to a weather service.
I wish to write a function that accepts calculables that matches the argument as one would a struct.
I’m beginning to suspect this isn’t possible though?
0
lucaong
Not in the way you would in a language with classical inheritance.
The kind of dispatching offered by Elixir is usually more flexible than inheritance though. You can define an implementation of the protocol for each separate type (it’s up to you how to best split those types), you can even define a fallback implementation for Any, and you can even derive a protocol implementation. The protocol implementation can be defined by the module implementing the protocol, or “centralized” in a place for multiple different modules.
In all those cases though, it takes thinking about types in a different way than in an inheritance-based language.
0
jmnsf
Not really inheritance; an addition operation can’t inherit from a weather service. If you want to think in OOP terms this is more closely related to implementing an interface (and what else is a protocol?).
I want to be able to say, “this function takes an argument that implements protocol (interface) X”. I don’t care about its type per se, but what it does.
If we can’t represent that, I’m having trouble distinguishing protocols from classic duck-typing with nicer error messages.
0