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 type specifications

**Type specifications** are notations that say what our functions expect and return. In some languages, the compiler uses the type specifications to optimize the code and check its correctness. Elixir is a dynamic language, and the compiler doesn’t use type specifications to optimize our code. However, the Dialyzer tool uses type specifications to do a static check to verify if type usage is correct, catching some hidden bugs. Type specifications are also good for generating documentation, clarifying what is expected in our code. We’ll use type specifications to improve the `DungeonCrawl.Room.Trigger.run/2` contract, and we’ll add them to document the expected structures in the function’s arguments and return.

# Adding type specifications to the game


The `DungeonCrawl.Room.Trigger.run/2` needs a character and a room action. We need to create the character and room types. Then we can specify the `run/2` function’s arguments. Let’s define the character type in `lib/dungeon_crawl/character.ex`, adding the following code:



@type t :: %DungeonCrawl.Character{ 
    name: String.t,
    description: String.t, 
    hit_points: non_neg_integer, 
    max_hit_points: non_neg_integer, 
    attack_description: String.t, 
    damage_range: Range.t
}


We used the `@type` directive to start the type definition. That type has the name t, and the code after the `::` is the type definition. We’re saying the type is a `DungeonCrawl.Character` struct composed of attributes with their specified types. We can reference some types with simple names, like `integer`. We can reference types like `String`  by accessing the `t` function from their modules. It’s a common convention in Elixir to define the struct type with `t`. With the type specification, it’s much clearer what is expected in each attribute of the struct. The next step is to define the type specification of the room action:

Learn how to use type specifications to improve code.

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

Adding Type Specifications

Introduction to type specifications

Adding type specifications to the game