Functional Programming

Functional Programming (FP) is a declarative programming paradigm where programs are constructed by applying and composing functions. It treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.

Key Concepts

• Pure Functions: A function is pure if its return value is the same for the same arguments (it's deterministic) and it has no observable side effects (e.g., no network requests, mutation of external state, or console logging). This makes functions predictable and easy to test in isolation.

• Immutability: Data is immutable, meaning it cannot be changed after it's created. Instead of modifying an existing data structure, a functional approach creates a new data structure with the updated values. This eliminates bugs caused by unexpected changes to shared state, which is particularly useful in concurrent applications.

• First-Class and Higher-Order Functions: Functions are treated as first-class citizens, meaning they can be stored in variables, passed as arguments to other functions, and returned as values from other functions. A function that takes another function as an argument or returns a function is called a higher-order function. Examples include map, filter, and reduce.

• Avoiding Side Effects: The core logic of a program is separated from actions that interact with the outside world (like I/O operations). This separation makes the core logic easier to reason about and maintain.

Example (JavaScript)

Here's how to double the numbers in an array using an imperative vs. a functional approach.

Imperative (How to do it)

const numbers = [1, 2, 3, 4];
const doubled = [];
for (let i = 0; i < numbers.length; i++) {
  // Mutates the 'doubled' array and uses a loop counter
  doubled.push(numbers[i] * 2);
}
// doubled is [2, 4, 6, 8]

Functional (What to do)

const numbers = [1, 2, 3, 4];
const double = (x) => x * 2; // A pure function

// 'map' is a higher-order function that returns a new array
const doubled = numbers.map(double);
// doubled is [2, 4, 6, 8]

Usage

FP is widely used in data processing frameworks (Apache Spark), front-end development (React, Elm), and for building highly concurrent and fault-tolerant systems (Erlang/Elixir).