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

# Introduction to module behaviors

A contract sets the rules in an agreement between parties and indicates how the parties will benefit. For example, think of a job contract. It has rules for the employee and the employer, and by following those rules, both parties will reap specific benefits. If the rules are broken, though, those benefits aren’t guaranteed.



In Elixir, a **behavior** is a contract between a module and the client code that’s using it. It provides a common interface for a client across multiple modules. It means a client can use multiple modules in the same way since the modules provide the same functions with the same signatures defined in the behavior contract. 

For example, `Mix.Task` is a behavior. When we create a module that follows the `Mix.Task` behavior, we must implement the function `run/1`. If we don’t, Mix will have problems when trying to run our module as a task. It’s very useful to enforce the practice of developers creating consistent code when developing new features in an application.

In this lesson, we’ll learn how to build our own behaviors, create better function signatures with type specifications, and add a new library in our application. In the next lesson, we’ll even learn how to use **Dialyzer** to check if our code has hidden bugs.

# Building the exit with Elixir behavior

Let’s return to our game example. The hero can walk for several rooms. Each room has a list of actions. The player chooses one action, and it will trigger a situation. Each situation can be very different, but it’d be nice if the situation triggers had uniform input and output. Having multiple functions that respect the same behavior permits us to have a central point of execution and handling, avoiding extra conditional code.

For each type of room, we’ll build a module. Inside each module, we’ll have the function that knows what to do when the user chooses an action for that room. The function must accept the hero and the player action as an argument and return the hero with a flag. When the flag is `:exit`, the game is finished; when it’s `:forward`, the hero must keep crawling the dungeon. We’ll use an Elixir behavior feature that will be like a simple contract of how that function should work. Let's create the file `lib/dungeon_crawl/room/trigger.ex` and write the module in it:

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

Creating Module Behaviors

Introduction to module behaviors