Gain insights into Elixir's functional programming fundamentals, explore expressions, modules, conditional statements, recursion, and delve into advanced topics like higher-order functions and application design. Discover Elixir's vibrant community and tooling.

Learn Functional Programming with Elixir by The Pragmatic Programmer_468 x 60 copy.png

elixir.tar.gz

Elixir

Elixir-SPA

Elixir-SPA-cleared

Elixir script

Elixir-SPA-script

Elixir-SPA-copy all

Elixir-SPA-copy all-dungeon

Elixir-test

Elixir-SPA-test

Elixir is a functional programming language that runs in the Erlang VM, a powerful environment to run distributed systems. This course uses Elixir because of its fun syntax, vibrant community, and production-ready tooling. Elixir syntax lets you focus on what’s important while learning functional programming.

Starting from scratch, you will learn the fundamentals of Elixir including expressions, modules, conditional statements, and recursion. Towards the end of the course, you will focus on more advanced material like higher-order functions, how to handle impure functions, and lastly how to design an application using Elixir and functional programming principles.

By the end, you will be able to write basic Elixir programs that follow the functional programming paradigm.

Learn Functional Programming with Elixir

# Higher-order functions
The `each`, `map`, `reduce`, and filter list operations are used in almost all of the programming tasks we do with lists. Thanks to Elixir’s core team, we don’t need to write these higher-order functions every time we start a new Elixir project because they’re available in the `Enum` module. We wrote all these functions to understand how to create higher-order functions. From now on, we’ll use them directly from the `Enum` module.

Now we’ll experiment with more useful higher-order functions from that module, starting with ones we’ve built. Try this in your IEx below:


```Elixir
iex> Enum.each(["dogs", "cats", "flowers"], &(IO.puts String.upcase(&1))) 
#Output -> 
DOGS
CATS
FLOWERS

iex> Enum.map(["dogs", "cats", "flowers"], &String.capitalize/1)
#Output -> ["Dogs", "Cats", "Flowers"]

iex> Enum.reduce([10, 5, 5, 10], 0, &+/2)
#Output -> 30

iex> Enum.filter(["a", "b", "c", "d"], &(&1 > "b"))
#Output ->["c", "d"]
```


The `Enum` functions work like our homemade functions. The `Enum` module has many useful functions; it’s easy to guess what they do from their names. Let’s take a quick look:

```Elixir
iex> Enum.count(["dogs", "cats", "flowers"])
#Output -> 3

iex> Enum.uniq(["a", "a", "b", "b", "b", "c"])
#Output -> ["a", "b", "c"]

iex> Enum.sum([10, 5, 5, 10])
#Output -> 30

iex> Enum.sort(["c", "b", "d", "a"], &<=/2)
#Output -> ["a", "b", "c", "d"]

iex> Enum.sort(["c", "b", "d", "a"], &>=/2)
#Output -> ["d", "c", "b", "a"]

iex> Enum.member?([10, 20, 12], 10)
#Output -> true

iex> Enum.join(["apples", "hot dogs", "flowers"], ", ") 
#Output -> "apples, hot dogs, flowers"
```

The `count/1` function returns the total number of elements, and `uniq/1` returns a new list without duplicate elements. `sum/1 `returns the sum of all numbers in a list, `member?/2` checks if an item exists in a list, and `join/2` combines the list items in one string. The `sort/2` is a higher-order function that accepts a function comparing the elements in a list. The Enum functions work with any data type that respects the *[Enumerable protocol](https://hexdocs.pm/elixir/Enumerable.html)*. Take a look:

```Elixir
iex> upcase = fn {_key, value} -> String.upcase(value) end 

iex> Enum.map(%{name: "willy", last_name: "wonka"}, upcase) 
#Output -> ["WONKA", "WILLY"]
```
The map data type implements the `Enumerable` protocol so we can use it with the `Enum` module functions. On each iteration of a map structure, we have a tuple with two elements: one for the map key and the other for the value. We’ll see more about protocols in Chapter 7, [*Designing Your Elixir Applications*](https://www.educative.io/courses/functional-programming-elixir/using-protocols-to-create-polymorphic-functions).

In the `Enum` module, we also have useful and complex higher-order functions that take two functions in the argument. For example, `Enum.group_by/3` receives a function that applies grouping criteria, and it takes a function that generates the values for each group. Let’s try it with a list that contains medals and the players who earned them. Create the following `medals` variable:

```Elixir
iex> medals = [
%{medal: :gold, player: "Anna"}, %{medal: :silver, player: "Joe"}, %{medal: :gold, player: "Zoe"}, %{medal: :bronze, player: "Anna"}, %{medal: :silver, player: "Anderson"}, %{medal: :silver, player: "Peter"}
]
```

Learn about higher-order functions in Elixir's Enum module.

Getting Started

Introduction to Functional Programming

Working with Variables and Functions

Using Pattern Matching to Control Program Flow

Diving into Recursion

Using Higher-Order Functions

Designing Your Elixir Applications

Handling Impure Functions

Conclusion

Appendices

Using the Enum Module

Higher-order functions