Elixir

Elixir version 1.14 introduced the powerful debugging tool dbg/2. It not only prints the passed value, returning it simultaneously, but also outlines the code and location. Here’s an example:

The function IO.inspect(item, opts \\ []) is a staple in Elixir debugging. Although it’s less feature-rich than dbg/2, its usage remains widespread, given its history and straightforward application. You can inject IO.inspect/2 into your code at any point, printing the value of an expression to your console - perfect for verifying a variable’s value or a function call’s result.

For example:

Finally, the IEx helper function i/1 offers useful insights about any data type or structure. Launch an IEx session with iex in your terminal, and then call i() with any term to obtain information about it.

Here’s an example:

This output elucidates that "Hello, world!" is a 13-byte BitString and provides further details like the string’s raw representation and the protocols it implements.

In Elixir, the term "arity" refers to the number of arguments that a function accepts. Functions are identified by both their name and their arity, expressed as name/arity.

The arity concept is essential because it allows us to define multiple functions with the same name but different arities within a single module. Each of these is considered a distinct function due to its unique argument count.

Let’s demonstrate this with a slightly more complex example:

In this example, we’ve defined three versions of the greet function, each with a different arity.

Sometimes, we want to hide certain functions within a module, making them inaccessible from outside. Elixir supports this through private functions, which we declare using the defp keyword:

Private functions help us hide implementation details and reduce the exposed interface of a module, leading to cleaner and more maintainable code.

As your projects become more complex, it’s crucial to structure your code into a clear and manageable form. In Elixir, you can achieve this by using hierarchical module names. Hierarchical modules are defined by attaching sub-module names to a parent module using a . delimiter.

Here’s a new example with a Fruit Shop:

The . syntax offers a neat shortcut for defining nested modules. Here’s how you can create the same hierarchy using nested module definitions:

Both methods achieve the same result. Your choice between these two depends on your project’s structure and your coding style preference.

The import directive in Elixir provides a way to access public functions from other modules without needing to write out their fully qualified names. This can make your code cleaner and easier to read.

Consider the following FruitShop.Apples module:

By importing this module, you can call its functions directly, without having to prefix them with the module’s name:

Here, importing FruitShop.Apples lets you call price_per_kg/0 directly, eliminating the need to use the FruitShop.Apples. prefix.

While importing a module grants you access to all its public functions, there might be times when you want to import only specific functions from a module. Elixir allows you to do this using a selective import.

For instance, suppose the FruitShop.Apples module also had a quantity_in_stock/0 function. But if you only needed price_per_kg/0 in your current context, you could import just that function like so:

Here, import FruitShop.Apples, only: [price_per_kg: 0] means that only the price_per_kg/0 function from FruitShop.Apples is available for direct calling. This can help reduce naming conflicts and makes it clear which functions are being used from the imported module.

An alternative to only is except, which lets you import all functions except the ones specified.

The alias directive offers a convenient way to assign a shorter, alternative name to a module. This can improve both readability and maintainability of your code by reducing verbosity when accessing the module’s functions.

Take a look at the FruitShop.Apples module:

To make calling this module’s functions less verbose, you can use the alias directive to assign it a shorter name:

In the code above, we’ve created an alias for FruitShop.Apples as Apples.

For a quicker and more direct way, you can simply use alias FruitShop.Apples. Elixir will automatically infer the alias from the last part of the module name, in this case Apples:

In this example, the alias FruitShop.Apples directive lets you call functions from FruitShop.Apples using the shortened name Apples. This can significantly improve readability when working with modules that have long or complex names.

Elixir’s use keyword is a cornerstone of metaprogramming in Elixir. It is a powerful tool that helps keep our code DRY (Don’t Repeat Yourself) by allowing us to perform certain actions defined in another module within the current module.

Metaprogramming is a technique that helps us write code that generates or modifies other code. In the context of Elixir, we can think of the use keyword as a way to inject code from one module into another. This is accomplished through the use of the using macro in the module that is being used.

Let’s illustrate this with a more comprehensive example involving a Discount module and two fruit modules, Apples and Bananas:

In these examples, both the FruitShop.Apples and FruitShop.Bananas modules use the Discount module. The use keyword triggers the using macro in the Discount module, which in turn injects the apply_discount/2 function definition into the FruitShop.Apples and FruitShop.Bananas modules. Therefore, we can call apply_discount/2 directly on either of these modules:

In these cases, we’ve applied a 20% discount to the price of apples (which was 10), and the result is 8. Similarly, we’ve applied a 15% discount to the price of bananas (which was 5), and the result is 4.25.

