Reusing function variables in a `when` conditional

Hi @tbk the code you show looks valid to me. Can you show the actual error you get?

I am using the Exercism practice platform which attempts to test the code

 ** (FunctionClauseError) no function clause matching in RomanNumerals.iteraterefs/5
...
Attempted function clauses (showing 1 out of 1):

         def iteraterefs(divisor, number, table, out, i) when number >= divisor

In the above number >= divisor has red text highlighting. The function is being called in a Enum.each like this:

    Enum.each(refs, fn(divisor) -> 
      iteraterefs(divisor, number, table, out, i)
      i = i + 1
    end)

And is defined as:

  def iteraterefs(divisor, number, table, out, i) when number >= divisor do
    number = number - divisor
    out = out <> elem(table, i)
  end

FunctionClauseError is what I’d expect from iteraterefs if it was called with number < divisor. You likely need to define it for those inputs as well to pass Exercism’s tests.

General note: this isn’t going to do what you want. i = i + 1 rebinds the name i inside the do / end block but that value doesn’t escape or even make it to the next iteration.

Same thing for out = out <> elem(table, i) inside iteraterefs; the name out is bound to a new name but then the scope ends immediately.

My recommendation would be to forget completely about Enum.each for a little while; it is almost never the right solution in Elixir.

Isn’t the solution to variable scope to pin the variables?

Pinning variables only performs a match, it doesn’t create a binding. You aren’t actually doing any pinning in your example so I’m not quite sure how you are picturing it would work but, for example, this doesn’t work:

foo = 1
^foo = 1 + 1 # This is a match error

^foo = 1 + 1 gets expanded to 1 = 2 which, of course, does not match.

If you want to accumulate a variable the most basic ways to are either recursion or Enum.reduce.

I was imagining something like foo = ^foo + 1 which would reference the variable in the outer scope. Or is foo destroyed when it leave scope?

Yes, it is. It’s a bit confusing terminology-wise since we do say we can re-bind variables but really it might be easier to think of as you are only reusing the names. It doesn’t affect any outer scopes.

The pin operator can only be used on the lefthand side of a match. The only reason it exists is due to being able to reuse variable names. In Erlang, this isn’t a problem since you are not allow to re-use them.

# Elixir
foo = 1
^foo = 1 # match
foo = 2 # foo is now 2!

% Erlang
Foo = 1.
Foo = 1. % match
Foo = 2. % match error!

It was my reading of those examples from the docs to interpret the ^ as something like a “type/value checked deference”.

Forging ahead, ignoring what I was told about the scope of out, I’ve restructured my code in a recursive manner.

  def iteraterefs(number, refs, table, out, i) when number > 0 do
    reducenumber(elem(refs, i), number, elem(table, i), out)
    iteraterefs(number, refs, table, out, i + 1)
  end

  def reducenumber(divisor, number, symbol, out) when number >= divisor do
    number = number - divisor
    out = out <> symbol
  end

The compiler parses iteraterefs and produces:

     ** (ArgumentError) errors were found at the given arguments:

       * 2nd argument: not a tuple

Is this an interaction with the elem(refs, i) call? Here is the refs I constructed by hand:

refs = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]

Sorry, my example may have been a bit confusing. The out = out <> symbol isn’t doing anything other than assigning out <> symbol to out then throwing it away. You can rebind variable from outer scope.

foo = "bar"
if true do
  foo = "bazzzz"
end
foo # This is still "bar"

You can reference an outer scope, but you can’t re-bind.

This I understand from your explanation I was just attempting to address getting the function iteraterefs to compile with inputs. I’ll worry about variable assignment after that.