I’m designing a pure functional data structure to manage banking accounts, a simplified version of it would be:
defmodule Account do
defstruct balance: 0, limit: -500
def new() do
%Account{}
end
def deposit(%Account{} = account, amount) do
new_account =
%Account{account | balance: account.balance + amount}
{:ok, new_account}
end
def withdraw(%Account{} = account, amount) do
new_balance = account.balance - amount
if new_balance >= account.limit do
new_account =
%Account{account | balance: new_balance}
{:ok, new_account}
else
{:denied, "No funds", account}
end
end
end
My question is about when should I use the response pattern of {:ok, data}
for sucess and {:error, reason, unchanged_data}
for failures.
This sounds like the way to go here on this problem, but if I go with this pattern I lose the feature of do something like this:
account =
Account.new()
|> Account.deposit(%{amount: 5000})
|> Account.deposit(%{amount: 3000})
|> Account.withdraw(%{amount: 1000})
I really like to design modules that could use the pipe operator like this, but how to do this when the module functions can fail?
If I just remove the :ok
from the sucess response would solve the problem, but is this a good pattern?
What you guys think? How can I keep the pipe feature together with a good response check validation?