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

When we can’t predict the results of a function, the function is impure. But before we can devise a strategy to handle impure functions, we need to know how to identify them. In this lesson, we’ll learn all the differences between *predictable* pure functions and *unpredictable* impure functions. In this course, we’ve seen many examples that contain impure and pure functions, but we didn’t stop to understand their properties. Now, we’ll explore them and understand how to identify them by writing some examples.




# Pure functions are predictable
**Pure functions** always return consistent output when given the same input and never produce effects beyond the function’s scope, making them predictable. For example, write the following function that calculates the total from a given price and tax value:

```Elixir
iex> total = &(&1 * &2/100) 

iex> total.(100, 8)
#Output -> 8.0

iex> total.(100, 8)
#Output -> 8.0

iex> total.(nil, 8) 
#Output -> ** (ArithmeticError) 

iex> total.(nil, 8)
#Output -> ** (ArithmeticError)
```

Try it below:

With a pure function, we can try `total.(100, 8)` a thousand times. We'll always see the same result. If we try `calculate_tax.(nil, 8)`, it always generates an error. Pure functions can result in errors, but the errors are predictable.

Pure functions are very predictable. They’re so predictable that if we have our program call something like `total.(100, 8)`, we can replace the entire function call with `8.0`, and our program will work in the same way. It’s called the **referential transparency** property of pure functions. Now that the definition of pure functions is clear, let’s talk about impure functions.

Understand the differences between pure and impure functions.


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

Pure vs. Impure Functions

Pure functions are predictable