How Do Functions Work In Elixir?

In Elixir, functions are defined using the def keyword followed by the function name and its parameters. The function body is enclosed in a block and the result of the function is the value of the last expression in the block. Functions can also have multiple clauses with different patterns to match against different inputs.

Elixir functions are first-class citizens, meaning they can be assigned to variables, passed as arguments to other functions, and returned from other functions. This allows for powerful and flexible programming constructs.

Elixir functions are typically defined within modules, and are called using the module name followed by a dot and the function name. For example, if there is a function named add in a module named Math, it can be called as Math.add(1, 2).

Functions in Elixir can also have default values for parameters, allowing for optional arguments. Additionally, Elixir supports anonymous functions, which are defined using the fn keyword and can be passed as arguments or stored in variables.

Overall, functions in Elixir are a fundamental building block of the language and play a crucial role in defining the behavior of Elixir programs.

How do functions in Elixir handle function arity mismatch?

In Elixir, if a function is called with a different number of arguments than its defined arity (the number of parameters it expects), the Elixir compiler will raise a compile-time warning.

For example, if a function is defined with an arity of 2:

1
2
3
4
5

defmodule Example do
  def add(a, b) do
    a + b
  end
end

And it is called with only 1 argument:

1

Example.add(1)

The compiler will raise a warning such as:

1

warning: example.ex:4: missing argument error

However, the code will still compile and execute. Elixir will simply ignore the extra arguments passed to the function.

How do functions in Elixir handle function currying?

In Elixir, functions do not handle function currying in the traditional sense. Currying is the technique of converting a function that takes multiple arguments into a sequence of functions that each take a single argument.

However, Elixir does support partial function application, which is similar to currying. Partial function application is the process of fixing a number of arguments to a function, producing a new function that takes fewer arguments. This can be achieved using the Kernel.apply/3 function or the & syntax for defining anonymous functions.

Here is an example of partial function application in Elixir:

1
2
3
4

add = fn a, b -> a + b end
add_five = &Kernel.apply(&1, [5])

IO.puts add_five.(2) # Output: 7

In this example, we define a function add that takes two arguments and returns their sum. We then create a new function add_five by partially applying the add function with the argument 5. Now, add_five is a function that takes a single argument and adds 5 to it.

While Elixir does not have built-in support for currying, partial function application can be used to achieve similar results in a functional programming style.

How do functions in Elixir handle error handling using try and rescue blocks?

In Elixir, error handling is typically done using try and rescue blocks. The try block is used to wrap code that might raise an error, while the rescue block is used to handle the error if one occurs.

Here's an example of how error handling with try and rescue blocks works in Elixir:

1
2
3
4
5

try do
  raise "This is an error"
rescue
  RuntimeError -> IO.puts "An error occurred"
end

In this example, the code within the try block raises a RuntimeError by calling the raise function with a custom error message. The rescue block catches the error and handles it by printing a message to the console.

Additionally, you can also specify specific error types to rescue in the rescue block. For example:

1
2
3
4
5
6

try do
  raise "This is an error"
rescue
  RuntimeError -> IO.puts "A RuntimeError occurred"
  _ -> IO.puts "An unknown error occurred"
end

In this case, the rescue block catches any RuntimeError and prints a specific message, while catching any other type of error with the _ wildcard and printing a more generic message.

Overall, try and rescue blocks in Elixir provide a flexible and powerful way to handle errors and gracefully recover from them in your code.