Functional Programming

2.

Foundational Concepts

2.1.

Functions as First-Class Citizens

2.1.1.

Assigning Functions to Variables

2.1.2.

Passing Functions as Arguments

2.1.3.

Returning Functions from Other Functions

2.1.4.

Storing Functions in Data Structures

2.1.5.

Function Equality and Identity

2.2.

2.2.1.

Definition and Characteristics

2.2.2.

The Problem of Side Effects

2.2.3.

2.2.4.

2.2.5.

Input-Output Relationships

2.2.6.

Testing Strategies for Pure Functions

2.3.

Higher-Order Functions

2.3.1.

Definition and Usage

2.3.2.

Common Higher-Order Functions

2.3.2.1.

2.3.2.2.

2.3.2.3.

2.3.2.4.

2.3.2.5.

2.3.2.6.

2.3.2.7.

2.3.2.8.

2.3.3.

Custom Higher-Order Functions

2.3.4.

Function Factories

2.3.5.

Callback Patterns

2.4.

2.4.1.

Immutable Data Structures

2.4.1.1.

2.4.1.2.

2.4.1.3.

2.4.1.4.

2.4.1.5.

2.4.2.

State and Identity

2.4.3.

Advantages of Immutability

2.4.3.1.

2.4.3.2.

Predictable Behavior

2.4.3.3.

Simplified Reasoning

2.4.4.

Implementing Immutability

2.4.4.1.

Copy-on-Write Strategies

2.4.4.2.

Structural Sharing

2.4.4.3.

Persistent Data Structures

2.5.

Expressions over Statements

2.5.1.

The Role of Evaluation

2.5.2.

Expression-Oriented Programming

2.5.3.

Everything Returns a Value

2.5.4.

2.5.4.1.

2.5.4.2.

2.5.4.3.

2.5.4.4.

Null Object Pattern

2.6.

Lambda Calculus

2.6.1.

Syntax and Semantics

2.6.2.

Role in Functional Programming

2.6.3.

Church Encoding

2.6.4.

Alpha Conversion

2.6.5.

2.6.6.

2.7.

Evaluation Strategies

2.7.1.

Eager Evaluation

2.7.1.1.

2.7.1.2.

Performance Characteristics

2.7.2.

Lazy Evaluation

2.7.2.1.

2.7.2.2.

Infinite Data Structures

2.7.2.3.

Performance Trade-offs

2.7.3.

2.7.4.

Implications for Performance and Semantics

Previous

1. Introduction to Functional Programming

Go to top

Next

3. Core Techniques and Patterns