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.
# elixir