Sign In Start Free Trial

Elixir Cookbook

By : Paulo Pereira

4.5 (2)

Elixir Cookbook

4.5 (2)

By: Paulo Pereira

Overview of this book

This book is intended for users with some knowledge of the Elixir language syntax and basic data types/structures. Although this is a cookbook and no sequential reading is required, the book’s structure will allow less advanced users who follow it to be gradually exposed to some of Elixir’s features and concepts specific to functional programming. To get the most out of this book, you need to be well versed with Erlang.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Sections

Conventions

Reader feedback

Customer support

Free Chapter

1. Command Line

1. Command Line

Introduction

Using the terminal to prototype and test ideas

Loading and compiling modules

Getting help and accessing documentation within IEx

Using Erlang from Elixir

Inspecting your system in IEx

Inspecting your system with Observer

Creating a simple application

Managing dependencies

Generating a supervised application

Generating umbrella applications

Managing application configuration

Creating custom Mix tasks

2. Data Types and Structures

2. Data Types and Structures

Understanding immutability

Adding and subtracting lists

Combining tuples into a list

Creating and manipulating keyword lists

Using pattern matching

Pattern matching an HTTPoison response

Creating a key/value store with a map

Mapping and reducing enumerables

Generating lazy (even infinite) sequences

Streaming a file as a resource

3. Strings and Binaries

3. Strings and Binaries

Introduction

Joining strings

Splitting strings

Replacing string codepoints with patterns

Slicing strings with ranges

Using regular expressions

Combining operations with the |> operator

Creating a word list

Determining the word frequency in a text

Reading and writing metadata from MP3 files

4. Modules and Functions

4. Modules and Functions

Introduction

Namespacing modules

Using module attributes as constants

Enforcing behaviors

Documenting modules

Using module directives

Using a module in the scripted mode

Defining functions with default arguments

Using guard clauses and pattern matching in function definitions

5. Processes and Nodes

5. Processes and Nodes

Introduction

Sending messages between processes

Making code run on all available CPUs

Using tasks to perform multiple concurrent computations

Creating a stateful server process (messages with counters)

Using agents as an abstraction around states

Using an ETS table to share the state

Creating named nodes

Connecting nodes

Executing code in a different node

6. OTP – Open Telecom Platform

6. OTP – Open Telecom Platform

Introduction

Implementing a GenServer

Expanding our server

Creating a supervisor

Using Observer to inspect supervisors and processes

Handling errors and managing exceptions

Packaging and releasing an OTP application

Deploying applications and updating a running system

7. Cowboy and Phoenix

7. Cowboy and Phoenix

Introduction

Setting up Cowboy

Serving static files

Implementing a websocket handler

Creating a Phoenix application

Defining routes

Creating a controller

Creating views and templates

Implementing topics

Protecting the Phoenix app with SSL

8. Interactions

8. Interactions

Introduction

Using Redis and Postgres

Using OS commands from within Elixir

Getting Twitter data

A. Installation and Further Reading

A. Installation and Further Reading

Installing Elixir

Installing PostgreSQL

Installing Redis

Some useful links

Index

Index

Customer Reviews

4.5 (2)

5 star

50%

4 star

50%

3 star

0

2 star

0

1 star

0

Generating umbrella applications

The "Erlang way" is to name each self-contained unit of code as an app. Sometimes, an app may be what is referred to as a library in other languages. This is a great way to achieve code reusability and modularity, but sometimes, it is convenient to treat all the apps in a project as a single entity, committing them as a whole to version control, to allow running tests, and so on. Think of an umbrella application as a container used to hold one or more applications and to make them behave as a single application.

This recipe shows how to create umbrella applications with Mix.

How to do it…

Generate an umbrella application to contain other applications:
```
mix new --umbrella container
```
What happens next is shown in the following screenshot:

Generate application_one and application_two inside the container/apps directory:

> cd container/apps
> mix new application_one
> mix new application_two

Modify the tests in the applications as follows:
- Change the test in container/apps/application_one/application_one_test.exs like this:
```
test "the truth on application one" do
  IO.puts "Running Application One tests"
  assert 1 + 1 == 2
end
```
- Change the test in container/apps/application_two/application_two_test.exs as shown here:
```
test "the truth on application two" do
  IO.puts "Running Application Two tests"
  assert 2 - 1 == 1
end
```
Run the tests in all applications (inside the container directory):
```
> mix test
```
The result of these tests is shown here:
Now run the tests individually. Firstly, run them for application_one as follows:
```
> cd apps/application_one
> mix test
```
The outcome of these tests is shown in the following screenshot:
For application_two , run them like this:
```
> cd ../application_two
> mix test
```
The result of these tests is shown in this screenshot:

How it works…

By generating this structure of the application with subprojects under the apps directory, Elixir makes dependency management, compilation, and testing easier. It is possible to perform these tasks at the umbrella application level, affecting all the subprojects, or at each subproject level, allowing a high level of granularity.

See also

The Elixir Getting Started guide on dependencies and umbrella projects is available at http://elixir-lang.org/getting_started/mix_otp/7.html. It says the following:
Remember that the runtime and the Elixir ecosystem already provide the concept of applications. As such, we expect you to frequently break your code into applications that can be organized logically, even within a single project. However, if you push every application as a separate project to a Git repository, your projects can become very hard to maintain, because now you will have to spend a lot of time managing those Git repositories rather than writing your code.
For this reason, Mix supports "umbrella projects." Umbrella projects allow you to create one project that hosts many applications and push all of them to a single Git repository. That is exactly the style we are going to explore in the next sections.

Search

Your notes and bookmarks