内容简介

As a developer, you’ve probably heard that functional programming techniques help manage the complexities of today’s real-world, concurrent systems. You’re also investigating designs that help you maximize uptime and manage security.

This book is your guide to Elixir, a modern, functional, and concurrent programming language. Because Elixir runs on the Erlang VM, and uses the underlying Erlang/OTP architecture, it benefits from almost 20 years of research into high performance, highly parallel, and seriously robust applications. Elixir brings a lot that’s new: a modern, Ruby-like, extendable syntax, compile and runtime evaluation, a hygienic macro system, and more.

But, just as importantly, Elixir brings a sense of enjoyment to parallel, functional programming. Your applications become fun to work with, and the language encourages you to experiment.

Part 1 covers the basics of writing sequential Elixir programs. We’ll look at the language, the tools, and the conventions.

Part 2 uses these skills to start writing concurrent code—applications that use all the cores on your machine, or all the machines on your network! And we do it both with and without OTP.

And Part 3 looks at the more advanced features of the language, from DSLs and code generation to extending the syntax.

By the end of this book, you’ll understand Elixir, and know how to apply it to solve your complex, modern problems.

作品目录

Contents and Extracts

This book is currently in beta, so the contents and extracts will change as the book is developed.

Preface/Introduction

Conventional Programming

Pattern Matching

Assignment: I do not think it means what you think it means

More Complex Matches

Ignoring a Value With _

Variables Bind Once (Per Match)

Another way of looking at the equals sign

Immutability

You Already Have (Some) Immutable Data

Immutable Data Is Known Data

Performance Implications of Immutability

Coding With Immutable Data

Elixir Basics excerpt

Value Types

System Types

Collection Types

Names, Source Files, Conventions, Operators, and So On

End of the Basics

Anonymous Functions

Functions and Pattern Matching

One Function, Multiple Bodies

Functions Can Return Functions

Passing Functions as Arguments

Functions Are The Core

Modules and Named Functions

The Body of the Function is a Block

Function Calls and Pattern Matching

Guard Clauses

Default Parameters

|> — The Amazing Pipe Operator

Modules

Module Attributes

Module Names: Elixir, Erlang, and Atoms

Lists and Recursion

Heads and Tails

Using Head and Tail to Process a List

Using Head and Tail to Build a List

Creation of a Map Function

Keeping Track of Values During Recursion

More Complex List Patterns

List Comprehensions

Using the Built-in Libraries

Strings and Binaries

String Literals

The Name “strings”

Single Quoted Strings—Lists of Character Codes

Binaries

Double Quoted Strings are Binaries

Binaries and Pattern Matching

Records

Defining Records: defrecord

Records and Pattern Matching

Advanced Records

Control Flow

if and unless

cond

case

Raising Exceptions

Designing With Exceptions

What we’ve seen

Organizing a Project

The Project: Fetch Issues from Github

Task: Use Mix to Create our New Project

Transformation: Parse the Command Line

Step: Write Some Basic Tests

Transformation: Fetch from Github

Task: Use External Libraries

Transformation: Convert Response

Transformation: Take First N Items

Transformation: Format the Table

Task: Make a command line executable (#sec.cmd-line}

Task: Test The Comments

Task: Create Project Documentation

What We’ve Just Seen

Concurrent Programming

Working With Multiple Processes

A Simple Process

Process Overhead

When Processes Die

Parallel Map—The Hello World of Erlang

A Fibonacci Server

What’s Next

Nodes—The Key To Distributing Services excerpt

Naming Nodes

Naming Your Processes

I/O, PIDs, and Nodes

What’s Next

OTP: Servers

Some OTP Definitions

An OTP Server

GenServer Callbacks

Naming A Process

Tidying Up The Interface

What We Learned

OTP: Supervisors

Supervisors And Workers

Supervisors Are The Heart of Reliability

OTP: Applications

Application: I do not think it means what you think it means

The Application Specification File

Turning Our Sequence Program into an OTP Application

Tell Mix About The Application

Create the application OTP entry point

Hot Code Swapping

OTP is Big. Unbelievably Big

Web Applications with Dynamo

More Advanced Elixir

Protocols

Use and Using

Macros