By leveraging the power of the use keyword and metaprogramming, we’ve written a versatile Discount module that can be used across multiple fruit modules to apply discounts to their prices.

An anonymous function, as the name suggests, is a function without a name. These are throwaway functions that you define right where you need them.

Anonymous functions are defined using the fn keyword, like so:

Anonymous functions can also take parameters:

if, unless, and else are coding classics to create conditional branches which are used in most programming languages. These expressions evaluate to either true or false and execute the associated code blocks.

Two styles of syntax can be used for these expressions: multi-line and single-line.

The case construct in Elixir provides a powerful way to pattern match complex data structures and execute code based on the matching pattern. For many Elixir porgrammers it is the go-to construct for control flow.

A case expression evaluates an expression, and compares the result to each pattern specified in the clauses. When a match is found, the associated block of code is executed.

In the above example, num is evaluated and its value is compared with each pattern. The pattern 2 matches the value of num, so "Two" is printed.

Pattern matching in case is not limited to simple values. You can also pattern match on more complex structures like tuples, lists, or maps.

In this example, the case statement matches on the structure and content of the tuple.

Remember, like if and unless, case is an expression, meaning it returns a value which can be assigned to a variable or used in another expression.

In this example, we use a case expression to evaluate num and assign the corresponding string to the result variable. The variable result is then printed using IO.puts/1. The case expression returns "Other", because num does not match 1 or 2, and "Other" is assigned to result.

cond is another control structure in Elixir that checks for the truthiness of multiple conditions. It is like a collection of multiple if/2 expressions. It evaluates each condition in turn, from top to bottom, and once it encounters a condition that evaluates to true, it executes the associated block of code and ignores the rest.

Here’s an example:

In this example, cond checks each condition in order. When it finds a truthy condition (num < 20), it executes the associated block of code and skips the rest.

cond is especially useful when you have multiple conditions and don’t want to write nested if statements.

One of the unique characteristics of control structures in Elixir is their ability to return a value, which can be assigned to a variable. This is possible because these expressions always return a value.

Here’s an example of assigning the result of an if expression to a variable:

This approach can be extended to other control structures such as unless, case, and even custom defined ones:

