How to update boolean value of a variable inside if statements?

In Elixir, everything is an expression.

Other than in languages that have mutation, variables are not ‘boxes you put something into’ but rather ‘labels you attach to a value’.

As such you can change what a label points to, but this will not alter the original value (rather ‘you move the label’ you could say).

This means that rather than overriding variables as you attempt to do here, try to return values from your if-statement directly.

For instance:

defmodule MyModule do
  def my_function(a, b) do
    {curr1, curr2} = if(a > b) do
      {false, true}
    else
      {true, false}
    end
    
    curr1 or curr2
  end
end

This is excellent advice. Thank you! One additional thing that I would like to ask is that what if we are using this if condition inside an Enum.map and the curr1 or curr2 part has to come after the Enum.map section. Over here, it won’t recognize curr1 and curr2 now. For example:

defmodule MyModule do
  def my_function(mylist) do
    Enum.map(0..length(mylist), fn(i) ->
    {curr1, curr2} = if(i > i+1) do
      {false, true}
    else
      {true, false}
    end  
    end)
   curr1 or curr2
  end
end

Any help over how we can work around over here?

Elixir is lexically scoped, so variables of outer scopes are accessible to inner scopes (though not changeable as you’ve seen). Anonymous functions, branching (case/if) or blocks like do/end create new scopes. In your case you try to access variables of an inner scope from the outside, which is not possible. If you need values from inside the anonymous function you need to figure out a way to have it returned by the Enum.map or other function call, which executes the anonymous function.

It’s always false (when i is a positive number)

The code is wrong, but it would always be true

Rebinding variables (what happens when you write a = 1 followed by a = 2 later in the same block) is always scoped to the current block and does not “leak” into the surrounding context. That’s why your first example doesn’t work:

def my_function() do
  curr1 = curr2 = true

  if a > b do
    # This _rebinds_ the name "curr1" but only until the "else"
    curr1 = false
  else
    curr2 = false
  end

  # This refers to the original binding, not the one introduced inside the "if" blocks
  curr1 or curr2
end

Same thing for the Enum.map case; each invocation of the anonymous function passed to Enum.map binds curr1 and curr2 and then those bindings are dropped at the end of the function.

Depending on your specific needs, a function like Enum.any? or similar might be a better fit; alternatively, Enum.reduce will do what you’re looking for:

# Ruby version, that uses "leaky" scopes
curr1 = nil
curr2 = nil
some_list.map { |el| curr1, curr2 = something_with(el, curr1, curr2) }
# read the last values stored in curr1 and curr2 here

# Elixir version that makes the shared state between iterations explicit
{curr1, curr2} = Enum.reduce(some_list, {nil, nil}, fn el, {a1, a2} -> something_with(el, a1, a2); end)

Enum.reduce provides the equivalent of an “update” to the accumulated state as the list is traversed.

Thank you! This helped a lot and I was able to make it work using Enum.reduce and Maps.