small medium large xlarge

Learn Functional Programming with Elixir: New Foundations for a New World

by

Cover image for Learn Functional Programming with Elixir

Learn Functional Programming with Elixir

New Foundations for a New World

by

Elixir’s straightforward syntax and this guided tour give you a clean, simple path to learn modern functional programming techniques. No previous functional programming experience required! This book walks you through the right concepts at the right pace, as you explore immutable values and explicit data transformation, functions, modules, recursive functions, pattern matching, high-order functions, polymorphism, and failure handling, all while avoiding side effects. Don’t board the Elixir train with an imperative mindset! To get the most out of functional languages, you need to think functionally. This book will get you there.

Choose Your Format(s)

  • $21.95 In Stock
    • Beta: What do I get?

  • Ebooks are DRM free.

  • Ebook delivery options.

  • The Paper Book will ship on 2018-01-10 (roughly).

About this Title

Skill-meter-1-4
Pages: 200 (est)
Published: 2018-01-10
Release: B4.0 (2017-11-07)
ISBN: 978-1-68050-245-9

Functional programming offers useful techniques for building maintainable and scalable software that solves today’s difficult problems. The demand for software written in this way is increasing—you don’t want to miss out. In this book, you’ll not only learn Elixir and its features, you’ll also learn the mindset required to program functionally. Elixir’s clean syntax is excellent for exploring the critical skills of using functions and concurrency.

Start with the basic techniques of the functional way: working with immutable data, transforming data in discrete steps, and avoiding side effects. Next, take a deep look at values, expressions, functions, and modules. Then extend your programming with pattern matching and flow control with case, if, cond, and functions. Use recursive functions to create iterations. Work with data types such as lists, tuples, and maps. Improve code reusability and readability with Elixir’s most common high-order functions. Explore how to use lazy computation with streams, design your data, and take advantage of polymorphism with protocols. Combine functions and handle failures in a maintainable way using Elixir features and libraries.

Learn techniques that matter to make code that lives harmoniously with the language.

What You Need

You’ll need a computer and Elixir 1.4 or newer version installed. No previous functional programming or Elixir experience is required. Some experience with any programming language is recommended.

Contents & Extracts

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

  • Introduction
    • Is This Book for You?
    • What’s in This Book?
    • Using Elixir
    • Online Resources
  • Thinking Functionally
    • Why Functional?
    • Working with Immutable Data
    • Building Programs with Functions
    • Declaring Code
    • Wrapping Up
  • Working with Variables and Functions
    • Representing Values
    • Executing Code and Generating a Result
    • Binding Values in Variables
    • Creating Anonymous Functions excerpt
    • Giving Functions Names
    • Wrapping Up
  • Use Pattern Matching to Control the Program Flow
    • Making Two Things Match
    • Unpacking Values from Various Data Types
    • Control Flow with Functions
    • Expanding the Control with Guard Clauses
    • Elixir Control Flow Structures
    • Wrapping Up
  • Dive into Recursion
    • Surrounded by Boundaries
    • Conquering Recursion excerpt
    • Tail Call Optimization
    • Functions Without Borders
    • Using Recursion with Anonymous Functions
    • Wrapping Up
  • Using Higher-Order Functions
    • Creating Higher-Order Functions for Lists excerpt
    • Use the Enum
    • Use List Comprehensions
    • Pipelining Your Functions
    • Be Lazy
    • Wrapping Up
  • Design Your Elixir Applications
    • Starting Your Project with Mix
    • Designing Entities with Structs
    • Using Protocols to Create Polymorphic Functions
    • Creating Module Behaviours
    • Wrapping Up
  • Handle Impure Functions
    • Pure vs. Impure Functions
    • Controlling the Flow of Impure Functions
    • Trying, Rescuing, and Catching
    • Handling with the Error Monad
    • Using with
    • Wrapping Up

Author

Ulisses Almeida is a software consultant at Plataformatec, the company that created Elixir. He works on crafting applications, coaching beginner developers, and advising customers on best practices to build robust and maintainable systems.