Librería Portfolio

Smooth, powerful, and small, Elixir is an excellent language for learning functional programming, and with this hands-on introduction, you'll discover just how powerful Elixir can be. Authors Simon St. Laurent and J. David Eisenberg show you how Elixir combines the robust functional programming of Erlang with an approach that looks more like Ruby, and includes powerful macro features for metaprogramming.

Updated to cover Elixir 1.4, the second edition of this practical book helps you write simple Elixir programs by teaching one skill at a time. Once you pick up pattern matching, process-oriented programming, and other concepts, you'll understand why Elixir makes it easier to build concurrent and resilient programs that scale up and down with ease.

Get comfortable with IEx, Elixir's command line interface
Learn Elixir's basic structures by working with numbers
Discover atoms, pattern matching, and guards: the foundations of your program structure
Delve into the heart of Elixir processing with recursion, strings, lists, and higher-order functions
Create Elixir processes and send messages among them
Store and manipulate structured data with Erlang Term Storage and the Mnesia database
Build resilient applications with the Open Telecom Platform



Chapter 1Getting Comfortable
Installation
Firing It Up
First Steps
Doing Something
Calling Functions
Numbers in Elixir
Working with Variables in the Shell
Chapter 2Functions and Modules
Fun with fn
And the &
Defining Modules
From Module to Free-Floating Function
Splitting Code Across Modules
Combining Functions with the Pipe Operator
Importing Functions
Default Values for Arguments
Documenting Code
Chapter 3Atoms, Tuples, and Pattern Matching
Atoms
Pattern Matching with Atoms
Atomic Booleans
Guards
Underscoring That You Don't Care
Adding Structure: Tuples
Chapter 4Logic and Recursion
Logic Inside of Functions
The Gentlest Side Effect: IO.puts
Simple Recursion
Chapter 5Communicating with Humans
Strings
Multiline Strings
Unicode
Character Lists
String Sigils
Asking Users for Information
Chapter 6Lists
List Basics
Splitting Lists into Heads and Tails
Processing List Content
Creating Lists with Heads and Tails
Mixing Lists and Tuples
Building a List of Lists
Chapter 7Name-Value Pairs
Keyword Lists
Lists of Tuples with Multiple Keys
Hash Dictionaries
From Lists to Maps
From Maps to Structs
Chapter 8Higher-Order Functions and List Comprehensions
Simple Higher-Order Functions
Creating New Lists with Higher-Order Functions
Beyond List Comprehensions
Chapter 9Playing with Processes
The Shell Is a Process
Spawning Processes from Modules
Lightweight Processes
Registering a Process
When Processes Break
Processes Talking Amongst Themselves
Watching Your Processes
Breaking Things and Linking Processes
Chapter 10Exceptions, Errors, and Debugging
Flavors of Errors
Rescuing Code from Runtime Errors as They Happen
Logging Progress and Failure
Tracing Messages
Watching Function Calls
Chapter 11Static Analysis, Typespecs, and Testing
Static Analysis
Typespecs
Writing Unit Tests
Setting Up Tests
Embedding Tests in Documentation
Chapter 12Storing Structured Data
Records: Structured Data Before Structs
Storing Data in Erlang Term Storage
Storing Records in Mnesia
Chapter 13Getting Started with OTP
Creating Services with GenServer
A Simple Supervisor
Packaging an Application with Mix
Chapter 14Using Macros to Extend Elixir
Functions Versus Macros
A Simple Macro
Creating New Logic
Creating Functions Programatically
When (Not) to Use Macros
Chapter 15Using Phoenix
Skeleton Installation
Structuring a Basic Phoenix Application
Presenting a Page
Calculating
Sharing the Gospel of Elixir
Appendix An Elixir Parts Catalog
Shell Commands
Reserved Words
Operators
Guard Components
Common Functions
Datatypes for Documentation and Analysis
Appendix Generating Documentation with ExDoc
Using ExDoc with Mix