Functional Programming Techniques in Python

# Pure function - predictable, no side effects
def pure_add(x, y):
    return x + y

print(pure_add(2, 3))  # Always returns 5
print(pure_add(2, 3))  # Still returns 5

# Impure function - has side effects
count = 0

def impure_increment():
    global count
    count += 1
    return count

print(impure_increment())  # 1
print(impure_increment())  # 2 (different result!)

# Pure functions are:
# ✓ easier to test
# ✓ easier to debug
# ✓ safer to parallelize
# ✓ more reliable

# Immutable types: int, float, str, tuple, frozenset
# Mutable types: list, dict, set

# FP style - transform, don't mutate
nums = [1, 2, 3, 4, 5]

# Good FP style - create new list
doubled = [x * 2 for x in nums]
print(f"Original: {nums}")
print(f"Doubled: {doubled}")

# Avoid mutation (when following FP)
# nums.append(6)  # modifies original

# Using tuples for immutability
point = (3, 4)
# point[0] = 5  # Error! Tuples are immutable

# Frozen sets
fs = frozenset([1, 2, 3])
# fs.add(4)  # Erro
...

# Higher-order function - takes function as argument
def apply_twice(func, value):
    return func(func(value))

def add_one(x):
    return x + 1

def double(x):
    return x * 2

result1 = apply_twice(add_one, 5)
print(f"Apply add_one twice to 5: {result1}")  # 7

result2 = apply_twice(double, 3)
print(f"Apply double twice to 3: {result2}")   # 12

# Higher-order function - returns a function
def make_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier

times_3 = ma
...

from functools import reduce

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# map() - transform each element
doubled = list(map(lambda x: x * 2, nums))
print(f"Doubled: {doubled}")

# filter() - keep only matching items
evens = list(filter(lambda x: x % 2 == 0, nums))
print(f"Evens: {evens}")

# reduce() - combine into single value
total = reduce(lambda a, b: a + b, nums)
print(f"Sum: {total}")

product = reduce(lambda a, b: a * b, nums)
print(f"Product: {product}")

# Chaining operations
result = lis
...

# Basic lambda syntax
square = lambda x: x * x
print(f"Square of 5: {square(5)}")

# Lambdas with multiple arguments
add = lambda x, y: x + y
print(f"3 + 4 = {add(3, 4)}")

# Lambdas in sorting
users = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Charlie", "age": 35}
]

sorted_by_age = sorted(users, key=lambda u: u["age"])
print("\nSorted by age:")
for user in sorted_by_age:
    print(f"  {user['name']}: {user['age']}")

# Lambdas in functional chains
nums = 
...

# Composition utility
def compose(*funcs):
    def wrapper(x):
        for f in reversed(funcs):
            x = f(x)
        return x
    return wrapper

# Simple functions
double = lambda x: x * 2
increment = lambda x: x + 1
square = lambda x: x * x

# Compose them
f1 = compose(increment, double)
print(f"Double then increment 5: {f1(5)}")  # 11

f2 = compose(square, increment, double)
print(f"Double, increment, square 3: {f2(3)}")  # 49

# String processing pipeline
clean = compose(
    str.st
...

from functools import partial
import operator

# Basic partial application
def power(base, exp):
    return base ** exp

square = partial(power, exp=2)
cube = partial(power, exp=3)

print(f"5² = {square(5)}")
print(f"5³ = {cube(5)}")

# With operators
times_10 = partial(operator.mul, 10)
result = list(map(times_10, [1, 2, 3, 4, 5]))
print(f"\nMultiply by 10: {result}")

# Practical example: logging with context
def log_message(level, message, context=""):
    print(f"[{level}] {message} {context
...

# Generator pipeline for processing data
def numbers(n):
    """Generate numbers"""
    for i in range(n):
        yield i

def only_evens(nums):
    """Filter to only evens"""
    for n in nums:
        if n % 2 == 0:
            yield n

def squared(nums):
    """Square each number"""
    for n in nums:
        yield n ** 2

# Chain generators (lazy evaluation)
pipeline = squared(only_evens(numbers(10)))

print("Processing numbers 0-9:")
for result in pipeline:
    print(f"  {result}")

# File
...

# Manual currying
def curry_add(a):
    def add_b(b):
        def add_c(c):
            return a + b + c
        return add_c
    return add_b

result = curry_add(1)(2)(3)
print(f"Curried add: {result}")

# Generic curry decorator
def curry(func):
    """Transform f(a, b, c) into f(a)(b)(c)"""
    def curried(a):
        return lambda b: lambda c: func(a, b, c)
    return curried

@curry
def multiply(a, b, c):
    return a * b * c

result = multiply(2)(3)(4)
print(f"Curried multiply: {result}")

...

from functools import wraps
import time

# Simple logging decorator
def log_calls(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}({args}, {kwargs})")
        result = func(*args, **kwargs)
        print(f"  → {result}")
        return result
    return wrapper

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

print("Example 1: Logging")
add(3, 5)
add(10, 20)

# Timing decorator
def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
      
...

# Option/Maybe pattern
class Maybe:
    def __init__(self, value):
        self.value = value
    
    def bind(self, func):
        if self.value is None:
            return Maybe(None)
        try:
            return Maybe(func(self.value))
        except:
            return Maybe(None)
    
    def get_or(self, default):
        return self.value if self.value is not None else default

# Safe operations
def safe_divide(x):
    return 100 / x if x != 0 else None

def double(x):
    return x * 
...

from dataclasses import dataclass
from typing import FrozenSet

# Frozen dataclass (immutable)
@dataclass(frozen=True)
class Point:
    x: int
    y: int
    
    def move(self, dx, dy):
        """Returns new Point instead of modifying"""
        return Point(self.x + dx, self.y + dy)

p1 = Point(0, 0)
p2 = p1.move(3, 4)
print(f"Original: {p1}")
print(f"Moved: {p2}")

# p1.x = 10  # Error! Frozen dataclass is immutable

# Frozen dataclass with methods
@dataclass(frozen=True)
class User:
    id:
...

from functools import reduce

# Pure transformation functions
def parse_line(line):
    """Parse CSV-like line"""
    parts = line.strip().split(",")
    return {"name": parts[0], "value": int(parts[1])}

def is_valid(record):
    """Check if record is valid"""
    return record["value"] > 0

def extract_value(record):
    """Extract just the value"""
    return record["value"]

def sum_values(acc, value):
    """Accumulator for reduce"""
    return acc + value

# Sample data
data = """Alice,100
...