#til Elixir's anonymous function

fn is a keyword that creates an anonymous function.

sum = fn(a,b) ->
  a+b
end

IO.puts sum.(1,2)

Invoke using . (dot) similar to Ruby’s #call. Note the dot is not used for named function calls.

fb = fn
  {0, 0, c} -> "FizzBuzz"
  {0, b, c} -> "Fizz"
  {a, 0, c} -> "Buzz"
  {a, b, c} -> c
end

A single function with multiple implementations depending on the arguments passed. Elixir does not have assignments - yes you heard it right. Instead, it uses pattern matching then it binds the variable to the value. Note each implementation should have the same number of arguments.

IO.puts fb.({0,0,3})
# FizzBuzz
IO.puts fb.({0,2,3})
# Fizz
IO.puts fb.({1,0,3})
# Buzz
IO.puts fb.({1,2,3})
# 3

Since it is just a function, why not define it inside another function.

fizzbuzz = fn(n) ->
  fb = fn
    {0, 0, c} -> "FizzBuzz"
    {0, b, c} -> "Fizz"
    {a, 0, c} -> "Buzz"
    {a, b, c} -> c
  end

  fb.({rem(n,3), rem(n,5), n})
end

IO.puts fizzbuzz.(10)
IO.puts fizzbuzz.(11)
IO.puts fizzbuzz.(12)
IO.puts fizzbuzz.(13)
IO.puts fizzbuzz.(14)
IO.puts fizzbuzz.(15)
IO.puts fizzbuzz.(16)

We now have a baseline FizzBuzz solution with no conditional logic. Note rem(a,b) is an operator that returns the remainder after dividing a by b. The final solution uses the Enum module.

Enum.each(1..100, fn(n) -> IO.puts fizzbuzz.(n) end)

I’ve read the |> pipe operator before, so why not use it. The pipe operator simply takes the result of one expression and passes it as the 1st parameter to the next expression.

(1..100) |> Enum.each(fn(n) -> IO.puts fizzbuzz.(n) end)

#til Elixir's Anonymous Function