A function is a unit of code that does a thing. With Elixir being a functional language, functions are a core tenant of the language.

Elixir has both named functions and anonymous functions.

Named Functions

Functions are defined in Elixir with the def keyword.


# Define a named function
def my_function do
  # Contents

# Define a named function that accepts arguments
def another_function(a, b) do
  # Do someting with "a" and "b"

# Define a named function that has default arguments
# default arguments use the double backslash (\\) to define their value
def another_function(a, b \\ 1) do
  # Do someting with "a" and "b"

# Define a private named function
defp my_function do
  # Contents

# Call a named function within a module
another_function("stuff", "things")

# Call a named function from another module
IO.puts("Beam me up Scotty!")

Anonymous Functions

Anonymous functions are like named functions except they don't have a name. An anonymous function can be assigned to a variable and passed around like an integer or a string.


# Anonymous function syntax
fn parameter(s) -> body end
# Define an anonymous function
add = fn a, b -> a + b end

# Call an anonymous function
add.(1, 2)

Multi-Clause Functions

Functions can be overloaded by defining a function with the same name but different number of parameters (arity). This generates a function with a different signature because function signatures are defined by both their name and arity.


# Define multiple functions with the same name, but different parameters
defmodule SomeModule do
  # some_funciton/2
  def some_function(a, b) do
    # Do someting with "a" and "b"

  # some_function/3
  def some_function(a, b, c) do
    # Do someting with "a" and "b" and "c"

  # default clause that is always matched and 
  # returns and error rather than raise an exception.
  def some_function(unknown) do
    {:error, {:unknown_param, unknown}}


  • Functions must be defined inside of a module.
  • Functions can start with a lowercase [a-z] or an underscore _
  • Functions can contain upper/lower case [a-zA-Z] and the _ underscore characters.
  • snake_case is the formatting convention used for function naming.
  • Functions can end with a question mark ? or an exclaimation mark !
  • Functions that end with a question mark ? should return a boolean true or false
  • Functions that end with an exclaimation mark ! may raise a runtime error.
  • Functions are identified by its containing module and both their name and arity. Arity is a fancy word for the number of arguments.
  • Private functions are only accessible from the module they exist in.