Chapter 6: Functional Programming Paradigm

Introduction to Functional Programming

Key Principles and Concepts of Functional Programming

Functional programming focuses on pure functions, immutability, and higher-order functions. Here’s a simple example in Haskell demonstrating a pure function that doubles a number:

haskell

double :: Int -> Int
double x = x * 2

Another key concept is immutability, where data structures cannot be modified after creation. In Elixir, lists are immutable:

elixir

original_list = [1, 2, 3]
new_list = [4 | original_list]

Higher-order functions take other functions as arguments or return them as results. In Scala, map is a higher-order function:

scala

val numbers = List(1, 2, 3, 4)
val doubled = numbers.map(_ * 2)

Recursion is preferred over loops for iteration. Here’s a factorial function in Haskell:

haskell

factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)

Closures are functions that capture the bindings of free variables. In Python, a closure capturing a variable:

python

def make_multiplier(x):
    def multiplier(n):
        return x * n
    return multiplier

times_three = make_multiplier(3)
print(times_three(10))  # Output: 30

Differences from Procedural and Object-Oriented Programming

Functional programming avoids side effects, whereas procedural and object-oriented programming often use them. A comparison in Python:

Procedural:

python

total = 0

def add_to_total(amount):
    global total
    total += amount

add_to_total(5)

Functional:

python

def add(a, b):
    return a + b

new_total = add(5, 10)

Functional programming uses function composition to build complex operations from simpler ones. In Scala:

scala

def add(x: Int, y: Int): Int = x + y
def multiply(x: Int, y: Int): Int = x * y

val addThenMultiply = (add(1, _)).andThen(multiply(2, _))

In functional programming, data is transformed through pipelines. In Elixir:

elixir

[1, 2, 3, 4]
|> Enum.map(&(&1 * 2))
|> Enum.filter(&(&1 > 4))

Functional programming often emphasizes declarative code, specifying what to do, not how to do it. In Haskell:

haskell

sumOfSquares = sum . map (^2)

Popular Functional Languages

Overview of Functional Languages (e.g., Haskell, Scala, Elixir)

Haskell is a purely functional language. A basic example of list comprehension:

haskell

squares = [x^2 | x <- [1..10]]

Scala combines functional and object-oriented programming. Defining a case class and using it in a functional way:

scala

case class Person(name: String, age: Int)

val people = List(Person("Alice", 25), Person("Bob", 30))
val names = people.map(_.name)

Elixir is a functional language built on the Erlang VM. Using pattern matching:

elixir

defmodule Example do
  def greet({:ok, name}) do
    "Hello, #{name}"
  end
  def greet({:error, reason}) do
    "Error: #{reason}"
  end
end

Example.greet({:ok, "Alice"})

Use Cases and Industry Adoption

Haskell is often used in academia and for high-assurance software. Writing a type-safe configuration parser:

haskell

import Data.Configurator
import Data.Configurator.Types

main = do
  config <- load [Required "app.cfg"]
  name <- require config "name"
  putStrLn ("Hello, " ++ name)

Scala is widely used in data processing and distributed systems. An example with Apache Spark:

scala

val conf = new SparkConf().setAppName("Example")
val sc = new SparkContext(conf)
val data = sc.parallelize(Seq(1, 2, 3, 4))
val result = data.map(_ * 2).collect()

Elixir is popular for building scalable and maintainable systems. A simple Phoenix web application:

elixir

defmodule MyAppWeb.HelloController do
  use MyAppWeb, :controller

  def index(conn, _params) do
    text conn, "Hello, World!"
  end
end

Functional Features in Mainstream Languages

Introduction to Functional Features in Mainstream Languages (e.g., Lambda Functions in Python, LINQ in C#)

Lambda functions provide concise syntax for anonymous functions. In Python:

python

double = lambda x: x * 2
print(double(5))

LINQ enables querying of collections in C#. Querying a list of integers:

csharp

int[] numbers = { 1, 2, 3, 4, 5 };
var evenNumbers = from num in numbers
                  where num % 2 == 0
                  select num;

Java introduced functional programming features in Java 8. Using the Stream API:

java

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> doubled = numbers.stream()
                               .map(n -> n * 2)
                               .collect(Collectors.toList());

In C++, lambda functions were introduced in C++11. Example of a lambda that captures variables:

cpp

int a = 10, b = 20;
auto add = [a, b]() { return a + b; };
std::cout << add() << std::endl;

Ruby supports functional programming with blocks, procs, and lambdas. Using a lambda to filter an array:

ruby

numbers = [1, 2, 3, 4, 5]
even_numbers = numbers.select(&:even?)

Examples and Practical Applications

In Python, using map, filter, and reduce for functional operations:

python

from functools import reduce

numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x**2, numbers)
even = filter(lambda x: x % 2 == 0, squared)
summed = reduce(lambda x, y: x + y, even)

In C#, using Select and Where with LINQ:

csharp

int[] numbers = { 1, 2, 3, 4, 5 };
var squared = numbers.Select(n => n * n);
var even = squared.Where(n => n % 2 == 0);
var sum = even.Sum();

Java streams for processing data:

java

List<String> words = Arrays.asList("hello", "world", "java", "streams");
List<String> upperCaseWords = words.stream()
                                   .map(String::toUpperCase)
                                   .collect(Collectors.toList());

C++ STL algorithms for functional operations:

cpp

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::transform(numbers.begin(), numbers.end(), numbers.begin(), [](int x) { return x * x; });
    for (int n : numbers) {
        std::cout << n << " ";
    }
    return 0;
}

Using Ruby blocks to iterate and transform collections:

ruby

numbers = [1, 2, 3, 4, 5]
squared = numbers.map { |n| n ** 2 }
even = squared.select { |n| n.even? }
sum = even.reduce(:+)

These examples showcase the foundational principles of functional programming, popular languages that embrace the paradigm, and how mainstream languages incorporate functional features for versatile and efficient coding.