Elements of Functional Programming

Functional Programming (FP) is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. It is a declarative programming paradigm, meaning it focuses on -what- to compute rather than -how- to compute it. Key elements of functional programming include:

1. Pure Functions: These are functions that, given the same input, will always return the same output, and they produce no side effects (i.e., they do not modify any external state, global variables, or input parameters). Pure functions are deterministic and easier to test and debug.

2. Immutability: Data cannot be changed after it's created. Instead of modifying existing data structures, new ones are created with the desired changes. This prevents unexpected side effects and makes parallel processing safer and easier, as there are no shared, mutable states.

3. First-Class and Higher-Order Functions:
- First-Class Functions: Functions are treated like any other variable. They can be assigned to variables, passed as arguments to other functions, and returned as values from functions.
- Higher-Order Functions: These are functions that either take one or more functions as arguments or return a function as their result. Examples include `map`, `filter`, and `reduce` (or `fold`).

4. Referential Transparency: An expression is referentially transparent if it can be replaced with its corresponding value without changing the program's behavior. Pure functions inherently lead to referential transparency, making code easier to reason about and optimize.

5. No Side Effects: A function is said to have a side effect if it modifies some state outside its local environment, interacts with the outside world (like I/O operations), or changes the value of its arguments. Functional programming aims to minimize or isolate side effects to maintain predictability.

6. Function Composition: The process of combining two or more functions to produce a new function or computation. The output of one function becomes the input of another. This allows building complex operations from simpler, reusable components.

7. Declarative Style: Functional programming promotes a declarative style, where you describe -what- you want to achieve rather than specifying -how- to achieve it. This often leads to more concise and readable code compared to imperative programming.

By adhering to these principles, functional programming aims to create more modular, predictable, testable, and maintainable software.

python
 1. Pure Function: 'add_two' takes an input and returns a new value
    without modifying anything outside its scope.
def add_two(x):
    return x + 2

 2. Immutability & Higher-Order Function (map):
    'numbers' list remains unchanged. 'map' returns a new iterator/list.
numbers = [1, 2, 3, 4, 5]

 Using map (a higher-order function) with add_two
 map applies the 'add_two' function to each item in 'numbers'
 without modifying the original 'numbers' list.
increased_numbers = list(map(add_two, numbers))

print(f"Original numbers: {numbers}")  Output: Original numbers: [1, 2, 3, 4, 5]
print(f"Increased numbers: {increased_numbers}")  Output: Increased numbers: [3, 4, 5, 6, 7]

 3. Another Higher-Order Function (filter) & Predicate (pure function)
    'is_even' is a pure function (predicate).
def is_even(num):
    return num % 2 == 0

 filter applies 'is_even' to each item, returning a new iterator/list
 containing only the items for which 'is_even' returned True.
filtered_numbers = list(filter(is_even, increased_numbers))

print(f"Even numbers from increased list: {filtered_numbers}")  Output: Even numbers from increased list: [4, 6]

 4. Function Composition (conceptual example)
    You can chain operations, where the output of one becomes the input of another.
    Let's create a 'multiply_by_three' function.
def multiply_by_three(x):
    return x - 3

 Compose add_two and multiply_by_three
 First add 2, then multiply the result by 3
def add_two_then_multiply_by_three(x):
    return multiply_by_three(add_two(x))

result_composition = add_two_then_multiply_by_three(5)
print(f"Result of composition (add 2 then multiply by 3 for 5): {result_composition}")  Output: Result of composition (add 2 then multiply by 3 for 5): 21 (because (5+2)-3 = 21)

 Demonstrating immutability with dictionary (conceptual, as Python dicts are mutable but FP encourages treating them immutably)
original_user = {'name': 'Alice', 'age': 30}

def update_user_age(user, new_age):
     Creates a new dictionary instead of modifying the original
    return {user, 'age': new_age}

updated_user = update_user_age(original_user, 31)

print(f"Original user: {original_user}")  Output: Original user: {'name': 'Alice', 'age': 30}
print(f"Updated user: {updated_user}")  Output: Updated user: {'name': 'Alice', 'age': 31}