The last expression executed within the block will be the returned value of the control structure. If the condition does not pass and there is no else clause, the expression returns nil`.

Integers are whole numbers that can be positive, negative or zero. In Elixir, you can use integers without any limits, as long as you have enough memory in your machine.^[1]

Here is an example of integers in Elixir:

Integers can also be represented in binary, octal, and hexadecimal:

Additionally, Elixir supports basic arithmetic operations with integers:

Floats are numbers that have a decimal point. They are represented in Elixir using 64-bit double-precision.

Here’s how you can represent float numbers in Elixir:

Floats in Elixir must be at least 1 digit long, and they can have an optional exponent part. Here’s an example:

Keep in mind that float number precision can be a little imprecise due to the way they are stored in memory.

Remember that in Elixir, as in other languages, when you perform arithmetic with both integers and floats, the result will be a float to maintain precision.

The use of floor division (div) and modulo operation (rem) can return integer values:

Atoms in Elixir are constants that are represented by their name. They’re similar to symbols in other languages and start with a :.

They are extensively used to label or categorize values. For example, when a function might fail, it often returns a tuple tagged with an atom such as {:ok, value} or {:error, message}.

While atoms can be written in snake_case or CamelCase, snake_case is commonly used within the Elixir community. Ensure your atoms are descriptive and indicative of their purpose for code readability.

Booleans are a data type in Elixir used to represent truthiness and falsiness. They come in two flavors: true and false.

Interestingly, in Elixir, booleans are represented as atoms under the hood. Specifically, true and false are equivalent to the atoms :true and :false, respectively. This means you can use :true and :false as if they were true and false. But please don’t. It’s generally better to use true and false when dealing with booleans, as it makes the code clearer and easier to understand.

Tuples in Elixir are a collection of elements enclosed in curly braces {}. They can hold multiple elements of different types. Tuples are stored contiguously in memory, making data access operations quick. However, modifications (like inserting or deleting elements) can be slow because they require creating a new tuple to preserve immutability.

Here’s how tuples are represented:

You can quickly access an element of a tuple by using the elem/2 function:

On the other hand, lists, enclosed in brackets [], are implemented as linked lists, storing each element’s value and a reference to the next element. This structure makes adding elements to the start of the list fast. However, accessing individual elements or determining the list’s length is a linear operation, meaning it can take longer as the list size grows.

Here’s how you can work with lists:

List concatenation and subtraction can be done using the ++ and -- operators:

Keyword lists serve as a staple data structure in Elixir, taking the form of lists of tuples which act as key-value pairs, with atoms acting as keys.

Maps are data structures that store key-value pairs. So they are similar to keyword lists, but with some important differences:

Maps are created using the %{} syntax.

Maps are flexible, allowing any data type to serve as both keys and values:

A struct is a map variant that includes compile-time checks and default values. The defstruct construct is used to define a struct:

Structs ensure that only defined fields can be accessed:

In Elixir, type conversions are explicitly invoked by built-in functions. Here are some of the most commonly used functions to convert between different types:

Remember, type conversion in Elixir is explicit and must be invoked through these built-in functions. This design choice, while requiring a bit more typing, can help prevent bugs related to unexpected type conversions.

Arithmetic operators in Elixir allow you to perform basic mathematical calculations. These operators work with numbers and support integer as well as floating-point arithmetic.

Here are the most popular arithmetic operators:

These operators follow standard mathematical precedence rules. If you want to ensure a specific order of operations, use parentheses to make your intentions clear:

Elixir’s arithmetic operators are not just for integers and floats; they can also operate on other data types, such as complex numbers and matrices, provided the appropriate libraries are installed. However, the focus here is on their use with numbers.

Comparison operators in Elixir are used to compare two values. They evaluate to either true or false. These operators play a crucial role in controlling program flow through conditions.

Here are the primary comparison operators:

These operators are typically used in conditional expressions such as those found in if, unless, and cond statements.

It’s important to note that Elixir provides strict comparison operators as well (=== and !==). These are identical to == and != respectively, but additionally distinguish between integers and floats.

Boolean operators help to control logical flow within your program. They perform operations on boolean values and return a boolean result (true or false). The primary boolean operators include and, or, not, and xor.

In addition to the boolean operators and, or, and not, Elixir provides &&, ||, and ! as equivalent short-circuit operators. Short-circuit evaluation, also known as minimal evaluation, is a method of evaluation in which the second argument is executed or evaluated only if the first argument does not suffice to determine the value of the expression.

However, these operators handle non-boolean values differently than their counterparts, which is important to understand to avoid unexpected behavior in your Elixir programs.

In Elixir, the <> operator takes two strings and merges them together, forming a new string. This process is commonly known as "string concatenation." Here’s a simple example:

In the above example, "Hello" and " world" are two separate strings. The <> operator combines them into one string: "Hello world".

In practice, the <> operator is extensively used when there’s a need to dynamically construct a string. It allows parts of the string to be variables that can change depending on the program’s context:

In the example above, greeting and name are variables holding different string values. Using the <> operator, we can concatenate these variables with another string (", ") to create the desired output.

It’s important to note that the <> operator only works with strings. Attempting to concatenate a non-string data type without first converting it to a string will result in an error:

To avoid such errors, ensure all operands of the <> operator are strings. For example, you can use the Integer.to_string/1 function to convert an integer to a string:

The interpolation operator in Elixir, represented as #{}, is a powerful tool used for inserting values within a string. It allows for dynamic expression of values within a string without the need for explicit concatenation. Here’s a simple example:

In the example above, the variable name is interpolated into the string. The resulting string is "Hello, Alice".

String interpolation in Elixir can handle more complex expressions, not just variables. This includes arithmetic operations, function calls, and more:

In the above code, the expressions inside the interpolation operator #{} are evaluated, and their results are automatically converted into strings and inserted in the appropriate place.

Another powerful aspect of string interpolation in Elixir is that it’s not restricted to strings. It can handle any data type that can be meaningfully converted into a string representation, including integers, floats, atoms, lists, and even tuples:

In the above example, the tuple is automatically converted to its string representation and inserted into the string.

Remember, the expressions inside the interpolation operator #{} must be valid Elixir expressions.

The pipe operator |> is an effective tool in enhancing the readability of your code. Referred to as syntactic sugar, it directs the output from the expression to its left as the first argument into the function on its right. It thus allows for a clean and streamlined way to chain multiple functions together.

It is easier than it sounds. The following code examples explain it.

Consider a case where you wish to reverse a string with String.reverse/1 and subsequently capitalize it using String.capitalize/1. Traditionally, you might go about it as follows:

Although String.capitalize(String.reverse("house")) is technically correct, it can be a bit difficult to read. This is where the pipe operator |> comes in handy:

Moreover, the pipe operator can be seamlessly chained for multiple operations:

Employing the pipe operator, the code becomes more legible, easier to understand, and more maintainable. The benefits of this operator are particularly noticeable in multi-line source code where each transformation is clearly outlined:

This presentation enhances clarity and readability of the code, allowing for better understanding and maintenance.

In various programming languages, the equals sign (=) signifies assignment. For example, x = 5 generally reads as "Let x be equal to 5." Elixir, however, assigns a slightly different role to the equals sign.

In Elixir, = acts as the _match operator. Trying to match the right side of the expression with its left side. When we say x = 5 in Elixir, we are essentially telling the language, "Match x to the value 5." If x is unbound or has no assigned value, Elixir will bind x to 5, making it behave similarly to an assignment operator. But if x already holds a value, Elixir will attempt to rebind it. Older versions of Elixir did throw an error in this case, but this behavior was changed for a better user experience.

Elixir’s pattern matching becomes even more robust with more complex data types like tuples or lists:

In the above snippet, Elixir matches variables a, b, and c to their respective values in the right-side tuple. Thus a equals :hello, b equals "world", and c equals 42.

While it might seem similar to destructuring in JavaScript or other languages, remember that Elixir aims to match instead of simply assigning. If no match is found, Elixir throws an error:

In the second command, a two-element pattern cannot match a three-element tuple, thus resulting in a MatchError.

To summarize, pattern matching in Elixir verifies whether a certain pattern matches your data. If it does, Elixir assigns values to variables based on that pattern.

Pattern matching is pervasive in Elixir. It is used with functions too:

Pattern matching extends to various data structures in Elixir, including lists, maps, strings, and even function clauses. Let’s see how this works.

Sometimes you want to pattern match something but you don’t care about the value. By using the _ wildcard, either standalone or as a prefix to a variable name, you signal to Elixir that there’s no requirement for a binding to a particular variable. Here are two examples:

The range operator (..) in Elixir introduces a convenient way of defining sequences of successive integers. This section will explore the range operator, demonstrating its various uses from simple range definitions to utilization in functions for processing sequences.

In Elixir, a range is created by two integers separated by the .. operator. This sequence includes both the start and end points. For example, 1..5 creates a range of integers from 1 to 5 inclusive. 5..1 does the same but in reverse order.

Ranges in Elixir are considered as enumerables, which means they can be used with the Enum module to iterate over the sequence of numbers. This capability makes the range operator a versatile tool in various situations involving sequences of numbers.

In the code above, the first command creates a range from 1 to 5. The second command converts the range into a list using the Enum.to_list/1 function.

The range operator can also be used in combination with functions:

In this example, the Enum.map function is used to square each number in the range 1..5, resulting in a new list [1, 4, 9, 16, 25].

Elixir also allows you to define the step (increment) between successive numbers in a range using the // operator:

In this example, 1..11//3 creates a range from 1 to 11 with a step of 3, resulting in the list [1, 4, 7, 10].

The Capture operator, denoted as &, is a unique feature in Elixir that enables the creation of anonymous functions, often in a more succinct and readable way than the traditional fn → end syntax.

The Capture operator is often used to create quick, inline functions. Here’s a simple example:

In the above example, &(&1 + &2) creates an anonymous function that adds two arguments together. The placeholders &1 and &2 refer to the first and second arguments, respectively. The function is then assigned to the variable add, and it can be invoked with add.(1, 2).

The Capture operator isn’t just for simple functions. It can be used with more complex expressions and even function calls:

In the above example, &(&1 * 2) creates an anonymous function that doubles its argument.

You can also use the Capture operator to reference named functions from modules. For example, to reference the length function from the List module:

In the example above, &length/1 captures the length function from the which takes one argument (/1). This function is then assigned to the variable len.

The Cons operator, represented by the pipe character (|), is a core tool in Elixir used to construct and manipulate lists.

In Elixir, lists are fundamentally built as singly linked lists. That means each element in the list holds its value and also the remainder of the list. These individual pieces are referred to as the "head" and the "tail" of the list. The Cons operator is used to combine a head and a tail into a list.

Here is a simple example:

In this example, the expression [1 | [2 | [3 | []]]] constructs a list with the elements 1, 2, and 3. The last list in the chain is an empty list [].

One common usage of the Cons operator is in pattern matching to destructure a list into its head and tail:

In the example above, [head | tail] = [1, 2, 3] splits the list [1, 2, 3] into the head (the first element, 1) and the tail (the remainder of the list, [2, 3]).

This operator is particularly useful when working with recursive functions that need to operate on each element of a list.

While the Cons operator can be used to construct lists, it should be noted that the resulting data structure is only properly recognized as a list if the tail is a list or an empty list. For example:

In this case, since "World" is not a list, Elixir does not treat the entire structure as a regular list.

The Enum module contains functions for mapping, filtering, grouping, sorting, reducing, and other operations. They are the building blocks for manipulating and transforming data collections in a functional and declarative style, enhancing code readability and maintainability.

Consider this example of using Enum to multiply each element in a list by 2:

The Enum.map function takes two arguments: the enumerable (list in this case) and a transformation function for each element.

For further enhancement, Elixir’s pipe operator (|>) can be used with Enum functions for cleaner and more readable code. Here’s an example:

This statement takes a list, multiplies each element by 2 using Enum.map, and then filters out the odd numbers using Enum.filter. The use of the pipe operator makes the code flow naturally and easier to read.

Enum offers a ton of useful functions. All are listed at the official Enum documentation. Here are some of the most commonly used functions to give you an idea of what’s available.

The Stream module contains functions similar to the Enum module for mapping, filtering, grouping, sorting, reducing, and other operations. However, the key difference is that Stream operations are lazy. This means they only compute results when necessary, potentially saving a lot of resources when dealing with large data sets or I/O operations.

Consider this example of using Stream to multiply each element in a list by 2:

You might notice that the output is not a list but a Stream. To retrieve the final result, you will need to convert the stream back into a list:

The Stream module can be used with Elixir’s pipe operator (|>) to create a sequence of transformations. The transformations only get executed when the stream is converted into a list or another enumerable.

This is how you would use Stream to multiply each element by 3 and then filter out odd numbers:

Stream offers a lot of useful functions, similar to Enum. All are listed at the official Stream documentation. Here are some of the most commonly used functions to give you an idea of what’s available.

Think about Enum and Stream as two different chefs in a kitchen who are asked to prepare a large meal.

The Enum Chef (Eager Chef):

The Enum chef is eager to get the job done. He tries to cook everything at once. He gets every ingredient, every pot and pan, and starts cooking immediately. This is great if you’re not cooking a lot of food, because everything gets done fast.

But what if the meal or the number of meals is huge? Well, then the Enum chef might run into trouble. His kitchen (or our computer’s memory) might not have enough room for all the food he’s trying to cook at once. He might get overwhelmed because he’s trying to do too much at once.

The Stream Chef (Lazy Chef):

The Stream chef, on the other hand, is more laid-back. He doesn’t start cooking until it’s absolutely necessary. He prepares each dish one at a time, using only the ingredients and cookware needed for each dish. Once a dish is ready, he moves on to the next one.

If the meal is huge, the Stream chef handles it better because he only works on one dish at a time, which means he doesn’t need a lot of room in his kitchen. He’s more efficient with large meals because he can handle them piece by piece.

Comparing the Chefs:

So, when you’re choosing between Enum and Stream in your Elixir code, think about the size of your "meal" (your data), and pick the chef that suits your needs best.

The ~s and ~S sigils in Elixir are used for creating strings.

Let’s look at some examples of using the ~s sigil:

The ~S (uppercase) sigil also creates a string, but does not support interpolation:

~r is the sigil used to represent a [regular expression](https://en.wikipedia.org/wiki/Regular_expression):

As you can see, the ~r sigil allows you to easily create regular expressions in Elixir. It checks if the given string contains the regular expression pattern.

Modifiers are supported to change the behavior of the regular expressions. Two examples:

Here is an example of using the i modifier:

For a complete list of modifiers, have a look at the Regex module documentation.

The ~w sigil in Elixir helps to create a list of words without the need for quotes around each word. You start with ~w(, then put your words separated by spaces, and finish with ).

Here is an example of how it is used:

As you can see, it turns the words separated by spaces into a list of strings.

Elixir provides several date / time structs which all have their own sigils. These include the ~D sigil for dates, ~T for times, ~N for naive date-times, and ~U for UTC date-times.

You can find more information about timezones and DateTime at https://hexdocs.pm/elixir/DateTime.html

Let’s imagine we want to create a countdown. Here’s a simple recursive function that achieves this:

The countdown function keeps calling itself, each time reducing the initial number by one, until it reaches 1, at which point it stops, thus preventing infinite recursion.

Here’s another example where we calculate the sum of a list of integers using recursion:

You can use recursion to transform every element of a list. Let’s assume we want to double the value of every element of a list:

Unless you are doing this every day, you will get to problems where you know that recursion is a good solution, but you just can’t think of a good recursion for it. That is normal. Don’t worry.

I used to say that https://www.google.com and https://stackoverflow.com were your friends. They still are but ChatGPT and Github Copilot have made our lives as programmers to much easier. Ask them. No embarrassment!

During this book, we will work with recursions. So you’ll get a better feeling for it.