Binding vars inside `cond`?

[silverdr]

Guys, first thank you for so many responses and edifying ideas! It’s really enlightening to read through them. I respond to some here

@LostKobrakai

def compare(a, c, x) do
  with :ok <- a_non_expensive_function_comparison(x),
       :ok <- an_expensive_function_comparison(a, c) do
    no_errors()
  end
end
[…]

The one thing I am not so happy about in this approach is that it “disperses” the flow. If one looks at else if/elsif/elif etc. in other languages it is clear what the steps are. Similar can be achieved in Elixir with cond and with but the limitations are more strict here. I’d prefer to keep this one-look flow overview intact.

@al2o3cr

How do you feel about the process dictionary?

iWow!™ - that looks geeky enough to elevate my heartbeat rate and it allows wrapping only the expensive call(s). Looks like a good “solution candidate” to me!

@JohnnyCurran

If your method calls are able to return ok/error tuples, you can side-step the anti-pattern issue

Right, but no, they are heterogenous and returning whatever pleases them. As for the anti-pattern in some particular cases, I wouldn’t care that much (something I expressed here) yet here this doesn’t apply, and adding annotations or whatever to make it work smells from half a mile away Wrapping all things and normalising returns would work well but this we know.

@csadewa

you could implement caching based on function and argument (via one of in memory ETS based cache)

True. Although it looks like a bit of an overkill for the case at hand, doesn’t it?

@stefanchrobot

I think this could work:

with true <- x != a_non_expensive_function() || cond0_error(),
     b = an_expensive_function_returning_b(),
     true <- a != b || cond1_error(),
     true <- c < an_expensive_function_returning_b() || cond2_error() do
  no_errors()
end

O! That’s an interesting “abuse” of the with construct. For the current case it should in fact work as none of the errors evaluates to true. OTOH as mentioned already it can be brittle in the longer run. And you yourself mentioned you wouldn’t prefer it over nested constructs. Thanks for the enlightenment regardless!