Books & Videos

Table of Contents

  1. Chapter 1 Getting Comfortable

    1. Installation

    2. Firing It Up

    3. First Steps

    4. Doing Something

    5. Calling Functions

    6. Numbers in Elixir

    7. Working with Variables in the Shell

  2. Chapter 2 Functions and Modules

    1. Fun with fn

    2. And the &

    3. Defining Modules

    4. From Module to Free-Floating Function

    5. Splitting Code Across Modules

    6. Combining Functions with the Pipe Operator

    7. Importing Functions

    8. Default Values for Arguments

    9. Documenting Code

    10. Documenting Functions

    11. Documenting Modules

  3. Chapter 3 Atoms, Tuples, and Pattern Matching

    1. Atoms

    2. Pattern Matching with Atoms

    3. Atomic Booleans

    4. Guards

    5. Underscoring That You Don’t Care

    6. Adding Structure: Tuples

  4. Chapter 4 Logic and Recursion

    1. Logic Inside of Functions

    2. The Gentlest Side Effect: IO.puts

    3. Simple Recursion

  5. Chapter 5 Communicating with Humans

    1. Strings

    2. Multiline Strings

    3. Unicode

    4. Character Lists

    5. String Sigils

    6. Asking Users for Information

  6. Chapter 6 Lists

    1. List Basics

    2. Splitting Lists into Heads and Tails

    3. Processing List Content

    4. Creating Lists with Heads and Tails

    5. Mixing Lists and Tuples

    6. Building a List of Lists

  7. Chapter 7 Name-Value Pairs

    1. Keyword Lists

    2. Lists of Tuples with Multiple Keys

    3. Hash Dictionaries

    4. From Lists to Maps

    5. From Maps to Structs

  8. Chapter 8 Higher-Order Functions and List Comprehensions

    1. Simple Higher-Order Functions

    2. Creating New Lists with Higher-Order Functions

    3. Beyond List Comprehensions

  9. Chapter 9 Playing with Processes

    1. The Shell Is a Process

    2. Spawning Processes from Modules

    3. Lightweight Processes

    4. Registering a Process

    5. When Processes Break

    6. Processes Talking Amongst Themselves

    7. Watching Your Processes

    8. Breaking Things and Linking Processes

  10. Chapter 10 Exceptions, Errors, and Debugging

    1. Flavors of Errors

    2. Rescuing Code from Runtime Errors as They Happen

    3. Logging Progress and Failure

    4. Tracing Messages

    5. Watching Function Calls

    6. Writing Unit Tests

  11. Chapter 11 Storing Structured Data

    1. Records: Structured Data Before structs

    2. Storing Data in Erlang Term Storage

    3. Storing Records in Mnesia

  12. Chapter 12 Getting Started with OTP

    1. Creating Services with gen_server

    2. A Simple Supervisor

    3. Packaging an Application with Mix

  13. Chapter 13 Using Macros to Extend Elixir

    1. Functions versus Macros

    2. A Simple Macro

    3. Creating New Logic

    4. Creating Functions Programatically

    5. When (Not) to Use Macros

    6. Sharing the Gospel of Elixir

  14. Appendix An Elixir Parts Catalog

    1. Shell Commands

    2. Reserved Words

    3. Operators

    4. Guard Components

    5. Common Functions

    6. Datatypes for Documentation and Analysis

  15. Appendix Generating Documentation with ExDoc

    1. Using ExDoc with mix