Python Functional Programming

pip install functools itertools operator collections

pip install functools itertools operator collections

"""
🔧 IMPERATIVE STYLE: Step-by-step instructions
Focus on HOW to do something
"""

def sum_squares_of_evens_imperative(numbers):
    """Calculate sum of squares of even numbers - imperative way"""
    total = 0  # Mutable state

    for num in numbers:  # Step-by-step iteration
        if num % 2 == 0:  # Conditional check
            square = num * num  # Calculate square
            total += square  # Modify state

    return total

# Example usage
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = sum_squares_of_evens_imperative(numbers)
print(f"Imperative result: {result}")  # 220

# Step by step execution:
# 1. Initialize total = 0
# 2. Check 1: odd, skip
# 3. Check 2: even, total = 0 + 4 = 4
# 4. Check 3: odd, skip
# 5. Check 4: even, total = 4 + 16 = 20
# 6. ... and so on

"""
🔧 IMPERATIVE STYLE: Step-by-step instructions
Focus on HOW to do something
"""

def sum_squares_of_evens_imperative(numbers):
    """Calculate sum of squares of even numbers - imperative way"""
    total = 0  # Mutable state

    for num in numbers:  # Step-by-step iteration
        if num % 2 == 0:  # Conditional check
            square = num * num  # Calculate square
            total += square  # Modify state

    return total

# Example usage
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = sum_squares_of_evens_imperative(numbers)
print(f"Imperative result: {result}")  # 220

# Step by step execution:
# 1. Initialize total = 0
# 2. Check 1: odd, skip
# 3. Check 2: even, total = 0 + 4 = 4
# 4. Check 3: odd, skip
# 5. Check 4: even, total = 4 + 16 = 20
# 6. ... and so on

"""
🧮 FUNCTIONAL STYLE: Express what you want
Focus on WHAT to compute
"""

from functools import reduce

def is_even(n):
    """Pure function: check if number is even"""
    return n % 2 == 0

def square(n):
    """Pure function: calculate square"""
    return n * n

def add(x, y):
    """Pure function: add two numbers"""
    return x + y

def sum_squares_of_evens_functional(numbers):
    """Calculate sum of squares of even numbers - functional way"""
    return reduce(add,                    # Sum all values
                  map(square,             # Square each value
                      filter(is_even,     # Keep only even numbers
                             numbers)))   # From input numbers

# Alternative using built-in sum (more Pythonic)
def sum_squares_of_evens_pythonic(numbers):
    """Pythonic functional approach"""
    return sum(n**2 for n in numbers if n % 2 == 0)

# Example usage
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result1 = sum_squares_of_evens_functional(numbers)
result2 = sum_squares_of_evens_pythonic(numbers)
print(f"Functional result: {result1}")  # 220
print(f"Pythonic result: {result2}")    # 220

# Data flow visualization:
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#     ↓ filter(is_even)
# [2, 4, 6, 8, 10]
#     ↓ map(square)
# [4, 16, 36, 64, 100]
#     ↓ reduce(add)
# 220

"""
🧮 FUNCTIONAL STYLE: Express what you want
Focus on WHAT to compute
"""

from functools import reduce

def is_even(n):
    """Pure function: check if number is even"""
    return n % 2 == 0

def square(n):
    """Pure function: calculate square"""
    return n * n

def add(x, y):
    """Pure function: add two numbers"""
    return x + y

def sum_squares_of_evens_functional(numbers):
    """Calculate sum of squares of even numbers - functional way"""
    return reduce(add,                    # Sum all values
                  map(square,             # Square each value
                      filter(is_even,     # Keep only even numbers
                             numbers)))   # From input numbers

# Alternative using built-in sum (more Pythonic)
def sum_squares_of_evens_pythonic(numbers):
    """Pythonic functional approach"""
    return sum(n**2 for n in numbers if n % 2 == 0)

# Example usage
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result1 = sum_squares_of_evens_functional(numbers)
result2 = sum_squares_of_evens_pythonic(numbers)
print(f"Functional result: {result1}")  # 220
print(f"Pythonic result: {result2}")    # 220

# Data flow visualization:
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#     ↓ filter(is_even)
# [2, 4, 6, 8, 10]
#     ↓ map(square)
# [4, 16, 36, 64, 100]
#     ↓ reduce(add)
# 220

"""
🔬 INTERACTIVE DEMO: See functional programming in action
Try modifying the functions to see different transformations
"""

def demonstrate_fp_pipeline():
    """Interactive demonstration of functional programming concepts"""

    # Sample data
    data = [1, -2, 3, -4, 5, -6, 7, -8, 9, -10]

    print("🔍 FUNCTIONAL PROGRAMMING PIPELINE DEMO")
    print("=" * 50)
    print(f"Original data: {data}")

    # Step 1: Filter (keep only positive numbers)
    def is_positive(x):
        return x > 0

    step1 = list(filter(is_positive, data))
    print(f"After filter(is_positive): {step1}")

    # Step 2: Map (square each number)
    def square(x):
        return x * x

    step2 = list(map(square, step1))
    print(f"After map(square): {step2}")

    # Step 3: Reduce (sum all numbers)
    from functools import reduce

    def add(x, y):
        return x + y

    step3 = reduce(add, step2)
    print(f"After reduce(add): {step3}")

    print("\n🔗 CHAINED OPERATIONS:")
    # All in one expression
    result = reduce(add, 
                   map(square, 
                       filter(is_positive, data)))
    print(f"Chained result: {result}")

    # Using Python's built-in sum (more readable)
    pythonic_result = sum(x**2 for x in data if x > 0)
    print(f"Pythonic result: {pythonic_result}")

    print("\n🧪 TRY DIFFERENT TRANSFORMATIONS:")

    # Try 1: Negative numbers only, cubed
    negative_cubes = [x**3 for x in data if x < 0]
    print(f"Negative cubes: {negative_cubes}")

    # Try 2: Absolute values, doubled
    abs_doubled = [abs(x) * 2 for x in data]
    print(f"Absolute doubled: {abs_doubled}")

    # Try 3: Even numbers, halved
    even_halved = [x / 2 for x in data if x % 2 == 0]
    print(f"Even halved: {even_halved}")

# Run the demonstration
demonstrate_fp_pipeline()

"""
🔬 INTERACTIVE DEMO: See functional programming in action
Try modifying the functions to see different transformations
"""

def demonstrate_fp_pipeline():
    """Interactive demonstration of functional programming concepts"""

    # Sample data
    data = [1, -2, 3, -4, 5, -6, 7, -8, 9, -10]

    print("🔍 FUNCTIONAL PROGRAMMING PIPELINE DEMO")
    print("=" * 50)
    print(f"Original data: {data}")

    # Step 1: Filter (keep only positive numbers)
    def is_positive(x):
        return x > 0

    step1 = list(filter(is_positive, data))
    print(f"After filter(is_positive): {step1}")

    # Step 2: Map (square each number)
    def square(x):
        return x * x

    step2 = list(map(square, step1))
    print(f"After map(square): {step2}")

    # Step 3: Reduce (sum all numbers)
    from functools import reduce

    def add(x, y):
        return x + y

    step3 = reduce(add, step2)
    print(f"After reduce(add): {step3}")

    print("\n🔗 CHAINED OPERATIONS:")
    # All in one expression
    result = reduce(add, 
                   map(square, 
                       filter(is_positive, data)))
    print(f"Chained result: {result}")

    # Using Python's built-in sum (more readable)
    pythonic_result = sum(x**2 for x in data if x > 0)
    print(f"Pythonic result: {pythonic_result}")

    print("\n🧪 TRY DIFFERENT TRANSFORMATIONS:")

    # Try 1: Negative numbers only, cubed
    negative_cubes = [x**3 for x in data if x < 0]
    print(f"Negative cubes: {negative_cubes}")

    # Try 2: Absolute values, doubled
    abs_doubled = [abs(x) * 2 for x in data]
    print(f"Absolute doubled: {abs_doubled}")

    # Try 3: Even numbers, halved
    even_halved = [x / 2 for x in data if x % 2 == 0]
    print(f"Even halved: {even_halved}")

# Run the demonstration
demonstrate_fp_pipeline()

"""
🛠️ FUNCTIONAL PROGRAMMING ENVIRONMENT SETUP
Essential imports and utilities for functional programming in Python
"""

# Core functional programming imports
from functools import reduce, partial, singledispatch, lru_cache, wraps
from operator import add, mul, sub, truediv, mod, pow, and_, or_, not_
from itertools import (
    chain, combinations, permutations, product,
    groupby, accumulate, compress, cycle, repeat
)
from collections import namedtuple, defaultdict, Counter
from typing import Callable, Iterator, Iterable, Any, Optional, Union

# For advanced examples
import time
import threading
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
from dataclasses import dataclass
from abc import ABC, abstractmethod

print("✅ Functional Programming environment ready!")
print("📖 All imports successful - ready to explore FP concepts")

"""
🛠️ FUNCTIONAL PROGRAMMING ENVIRONMENT SETUP
Essential imports and utilities for functional programming in Python
"""

# Core functional programming imports
from functools import reduce, partial, singledispatch, lru_cache, wraps
from operator import add, mul, sub, truediv, mod, pow, and_, or_, not_
from itertools import (
    chain, combinations, permutations, product,
    groupby, accumulate, compress, cycle, repeat
)
from collections import namedtuple, defaultdict, Counter
from typing import Callable, Iterator, Iterable, Any, Optional, Union

# For advanced examples
import time
import threading
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
from dataclasses import dataclass
from abc import ABC, abstractmethod

print("✅ Functional Programming environment ready!")
print("📖 All imports successful - ready to explore FP concepts")

"""
🧪 ENVIRONMENT TEST SUITE
Verify your setup is working correctly
"""

def test_functional_features():
    """Test core functional programming features"""

    print("🔍 Testing functional programming setup...")

    # Test 1: Higher-order functions
    try:
        numbers = [1, 2, 3, 4, 5]
        squared = list(map(lambda x: x**2, numbers))
        evens = list(filter(lambda x: x % 2 == 0, numbers))
        total = reduce(add, numbers)
        print("✅ map, filter, reduce working")
    except Exception as e:
        print(f"❌ Basic functions failed: {e}")
        return False

    # Test 2: Operator module
    try:
        result = reduce(mul, [1, 2, 3, 4])
        print("✅ operator module working")
    except Exception as e:
        print(f"❌ Operator module failed: {e}")
        return False

    # Test 3: itertools
    try:
        combinations_result = list(combinations([1, 2, 3], 2))
        chain_result = list(chain([1, 2], [3, 4]))
        print("✅ itertools working")
    except Exception as e:
        print(f"❌ itertools failed: {e}")
        return False

    # Test 4: Decorators and closures
    try:
        @lru_cache(maxsize=128)
        def fibonacci(n):
            if n <= 1:
                return n
            return fibonacci(n-1) + fibonacci(n-2)

        result = fibonacci(10)
        print("✅ Decorators and memoization working")
    except Exception as e:
        print(f"❌ Decorators failed: {e}")
        return False

    print("🎉 All tests passed! Environment is ready for functional programming.")
    return True

# Run the test
test_functional_features()

"""
🧪 ENVIRONMENT TEST SUITE
Verify your setup is working correctly
"""

def test_functional_features():
    """Test core functional programming features"""

    print("🔍 Testing functional programming setup...")

    # Test 1: Higher-order functions
    try:
        numbers = [1, 2, 3, 4, 5]
        squared = list(map(lambda x: x**2, numbers))
        evens = list(filter(lambda x: x % 2 == 0, numbers))
        total = reduce(add, numbers)
        print("✅ map, filter, reduce working")
    except Exception as e:
        print(f"❌ Basic functions failed: {e}")
        return False

    # Test 2: Operator module
    try:
        result = reduce(mul, [1, 2, 3, 4])
        print("✅ operator module working")
    except Exception as e:
        print(f"❌ Operator module failed: {e}")
        return False

    # Test 3: itertools
    try:
        combinations_result = list(combinations([1, 2, 3], 2))
        chain_result = list(chain([1, 2], [3, 4]))
        print("✅ itertools working")
    except Exception as e:
        print(f"❌ itertools failed: {e}")
        return False

    # Test 4: Decorators and closures
    try:
        @lru_cache(maxsize=128)
        def fibonacci(n):
            if n <= 1:
                return n
            return fibonacci(n-1) + fibonacci(n-2)

        result = fibonacci(10)
        print("✅ Decorators and memoization working")
    except Exception as e:
        print(f"❌ Decorators failed: {e}")
        return False

    print("🎉 All tests passed! Environment is ready for functional programming.")
    return True

# Run the test
test_functional_features()

"""
📊 PERFORMANCE MONITORING UTILITIES
Tools for comparing functional vs imperative approaches
"""

import time
from functools import wraps
from contextlib import contextmanager

def timer(func):
    """Decorator to time function execution"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"⏱️ {func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper

@contextmanager
def time_block(description):
    """Context manager for timing code blocks"""
    start = time.time()
    yield
    end = time.time()
    print(f"⏱️ {description} took {end - start:.4f} seconds")

def compare_approaches(name, functional_fn, imperative_fn, *args, **kwargs):
    """Compare performance of functional vs imperative approaches"""
    print(f"\n🔍 Comparing approaches: {name}")
    print("-" * 40)

    # Time functional approach
    start = time.time()
    func_result = functional_fn(*args, **kwargs)
    func_time = time.time() - start

    # Time imperative approach  
    start = time.time()
    imp_result = imperative_fn(*args, **kwargs)
    imp_time = time.time() - start

    # Results
    print(f"🧮 Functional: {func_time:.4f}s")
    print(f"🔧 Imperative: {imp_time:.4f}s")
    print(f"⚡ Speedup: {func_time / imp_time:.2f}x {'(functional faster)' if imp_time > func_time else '(imperative faster)'}")
    print(f"✅ Results match: {func_result == imp_result}")

# Example usage
if __name__ == "__main__":
    # Example comparison
    def functional_sum_squares(numbers):
        return sum(x**2 for x in numbers)

    def imperative_sum_squares(numbers):
        total = 0
        for x in numbers:
            total += x**2
        return total

    test_data = list(range(10000))
    compare_approaches("Sum of squares", functional_sum_squares, imperative_sum_squares, test_data)

"""
📊 PERFORMANCE MONITORING UTILITIES
Tools for comparing functional vs imperative approaches
"""

import time
from functools import wraps
from contextlib import contextmanager

def timer(func):
    """Decorator to time function execution"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"⏱️ {func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper

@contextmanager
def time_block(description):
    """Context manager for timing code blocks"""
    start = time.time()
    yield
    end = time.time()
    print(f"⏱️ {description} took {end - start:.4f} seconds")

def compare_approaches(name, functional_fn, imperative_fn, *args, **kwargs):
    """Compare performance of functional vs imperative approaches"""
    print(f"\n🔍 Comparing approaches: {name}")
    print("-" * 40)

    # Time functional approach
    start = time.time()
    func_result = functional_fn(*args, **kwargs)
    func_time = time.time() - start

    # Time imperative approach  
    start = time.time()
    imp_result = imperative_fn(*args, **kwargs)
    imp_time = time.time() - start

    # Results
    print(f"🧮 Functional: {func_time:.4f}s")
    print(f"🔧 Imperative: {imp_time:.4f}s")
    print(f"⚡ Speedup: {func_time / imp_time:.2f}x {'(functional faster)' if imp_time > func_time else '(imperative faster)'}")
    print(f"✅ Results match: {func_result == imp_result}")

# Example usage
if __name__ == "__main__":
    # Example comparison
    def functional_sum_squares(numbers):
        return sum(x**2 for x in numbers)

    def imperative_sum_squares(numbers):
        total = 0
        for x in numbers:
            total += x**2
        return total

    test_data = list(range(10000))
    compare_approaches("Sum of squares", functional_sum_squares, imperative_sum_squares, test_data)

"""
🎨 VISUALIZATION HELPERS
Tools for visualizing functional programming concepts
"""

def visualize_pipeline(data, *operations):
    """Visualize data transformation pipeline"""
    print("🔄 DATA TRANSFORMATION PIPELINE")
    print("=" * 50)

    current_data = data
    print(f"📥 Input: {current_data}")

    for i, operation in enumerate(operations, 1):
        try:
            if hasattr(operation, '__name__'):
                op_name = operation.__name__
            else:
                op_name = str(operation)

            current_data = operation(current_data)
            print(f"Step {i} ({op_name}): {current_data}")
        except Exception as e:
            print(f"❌ Step {i} failed: {e}")
            break

    print(f"📤 Final result: {current_data}")
    return current_data

def show_function_composition(functions, input_value):
    """Show step-by-step function composition"""
    print("🔗 FUNCTION COMPOSITION VISUALIZATION")
    print("=" * 45)

    result = input_value
    print(f"Input: {result}")

    for i, func in enumerate(functions):
        result = func(result)
        func_name = getattr(func, '__name__', 'lambda')
        print(f"  Step {i+1}: {func_name}({result})")

    print(f"Final result: {result}")
    return result

# Example usage
if __name__ == "__main__":
    # Pipeline visualization
    numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    visualize_pipeline(
        numbers,
        lambda x: [n for n in x if n % 2 == 0],  # filter evens
        lambda x: [n**2 for n in x],             # square
        sum                                       # sum all
    )

    # Function composition visualization
    functions = [
        lambda x: x + 1,
        lambda x: x * 2, 
        lambda x: x**2
    ]
    show_function_composition(functions, 3)

"""
🎨 VISUALIZATION HELPERS
Tools for visualizing functional programming concepts
"""

def visualize_pipeline(data, *operations):
    """Visualize data transformation pipeline"""
    print("🔄 DATA TRANSFORMATION PIPELINE")
    print("=" * 50)

    current_data = data
    print(f"📥 Input: {current_data}")

    for i, operation in enumerate(operations, 1):
        try:
            if hasattr(operation, '__name__'):
                op_name = operation.__name__
            else:
                op_name = str(operation)

            current_data = operation(current_data)
            print(f"Step {i} ({op_name}): {current_data}")
        except Exception as e:
            print(f"❌ Step {i} failed: {e}")
            break

    print(f"📤 Final result: {current_data}")
    return current_data

def show_function_composition(functions, input_value):
    """Show step-by-step function composition"""
    print("🔗 FUNCTION COMPOSITION VISUALIZATION")
    print("=" * 45)

    result = input_value
    print(f"Input: {result}")

    for i, func in enumerate(functions):
        result = func(result)
        func_name = getattr(func, '__name__', 'lambda')
        print(f"  Step {i+1}: {func_name}({result})")

    print(f"Final result: {result}")
    return result

# Example usage
if __name__ == "__main__":
    # Pipeline visualization
    numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    visualize_pipeline(
        numbers,
        lambda x: [n for n in x if n % 2 == 0],  # filter evens
        lambda x: [n**2 for n in x],             # square
        sum                                       # sum all
    )

    # Function composition visualization
    functions = [
        lambda x: x + 1,
        lambda x: x * 2, 
        lambda x: x**2
    ]
    show_function_composition(functions, 3)

"""
📦 FUNCTIONS AS VARIABLES
Functions can be assigned to variables just like any other value
"""

def greet(name):
    """A simple greeting function"""
    return f"Hello, {name}!"

def farewell(name):
    """A farewell function"""
    return f"Goodbye, {name}!"

# Assign functions to variables
greeting_func = greet
farewell_func = farewell

print(f"Function name: {greeting_func.__name__}")  # greet
print(f"Function call: {greeting_func('Alice')}")  # Hello, Alice!

# Functions have the same identity
print(f"Same function? {greet is greeting_func}")  # True

# Can check if variable holds a function
print(f"Is callable? {callable(greeting_func)}")  # True

# Store functions in data structures
function_library = {
    'hello': greet,
    'bye': farewell,
    'welcome': lambda name: f"Welcome, {name}!"
}

# Use functions from the library
for func_name, func in function_library.items():
    print(f"{func_name}: {func('Bob')}")

# Advanced: Function metadata
def analyze_function(func):
    """Analyze a function's properties"""
    print(f"\n🔍 ANALYZING FUNCTION: {func.__name__}")
    print(f"   Module: {func.__module__}")
    print(f"   Doc: {func.__doc__}")
    if hasattr(func, '__code__'):
        print(f"   Arguments: {func.__code__.co_varnames}")
        print(f"   Line number: {func.__code__.co_firstlineno}")

analyze_function(greet)
analyze_function(lambda x: x * 2)

"""
📦 FUNCTIONS AS VARIABLES
Functions can be assigned to variables just like any other value
"""

def greet(name):
    """A simple greeting function"""
    return f"Hello, {name}!"

def farewell(name):
    """A farewell function"""
    return f"Goodbye, {name}!"

# Assign functions to variables
greeting_func = greet
farewell_func = farewell

print(f"Function name: {greeting_func.__name__}")  # greet
print(f"Function call: {greeting_func('Alice')}")  # Hello, Alice!

# Functions have the same identity
print(f"Same function? {greet is greeting_func}")  # True

# Can check if variable holds a function
print(f"Is callable? {callable(greeting_func)}")  # True

# Store functions in data structures
function_library = {
    'hello': greet,
    'bye': farewell,
    'welcome': lambda name: f"Welcome, {name}!"
}

# Use functions from the library
for func_name, func in function_library.items():
    print(f"{func_name}: {func('Bob')}")

# Advanced: Function metadata
def analyze_function(func):
    """Analyze a function's properties"""
    print(f"\n🔍 ANALYZING FUNCTION: {func.__name__}")
    print(f"   Module: {func.__module__}")
    print(f"   Doc: {func.__doc__}")
    if hasattr(func, '__code__'):
        print(f"   Arguments: {func.__code__.co_varnames}")
        print(f"   Line number: {func.__code__.co_firstlineno}")

analyze_function(greet)
analyze_function(lambda x: x * 2)

"""
📨 HIGHER-ORDER FUNCTIONS
Functions that accept other functions as arguments
"""

def apply_operation(data, operation):
    """Apply an operation to each item in data"""
    return [operation(item) for item in data]

def double(x):
    """Double a number"""
    return x * 2

def square(x):
    """Square a number"""
    return x ** 2

def cube(x):
    """Cube a number"""
    return x ** 3

# Sample data
numbers = [1, 2, 3, 4, 5]

print("🧮 HIGHER-ORDER FUNCTION DEMO")
print("=" * 40)

# Pass different functions as arguments
print(f"Original: {numbers}")
print(f"Doubled: {apply_operation(numbers, double)}")
print(f"Squared: {apply_operation(numbers, square)}")
print(f"Cubed: {apply_operation(numbers, cube)}")

# Pass lambda functions
print(f"Plus 10: {apply_operation(numbers, lambda x: x + 10)}")
print(f"Negated: {apply_operation(numbers, lambda x: -x)}")

# More complex example: Multiple operations
def chain_operations(data, *operations):
    """Apply multiple operations in sequence"""
    result = data
    for operation in operations:
        result = apply_operation(result, operation)
        print(f"After {operation.__name__}: {result}")
    return result

print(f"\n🔗 CHAINING OPERATIONS:")
final_result = chain_operations(
    [1, 2, 3], 
    double,     # First double: [2, 4, 6]
    square,     # Then square: [4, 16, 36]
    lambda x: x + 1  # Finally add 1: [5, 17, 37]
)

# Real-world example: Data processing pipeline
def process_data(data, filters=None, transformations=None, aggregations=None):
    """Generic data processing pipeline"""
    result = data

    # Apply filters
    if filters:
        for filter_func in filters:
            result = [item for item in result if filter_func(item)]
            print(f"After filter {filter_func.__name__}: {result}")

    # Apply transformations
    if transformations:
        for transform_func in transformations:
            result = [transform_func(item) for item in result]
            print(f"After transform {transform_func.__name__}: {result}")

    # Apply aggregations
    if aggregations:
        for agg_func in aggregations:
            result = agg_func(result)
            print(f"After aggregation {agg_func.__name__}: {result}")

    return result

# Define some helper functions
def is_positive(x):
    return x > 0

def is_even(x):
    return x % 2 == 0

def add_one(x):
    return x + 1

def multiply_by_ten(x):
    return x * 10

# Example usage
sample_data = [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6]
print(f"\n📊 DATA PROCESSING PIPELINE:")
print(f"Original data: {sample_data}")

result = process_data(
    sample_data,
    filters=[is_positive, is_even],  # Keep positive even numbers
    transformations=[add_one, multiply_by_ten],  # Add 1, then multiply by 10
    aggregations=[sum]  # Sum all results
)

"""
📨 HIGHER-ORDER FUNCTIONS
Functions that accept other functions as arguments
"""

def apply_operation(data, operation):
    """Apply an operation to each item in data"""
    return [operation(item) for item in data]

def double(x):
    """Double a number"""
    return x * 2

def square(x):
    """Square a number"""
    return x ** 2

def cube(x):
    """Cube a number"""
    return x ** 3

# Sample data
numbers = [1, 2, 3, 4, 5]

print("🧮 HIGHER-ORDER FUNCTION DEMO")
print("=" * 40)

# Pass different functions as arguments
print(f"Original: {numbers}")
print(f"Doubled: {apply_operation(numbers, double)}")
print(f"Squared: {apply_operation(numbers, square)}")
print(f"Cubed: {apply_operation(numbers, cube)}")

# Pass lambda functions
print(f"Plus 10: {apply_operation(numbers, lambda x: x + 10)}")
print(f"Negated: {apply_operation(numbers, lambda x: -x)}")

# More complex example: Multiple operations
def chain_operations(data, *operations):
    """Apply multiple operations in sequence"""
    result = data
    for operation in operations:
        result = apply_operation(result, operation)
        print(f"After {operation.__name__}: {result}")
    return result

print(f"\n🔗 CHAINING OPERATIONS:")
final_result = chain_operations(
    [1, 2, 3], 
    double,     # First double: [2, 4, 6]
    square,     # Then square: [4, 16, 36]
    lambda x: x + 1  # Finally add 1: [5, 17, 37]
)

# Real-world example: Data processing pipeline
def process_data(data, filters=None, transformations=None, aggregations=None):
    """Generic data processing pipeline"""
    result = data

    # Apply filters
    if filters:
        for filter_func in filters:
            result = [item for item in result if filter_func(item)]
            print(f"After filter {filter_func.__name__}: {result}")

    # Apply transformations
    if transformations:
        for transform_func in transformations:
            result = [transform_func(item) for item in result]
            print(f"After transform {transform_func.__name__}: {result}")

    # Apply aggregations
    if aggregations:
        for agg_func in aggregations:
            result = agg_func(result)
            print(f"After aggregation {agg_func.__name__}: {result}")

    return result

# Define some helper functions
def is_positive(x):
    return x > 0

def is_even(x):
    return x % 2 == 0

def add_one(x):
    return x + 1

def multiply_by_ten(x):
    return x * 10

# Example usage
sample_data = [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6]
print(f"\n📊 DATA PROCESSING PIPELINE:")
print(f"Original data: {sample_data}")

result = process_data(
    sample_data,
    filters=[is_positive, is_even],  # Keep positive even numbers
    transformations=[add_one, multiply_by_ten],  # Add 1, then multiply by 10
    aggregations=[sum]  # Sum all results
)

"""
📤 FUNCTION FACTORIES
Functions that create and return other functions
"""

def create_multiplier(factor):
    """Factory function that creates multiplier functions"""
    def multiplier(x):
        return x * factor

    # Add metadata to the created function
    multiplier.__name__ = f"multiply_by_{factor}"
    multiplier.__doc__ = f"Multiply input by {factor}"

    return multiplier

def create_validator(min_val, max_val):
    """Factory function that creates validator functions"""
    def validator(value):
        return min_val <= value <= max_val

    validator.__name__ = f"validate_{min_val}_to_{max_val}"
    return validator

def create_formatter(prefix, suffix=""):
    """Factory function that creates formatter functions"""
    def formatter(text):
        return f"{prefix}{text}{suffix}"

    formatter.__name__ = f"format_with_{prefix}"
    return formatter

# Create specific functions using factories
double = create_multiplier(2)
triple = create_multiplier(3)
multiply_by_10 = create_multiplier(10)

print("🏭 FUNCTION FACTORIES DEMO")
print("=" * 40)

# Test multiplier functions
numbers = [1, 2, 3, 4, 5]
print(f"Original: {numbers}")
print(f"Doubled: {[double(x) for x in numbers]}")
print(f"Tripled: {[triple(x) for x in numbers]}")
print(f"× 10: {[multiply_by_10(x) for x in numbers]}")

# Create validators
age_validator = create_validator(0, 120)
percentage_validator = create_validator(0, 100)
temperature_validator = create_validator(-273, 1000)

ages = [-5, 25, 150, 45]
print(f"\n✅ VALIDATION:")
for age in ages:
    valid = age_validator(age)
    print(f"Age {age}: {'✅ Valid' if valid else '❌ Invalid'}")

# Create formatters
html_bold = create_formatter("<b>", "</b>")
markdown_italic = create_formatter("*", "*")
quote_formatter = create_formatter('"', '"')

texts = ["Hello", "World", "Python"]
print(f"\n🎨 FORMATTING:")
for text in texts:
    print(f"Original: {text}")
    print(f"HTML Bold: {html_bold(text)}")
    print(f"Markdown Italic: {markdown_italic(text)}")
    print(f"Quoted: {quote_formatter(text)}")
    print()

# Advanced: Configurable function factory
def create_operation(operation_name, operation_func, *args, **kwargs):
    """Create a customized operation function"""
    def operation(data):
        return operation_func(data, *args, **kwargs)

    operation.__name__ = operation_name
    operation.__doc__ = f"Apply {operation_name} operation"
    return operation

# Create operations with different configurations
add_ten = create_operation("add_ten", lambda x, n: x + n, 10)
power_of = create_operation("square", lambda x, n: x ** n, 2)
modulo_check = create_operation("mod_3", lambda x, n: x % n, 3)

print(f"🔧 CONFIGURABLE OPERATIONS:")
test_val = 7
print(f"Original: {test_val}")
print(f"Add 10: {add_ten(test_val)}")
print(f"Square: {power_of(test_val)}")
print(f"Mod 3: {modulo_check(test_val)}")

"""
📤 FUNCTION FACTORIES
Functions that create and return other functions
"""

def create_multiplier(factor):
    """Factory function that creates multiplier functions"""
    def multiplier(x):
        return x * factor

    # Add metadata to the created function
    multiplier.__name__ = f"multiply_by_{factor}"
    multiplier.__doc__ = f"Multiply input by {factor}"

    return multiplier

def create_validator(min_val, max_val):
    """Factory function that creates validator functions"""
    def validator(value):
        return min_val <= value <= max_val

    validator.__name__ = f"validate_{min_val}_to_{max_val}"
    return validator

def create_formatter(prefix, suffix=""):
    """Factory function that creates formatter functions"""
    def formatter(text):
        return f"{prefix}{text}{suffix}"

    formatter.__name__ = f"format_with_{prefix}"
    return formatter

# Create specific functions using factories
double = create_multiplier(2)
triple = create_multiplier(3)
multiply_by_10 = create_multiplier(10)

print("🏭 FUNCTION FACTORIES DEMO")
print("=" * 40)

# Test multiplier functions
numbers = [1, 2, 3, 4, 5]
print(f"Original: {numbers}")
print(f"Doubled: {[double(x) for x in numbers]}")
print(f"Tripled: {[triple(x) for x in numbers]}")
print(f"× 10: {[multiply_by_10(x) for x in numbers]}")

# Create validators
age_validator = create_validator(0, 120)
percentage_validator = create_validator(0, 100)
temperature_validator = create_validator(-273, 1000)

ages = [-5, 25, 150, 45]
print(f"\n✅ VALIDATION:")
for age in ages:
    valid = age_validator(age)
    print(f"Age {age}: {'✅ Valid' if valid else '❌ Invalid'}")

# Create formatters
html_bold = create_formatter("<b>", "</b>")
markdown_italic = create_formatter("*", "*")
quote_formatter = create_formatter('"', '"')

texts = ["Hello", "World", "Python"]
print(f"\n🎨 FORMATTING:")
for text in texts:
    print(f"Original: {text}")
    print(f"HTML Bold: {html_bold(text)}")
    print(f"Markdown Italic: {markdown_italic(text)}")
    print(f"Quoted: {quote_formatter(text)}")
    print()

# Advanced: Configurable function factory
def create_operation(operation_name, operation_func, *args, **kwargs):
    """Create a customized operation function"""
    def operation(data):
        return operation_func(data, *args, **kwargs)

    operation.__name__ = operation_name
    operation.__doc__ = f"Apply {operation_name} operation"
    return operation

# Create operations with different configurations
add_ten = create_operation("add_ten", lambda x, n: x + n, 10)
power_of = create_operation("square", lambda x, n: x ** n, 2)
modulo_check = create_operation("mod_3", lambda x, n: x % n, 3)

print(f"🔧 CONFIGURABLE OPERATIONS:")
test_val = 7
print(f"Original: {test_val}")
print(f"Add 10: {add_ten(test_val)}")
print(f"Square: {power_of(test_val)}")
print(f"Mod 3: {modulo_check(test_val)}")

"""
🗄️ FUNCTIONS IN DATA STRUCTURES
Functions can be stored in lists, dictionaries, sets, etc.
"""

import math

# Calculator using function dictionary
calculator_operations = {
    'add': lambda x, y: x + y,
    'subtract': lambda x, y: x - y,
    'multiply': lambda x, y: x * y,
    'divide': lambda x, y: x / y if y != 0 else float('inf'),
    'power': lambda x, y: x ** y,
    'sqrt': lambda x, y=None: math.sqrt(x),
    'log': lambda x, y=None: math.log(x),
    'sin': lambda x, y=None: math.sin(x),
    'cos': lambda x, y=None: math.cos(x)
}

def calculate(operation, x, y=None):
    """Generic calculator function"""
    if operation in calculator_operations:
        func = calculator_operations[operation]
        try:
            return func(x, y) if y is not None else func(x)
        except Exception as e:
            return f"Error: {e}"
    else:
        return f"Unknown operation: {operation}"

print("🧮 CALCULATOR DEMO")
print("=" * 30)

# Test calculator
test_cases = [
    ('add', 5, 3),
    ('multiply', 4, 7),
    ('sqrt', 16),
    ('power', 2, 8),
    ('divide', 10, 0),
    ('unknown', 1, 2)
]

for operation, x, *args in test_cases:
    y = args[0] if args else None
    result = calculate(operation, x, y)
    if y is not None:
        print(f"{operation}({x}, {y}) = {result}")
    else:
        print(f"{operation}({x}) = {result}")

# Event handling system using function lists
event_handlers = {
    'user_login': [],
    'user_logout': [],
    'data_received': [],
    'error_occurred': []
}

def on_user_login(username):
    print(f"📧 Sending welcome email to {username}")

def on_user_login_analytics(username):
    print(f"📊 Recording login analytics for {username}")

def on_user_logout(username):
    print(f"👋 User {username} logged out")

def on_data_received(data):
    print(f"💾 Processing data: {len(data)} items")

def on_error(error_msg):
    print(f"🚨 Error logged: {error_msg}")

# Register event handlers
event_handlers['user_login'].extend([on_user_login, on_user_login_analytics])
event_handlers['user_logout'].append(on_user_logout)
event_handlers['data_received'].append(on_data_received)
event_handlers['error_occurred'].append(on_error)

def trigger_event(event_name, *args):
    """Trigger all handlers for an event"""
    if event_name in event_handlers:
        print(f"\n🎯 Triggering event: {event_name}")
        for handler in event_handlers[event_name]:
            try:
                handler(*args)
            except Exception as e:
                print(f"❌ Handler error: {e}")

print(f"\n📡 EVENT SYSTEM DEMO")
print("=" * 30)

# Trigger events
trigger_event('user_login', 'alice@example.com')
trigger_event('user_logout', 'bob@example.com')
trigger_event('data_received', [1, 2, 3, 4, 5])
trigger_event('error_occurred', 'Database connection failed')

# Plugin system using function registry
plugin_registry = []

def register_plugin(plugin_func):
    """Decorator to register plugin functions"""
    plugin_registry.append(plugin_func)
    print(f"🔌 Registered plugin: {plugin_func.__name__}")
    return plugin_func

def execute_plugins(data):
    """Execute all registered plugins"""
    result = data
    for plugin in plugin_registry:
        try:
            result = plugin(result)
            print(f"✅ Plugin {plugin.__name__} executed")
        except Exception as e:
            print(f"❌ Plugin {plugin.__name__} failed: {e}")
    return result

# Define and register plugins
@register_plugin
def uppercase_plugin(text):
    """Convert text to uppercase"""
    return text.upper() if isinstance(text, str) else text

@register_plugin
def add_timestamp_plugin(data):
    """Add timestamp to data"""
    import datetime
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    return f"[{timestamp}] {data}"

@register_plugin
def add_prefix_plugin(data):
    """Add prefix to data"""
    return f"PROCESSED: {data}"

print(f"\n🔌 PLUGIN SYSTEM DEMO")
print("=" * 30)

# Execute plugin pipeline
original_data = "hello world"
final_result = execute_plugins(original_data)
print(f"Original: {original_data}")
print(f"Final: {final_result}")

"""
🗄️ FUNCTIONS IN DATA STRUCTURES
Functions can be stored in lists, dictionaries, sets, etc.
"""

import math

# Calculator using function dictionary
calculator_operations = {
    'add': lambda x, y: x + y,
    'subtract': lambda x, y: x - y,
    'multiply': lambda x, y: x * y,
    'divide': lambda x, y: x / y if y != 0 else float('inf'),
    'power': lambda x, y: x ** y,
    'sqrt': lambda x, y=None: math.sqrt(x),
    'log': lambda x, y=None: math.log(x),
    'sin': lambda x, y=None: math.sin(x),
    'cos': lambda x, y=None: math.cos(x)
}

def calculate(operation, x, y=None):
    """Generic calculator function"""
    if operation in calculator_operations:
        func = calculator_operations[operation]
        try:
            return func(x, y) if y is not None else func(x)
        except Exception as e:
            return f"Error: {e}"
    else:
        return f"Unknown operation: {operation}"

print("🧮 CALCULATOR DEMO")
print("=" * 30)

# Test calculator
test_cases = [
    ('add', 5, 3),
    ('multiply', 4, 7),
    ('sqrt', 16),
    ('power', 2, 8),
    ('divide', 10, 0),
    ('unknown', 1, 2)
]

for operation, x, *args in test_cases:
    y = args[0] if args else None
    result = calculate(operation, x, y)
    if y is not None:
        print(f"{operation}({x}, {y}) = {result}")
    else:
        print(f"{operation}({x}) = {result}")

# Event handling system using function lists
event_handlers = {
    'user_login': [],
    'user_logout': [],
    'data_received': [],
    'error_occurred': []
}

def on_user_login(username):
    print(f"📧 Sending welcome email to {username}")

def on_user_login_analytics(username):
    print(f"📊 Recording login analytics for {username}")

def on_user_logout(username):
    print(f"👋 User {username} logged out")

def on_data_received(data):
    print(f"💾 Processing data: {len(data)} items")

def on_error(error_msg):
    print(f"🚨 Error logged: {error_msg}")

# Register event handlers
event_handlers['user_login'].extend([on_user_login, on_user_login_analytics])
event_handlers['user_logout'].append(on_user_logout)
event_handlers['data_received'].append(on_data_received)
event_handlers['error_occurred'].append(on_error)

def trigger_event(event_name, *args):
    """Trigger all handlers for an event"""
    if event_name in event_handlers:
        print(f"\n🎯 Triggering event: {event_name}")
        for handler in event_handlers[event_name]:
            try:
                handler(*args)
            except Exception as e:
                print(f"❌ Handler error: {e}")

print(f"\n📡 EVENT SYSTEM DEMO")
print("=" * 30)

# Trigger events
trigger_event('user_login', 'alice@example.com')
trigger_event('user_logout', 'bob@example.com')
trigger_event('data_received', [1, 2, 3, 4, 5])
trigger_event('error_occurred', 'Database connection failed')

# Plugin system using function registry
plugin_registry = []

def register_plugin(plugin_func):
    """Decorator to register plugin functions"""
    plugin_registry.append(plugin_func)
    print(f"🔌 Registered plugin: {plugin_func.__name__}")
    return plugin_func

def execute_plugins(data):
    """Execute all registered plugins"""
    result = data
    for plugin in plugin_registry:
        try:
            result = plugin(result)
            print(f"✅ Plugin {plugin.__name__} executed")
        except Exception as e:
            print(f"❌ Plugin {plugin.__name__} failed: {e}")
    return result

# Define and register plugins
@register_plugin
def uppercase_plugin(text):
    """Convert text to uppercase"""
    return text.upper() if isinstance(text, str) else text

@register_plugin
def add_timestamp_plugin(data):
    """Add timestamp to data"""
    import datetime
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    return f"[{timestamp}] {data}"

@register_plugin
def add_prefix_plugin(data):
    """Add prefix to data"""
    return f"PROCESSED: {data}"

print(f"\n🔌 PLUGIN SYSTEM DEMO")
print("=" * 30)

# Execute plugin pipeline
original_data = "hello world"
final_result = execute_plugins(original_data)
print(f"Original: {original_data}")
print(f"Final: {final_result}")

"""
🏗️ RUNTIME FUNCTION CREATION
Functions can be created dynamically during program execution
"""

def create_dynamic_function(operation, operand):
    """Create a function dynamically based on operation type"""

    operations = {
        'add': lambda x: x + operand,
        'subtract': lambda x: x - operand,
        'multiply': lambda x: x * operand,
        'divide': lambda x: x / operand if operand != 0 else float('inf'),
        'power': lambda x: x ** operand,
        'modulo': lambda x: x % operand if operand != 0 else 0
    }

    if operation not in operations:
        raise ValueError(f"Unknown operation: {operation}")

    func = operations[operation]
    func.__name__ = f"{operation}_by_{operand}"
    func.__doc__ = f"{operation.title()} input by {operand}"

    return func

# Create functions at runtime based on user input
print("🏗️ DYNAMIC FUNCTION CREATION")
print("=" * 40)

# Simulate user configuration
user_configs = [
    ('add', 5),
    ('multiply', 3),
    ('power', 2),
    ('divide', 2)
]

# Create and test dynamic functions
test_values = [1, 2, 3, 4, 5]
for operation, operand in user_configs:
    func = create_dynamic_function(operation, operand)
    results = [func(x) for x in test_values]
    print(f"{func.__name__}: {test_values} → {results}")

# Advanced: Code generation with exec
def create_function_from_template(func_name, operation_code):
    """Create function from string template"""

    template = f"""
def {func_name}(x):
    '''Generated function: {func_name}'''
    return {operation_code}
"""

    # Execute the template to create the function
    namespace = {}
    exec(template, namespace)
    return namespace[func_name]

print(f"\n📝 CODE GENERATION DEMO")
print("=" * 30)

# Generate functions from templates
templates = [
    ('double_plus_one', 'x * 2 + 1'),
    ('cube_minus_ten', 'x ** 3 - 10'),
    ('reciprocal_safe', '1 / x if x != 0 else 0')
]

generated_functions = []
for func_name, operation_code in templates:
    func = create_function_from_template(func_name, operation_code)
    generated_functions.append(func)
    print(f"Generated: {func.__name__} - {func.__doc__}")

# Test generated functions
test_value = 4
for func in generated_functions:
    result = func(test_value)
    print(f"{func.__name__}({test_value}) = {result}")

# Meta-programming: Function factory with custom behavior
class FunctionBuilder:
    """Builder class for creating custom functions"""

    def __init__(self, name):
        self.name = name
        self.operations = []

    def add_operation(self, operation):
        """Add an operation to the function pipeline"""
        self.operations.append(operation)
        return self  # Enable method chaining

    def build(self):
        """Build the final function"""
        def generated_function(x):
            result = x
            for operation in self.operations:
                result = operation(result)
            return result

        generated_function.__name__ = self.name
        generated_function.__doc__ = f"Generated function with {len(self.operations)} operations"

        return generated_function

print(f"\n🏗️ FUNCTION BUILDER DEMO")
print("=" * 30)

# Build complex functions using builder pattern
complex_func = (FunctionBuilder("complex_transformation")
               .add_operation(lambda x: x * 2)      # Double
               .add_operation(lambda x: x + 10)     # Add 10
               .add_operation(lambda x: x ** 2)     # Square
               .add_operation(lambda x: x % 100)    # Modulo 100
               .build())

# Test the built function
test_inputs = [1, 2, 3, 4, 5]
for inp in test_inputs:
    result = complex_func(inp)
    print(f"{complex_func.__name__}({inp}) = {result}")

# Show the transformation pipeline
def show_transformation_steps(func_builder, input_val):
    """Show each step of transformation"""
    result = input_val
    print(f"Input: {result}")

    for i, operation in enumerate(func_builder.operations, 1):
        result = operation(result)
        print(f"Step {i}: {result}")

print(f"\n🔍 TRANSFORMATION STEPS for input 3:")
builder = FunctionBuilder("step_by_step")
builder.add_operation(lambda x: x * 2)    # 3 → 6
builder.add_operation(lambda x: x + 10)   # 6 → 16
builder.add_operation(lambda x: x ** 2)   # 16 → 256
builder.add_operation(lambda x: x % 100)  # 256 → 56

show_transformation_steps(builder, 3)

"""
🏗️ RUNTIME FUNCTION CREATION
Functions can be created dynamically during program execution
"""

def create_dynamic_function(operation, operand):
    """Create a function dynamically based on operation type"""

    operations = {
        'add': lambda x: x + operand,
        'subtract': lambda x: x - operand,
        'multiply': lambda x: x * operand,
        'divide': lambda x: x / operand if operand != 0 else float('inf'),
        'power': lambda x: x ** operand,
        'modulo': lambda x: x % operand if operand != 0 else 0
    }

    if operation not in operations:
        raise ValueError(f"Unknown operation: {operation}")

    func = operations[operation]
    func.__name__ = f"{operation}_by_{operand}"
    func.__doc__ = f"{operation.title()} input by {operand}"

    return func

# Create functions at runtime based on user input
print("🏗️ DYNAMIC FUNCTION CREATION")
print("=" * 40)

# Simulate user configuration
user_configs = [
    ('add', 5),
    ('multiply', 3),
    ('power', 2),
    ('divide', 2)
]

# Create and test dynamic functions
test_values = [1, 2, 3, 4, 5]
for operation, operand in user_configs:
    func = create_dynamic_function(operation, operand)
    results = [func(x) for x in test_values]
    print(f"{func.__name__}: {test_values} → {results}")

# Advanced: Code generation with exec
def create_function_from_template(func_name, operation_code):
    """Create function from string template"""

    template = f"""
def {func_name}(x):
    '''Generated function: {func_name}'''
    return {operation_code}
"""

    # Execute the template to create the function
    namespace = {}
    exec(template, namespace)
    return namespace[func_name]

print(f"\n📝 CODE GENERATION DEMO")
print("=" * 30)

# Generate functions from templates
templates = [
    ('double_plus_one', 'x * 2 + 1'),
    ('cube_minus_ten', 'x ** 3 - 10'),
    ('reciprocal_safe', '1 / x if x != 0 else 0')
]

generated_functions = []
for func_name, operation_code in templates:
    func = create_function_from_template(func_name, operation_code)
    generated_functions.append(func)
    print(f"Generated: {func.__name__} - {func.__doc__}")

# Test generated functions
test_value = 4
for func in generated_functions:
    result = func(test_value)
    print(f"{func.__name__}({test_value}) = {result}")

# Meta-programming: Function factory with custom behavior
class FunctionBuilder:
    """Builder class for creating custom functions"""

    def __init__(self, name):
        self.name = name
        self.operations = []

    def add_operation(self, operation):
        """Add an operation to the function pipeline"""
        self.operations.append(operation)
        return self  # Enable method chaining

    def build(self):
        """Build the final function"""
        def generated_function(x):
            result = x
            for operation in self.operations:
                result = operation(result)
            return result

        generated_function.__name__ = self.name
        generated_function.__doc__ = f"Generated function with {len(self.operations)} operations"

        return generated_function

print(f"\n🏗️ FUNCTION BUILDER DEMO")
print("=" * 30)

# Build complex functions using builder pattern
complex_func = (FunctionBuilder("complex_transformation")
               .add_operation(lambda x: x * 2)      # Double
               .add_operation(lambda x: x + 10)     # Add 10
               .add_operation(lambda x: x ** 2)     # Square
               .add_operation(lambda x: x % 100)    # Modulo 100
               .build())

# Test the built function
test_inputs = [1, 2, 3, 4, 5]
for inp in test_inputs:
    result = complex_func(inp)
    print(f"{complex_func.__name__}({inp}) = {result}")

# Show the transformation pipeline
def show_transformation_steps(func_builder, input_val):
    """Show each step of transformation"""
    result = input_val
    print(f"Input: {result}")

    for i, operation in enumerate(func_builder.operations, 1):
        result = operation(result)
        print(f"Step {i}: {result}")

print(f"\n🔍 TRANSFORMATION STEPS for input 3:")
builder = FunctionBuilder("step_by_step")
builder.add_operation(lambda x: x * 2)    # 3 → 6
builder.add_operation(lambda x: x + 10)   # 6 → 16
builder.add_operation(lambda x: x ** 2)   # 16 → 256
builder.add_operation(lambda x: x % 100)  # 256 → 56

show_transformation_steps(builder, 3)

"""
🔍 PURE vs IMPURE FUNCTIONS
Understanding the difference through examples
"""

import random
import time
from datetime import datetime

# ✅ PURE FUNCTIONS
def add_pure(x, y):
    """Pure: same input always gives same output, no side effects"""
    return x + y

def calculate_area_pure(length, width):
    """Pure: mathematical calculation, deterministic"""
    return length * width

def get_full_name_pure(first, last):
    """Pure: string manipulation, no external dependencies"""
    return f"{first} {last}"

def factorial_pure(n):
    """Pure: mathematical calculation, recursive"""
    if n <= 1:
        return 1
    return n * factorial_pure(n - 1)

def filter_evens_pure(numbers):
    """Pure: returns new list, doesn't modify input"""
    return [n for n in numbers if n % 2 == 0]

print("✅ PURE FUNCTIONS DEMO")
print("=" * 30)

# Test pure functions - always same results
print(f"add_pure(2, 3) = {add_pure(2, 3)}")
print(f"add_pure(2, 3) = {add_pure(2, 3)}")  # Same result
print(f"area(5, 4) = {calculate_area_pure(5, 4)}")
print(f"full_name = {get_full_name_pure('Alice', 'Smith')}")
print(f"factorial(5) = {factorial_pure(5)}")

numbers = [1, 2, 3, 4, 5, 6]
evens1 = filter_evens_pure(numbers)
evens2 = filter_evens_pure(numbers)
print(f"Original numbers: {numbers}")
print(f"Filtered evens (1st call): {evens1}")
print(f"Filtered evens (2nd call): {evens2}")
print(f"Results are equal: {evens1 == evens2}")

print("\n❌ IMPURE FUNCTIONS DEMO")
print("=" * 30)

# ❌ IMPURE FUNCTIONS

# Global state dependency
counter = 0

def add_impure(x, y):
    """Impure: depends on global state"""
    global counter
    counter += 1  # Side effect: modifies global state
    return x + y + counter  # Result depends on external state

# Non-deterministic (depends on time/random)
def get_random_number():
    """Impure: non-deterministic output"""
    return random.randint(1, 100)

def get_current_time():
    """Impure: depends on system state"""
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

# Modifies input (side effect)
def add_to_list_impure(lst, item):
    """Impure: modifies the input list"""
    lst.append(item)  # Side effect: modifies input
    return lst

# I/O operations (side effects)
def log_message_impure(message):
    """Impure: has side effect (console output)"""
    print(f"LOG: {message}")  # Side effect: console output
    return message

# Test impure functions - results vary or have side effects
print("Testing impure functions:")

# Global state dependency - results change
print(f"add_impure(2, 3) = {add_impure(2, 3)}")  # 6 (2+3+1)
print(f"add_impure(2, 3) = {add_impure(2, 3)}")  # 7 (2+3+2) - Different!

# Non-deterministic results
print(f"random_number = {get_random_number()}")
print(f"random_number = {get_random_number()}")  # Different each time

# Time dependency
print(f"current_time = {get_current_time()}")
time.sleep(1)  # Wait 1 second
print(f"current_time = {get_current_time()}")  # Different time

# Modifying input
original_list = [1, 2, 3]
print(f"Original list: {original_list}")
result_list = add_to_list_impure(original_list, 4)
print(f"After impure function: {original_list}")  # Modified!
print(f"Result list: {result_list}")

# Side effects
log_message_impure("This is a side effect")  # Prints to console

"""
🔍 PURE vs IMPURE FUNCTIONS
Understanding the difference through examples
"""

import random
import time
from datetime import datetime

# ✅ PURE FUNCTIONS
def add_pure(x, y):
    """Pure: same input always gives same output, no side effects"""
    return x + y

def calculate_area_pure(length, width):
    """Pure: mathematical calculation, deterministic"""
    return length * width

def get_full_name_pure(first, last):
    """Pure: string manipulation, no external dependencies"""
    return f"{first} {last}"

def factorial_pure(n):
    """Pure: mathematical calculation, recursive"""
    if n <= 1:
        return 1
    return n * factorial_pure(n - 1)

def filter_evens_pure(numbers):
    """Pure: returns new list, doesn't modify input"""
    return [n for n in numbers if n % 2 == 0]

print("✅ PURE FUNCTIONS DEMO")
print("=" * 30)

# Test pure functions - always same results
print(f"add_pure(2, 3) = {add_pure(2, 3)}")
print(f"add_pure(2, 3) = {add_pure(2, 3)}")  # Same result
print(f"area(5, 4) = {calculate_area_pure(5, 4)}")
print(f"full_name = {get_full_name_pure('Alice', 'Smith')}")
print(f"factorial(5) = {factorial_pure(5)}")

numbers = [1, 2, 3, 4, 5, 6]
evens1 = filter_evens_pure(numbers)
evens2 = filter_evens_pure(numbers)
print(f"Original numbers: {numbers}")
print(f"Filtered evens (1st call): {evens1}")
print(f"Filtered evens (2nd call): {evens2}")
print(f"Results are equal: {evens1 == evens2}")

print("\n❌ IMPURE FUNCTIONS DEMO")
print("=" * 30)

# ❌ IMPURE FUNCTIONS

# Global state dependency
counter = 0

def add_impure(x, y):
    """Impure: depends on global state"""
    global counter
    counter += 1  # Side effect: modifies global state
    return x + y + counter  # Result depends on external state

# Non-deterministic (depends on time/random)
def get_random_number():
    """Impure: non-deterministic output"""
    return random.randint(1, 100)

def get_current_time():
    """Impure: depends on system state"""
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

# Modifies input (side effect)
def add_to_list_impure(lst, item):
    """Impure: modifies the input list"""
    lst.append(item)  # Side effect: modifies input
    return lst

# I/O operations (side effects)
def log_message_impure(message):
    """Impure: has side effect (console output)"""
    print(f"LOG: {message}")  # Side effect: console output
    return message

# Test impure functions - results vary or have side effects
print("Testing impure functions:")

# Global state dependency - results change
print(f"add_impure(2, 3) = {add_impure(2, 3)}")  # 6 (2+3+1)
print(f"add_impure(2, 3) = {add_impure(2, 3)}")  # 7 (2+3+2) - Different!

# Non-deterministic results
print(f"random_number = {get_random_number()}")
print(f"random_number = {get_random_number()}")  # Different each time

# Time dependency
print(f"current_time = {get_current_time()}")
time.sleep(1)  # Wait 1 second
print(f"current_time = {get_current_time()}")  # Different time

# Modifying input
original_list = [1, 2, 3]
print(f"Original list: {original_list}")
result_list = add_to_list_impure(original_list, 4)
print(f"After impure function: {original_list}")  # Modified!
print(f"Result list: {result_list}")

# Side effects
log_message_impure("This is a side effect")  # Prints to console

"""
🔧 PURIFICATION: Converting impure functions to pure ones
Learn how to eliminate side effects and external dependencies
"""

# ❌ IMPURE VERSION: Global state dependency
total_processed = 0

def process_data_impure(data):
    """Impure: modifies global state"""
    global total_processed
    total_processed += len(data)
    return [x * 2 for x in data]

# ✅ PURE VERSION: No global state
def process_data_pure(data, current_total=0):
    """Pure: returns both result and new total"""
    processed_data = [x * 2 for x in data]
    new_total = current_total + len(data)
    return processed_data, new_total

print("🔧 IMPURE → PURE CONVERSION DEMO")
print("=" * 40)

# Test impure version
print("❌ Impure version:")
data1 = [1, 2, 3]
data2 = [4, 5]
result1 = process_data_impure(data1)
result2 = process_data_impure(data2)
print(f"Data 1: {data1} → {result1}, Total: {total_processed}")
print(f"Data 2: {data2} → {result2}, Total: {total_processed}")

# Reset for comparison
total_processed = 0

# Test pure version
print("\n✅ Pure version:")
result1, total1 = process_data_pure(data1, 0)
result2, total2 = process_data_pure(data2, total1)
print(f"Data 1: {data1} → {result1}, Total: {total1}")
print(f"Data 2: {data2} → {result2}, Total: {total2}")

# ❌ IMPURE VERSION: Modifying input
def sort_list_impure(lst):
    """Impure: modifies the input list"""
    lst.sort()  # Side effect: modifies input
    return lst

# ✅ PURE VERSION: No input modification
def sort_list_pure(lst):
    """Pure: returns new sorted list"""
    return sorted(lst)  # Creates new list

print(f"\n📝 INPUT MODIFICATION DEMO")
print("=" * 30)

# Test input modification
original = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"Original list: {original}")

# Impure version
impure_copy = original.copy()
sorted_impure = sort_list_impure(impure_copy)
print(f"After impure sort - Original: {original}")
print(f"After impure sort - Copy: {impure_copy}")  # Modified!
print(f"Result: {sorted_impure}")

# Pure version
sorted_pure = sort_list_pure(original)
print(f"After pure sort - Original: {original}")  # Unchanged!
print(f"Pure result: {sorted_pure}")

# ❌ IMPURE VERSION: I/O operations
def calculate_with_logging_impure(x, y, operation):
    """Impure: has logging side effect"""
    if operation == "add":
        result = x + y
        print(f"LOG: Added {x} + {y} = {result}")  # Side effect
    elif operation == "multiply":
        result = x * y
        print(f"LOG: Multiplied {x} * {y} = {result}")  # Side effect
    else:
        result = 0
        print(f"LOG: Unknown operation")  # Side effect
    return result

# ✅ PURE VERSION: Return both result and log message
def calculate_with_logging_pure(x, y, operation):
    """Pure: returns both result and log message"""
    if operation == "add":
        result = x + y
        log_message = f"LOG: Added {x} + {y} = {result}"
    elif operation == "multiply":
        result = x * y
        log_message = f"LOG: Multiplied {x} * {y} = {result}"
    else:
        result = 0
        log_message = "LOG: Unknown operation"

    return result, log_message

print(f"\n📋 LOGGING DEMO")
print("=" * 20)

# Test logging functions
print("❌ Impure version (with side effects):")
result1 = calculate_with_logging_impure(5, 3, "add")
result2 = calculate_with_logging_impure(4, 7, "multiply")

print("\n✅ Pure version (no side effects):")
result3, log3 = calculate_with_logging_pure(5, 3, "add")
result4, log4 = calculate_with_logging_pure(4, 7, "multiply")
print(log3)  # Explicitly handle logging
print(log4)

# Advanced: Pure function with dependency injection
def create_pure_calculator(logger_func=None):
    """Factory function that creates a pure calculator"""

    def calculate(x, y, operation):
        """Pure calculation function"""
        operations = {
            'add': lambda a, b: a + b,
            'subtract': lambda a, b: a - b,
            'multiply': lambda a, b: a * b,
            'divide': lambda a, b: a / b if b != 0 else float('inf')
        }

        if operation in operations:
            result = operations[operation](x, y)
            log_message = f"Calculated: {x} {operation} {y} = {result}"
        else:
            result = 0
            log_message = f"Unknown operation: {operation}"

        # Pure function returns all effects as data
        return {
            'result': result,
            'log_message': log_message,
            'success': operation in operations
        }

    return calculate

print(f"\n🏭 DEPENDENCY INJECTION DEMO")
print("=" * 35)

# Create pure calculator
pure_calc = create_pure_calculator()

# Use the calculator
calc_result = pure_calc(10, 3, "divide")
print(f"Result: {calc_result['result']}")
print(f"Log: {calc_result['log_message']}")
print(f"Success: {calc_result['success']}")

# The logging effect is data that can be handled externally
if calc_result['log_message']:
    print(f"External logger: {calc_result['log_message']}")

"""
🔧 PURIFICATION: Converting impure functions to pure ones
Learn how to eliminate side effects and external dependencies
"""

# ❌ IMPURE VERSION: Global state dependency
total_processed = 0

def process_data_impure(data):
    """Impure: modifies global state"""
    global total_processed
    total_processed += len(data)
    return [x * 2 for x in data]

# ✅ PURE VERSION: No global state
def process_data_pure(data, current_total=0):
    """Pure: returns both result and new total"""
    processed_data = [x * 2 for x in data]
    new_total = current_total + len(data)
    return processed_data, new_total

print("🔧 IMPURE → PURE CONVERSION DEMO")
print("=" * 40)

# Test impure version
print("❌ Impure version:")
data1 = [1, 2, 3]
data2 = [4, 5]
result1 = process_data_impure(data1)
result2 = process_data_impure(data2)
print(f"Data 1: {data1} → {result1}, Total: {total_processed}")
print(f"Data 2: {data2} → {result2}, Total: {total_processed}")

# Reset for comparison
total_processed = 0

# Test pure version
print("\n✅ Pure version:")
result1, total1 = process_data_pure(data1, 0)
result2, total2 = process_data_pure(data2, total1)
print(f"Data 1: {data1} → {result1}, Total: {total1}")
print(f"Data 2: {data2} → {result2}, Total: {total2}")

# ❌ IMPURE VERSION: Modifying input
def sort_list_impure(lst):
    """Impure: modifies the input list"""
    lst.sort()  # Side effect: modifies input
    return lst

# ✅ PURE VERSION: No input modification
def sort_list_pure(lst):
    """Pure: returns new sorted list"""
    return sorted(lst)  # Creates new list

print(f"\n📝 INPUT MODIFICATION DEMO")
print("=" * 30)

# Test input modification
original = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"Original list: {original}")

# Impure version
impure_copy = original.copy()
sorted_impure = sort_list_impure(impure_copy)
print(f"After impure sort - Original: {original}")
print(f"After impure sort - Copy: {impure_copy}")  # Modified!
print(f"Result: {sorted_impure}")

# Pure version
sorted_pure = sort_list_pure(original)
print(f"After pure sort - Original: {original}")  # Unchanged!
print(f"Pure result: {sorted_pure}")

# ❌ IMPURE VERSION: I/O operations
def calculate_with_logging_impure(x, y, operation):
    """Impure: has logging side effect"""
    if operation == "add":
        result = x + y
        print(f"LOG: Added {x} + {y} = {result}")  # Side effect
    elif operation == "multiply":
        result = x * y
        print(f"LOG: Multiplied {x} * {y} = {result}")  # Side effect
    else:
        result = 0
        print(f"LOG: Unknown operation")  # Side effect
    return result

# ✅ PURE VERSION: Return both result and log message
def calculate_with_logging_pure(x, y, operation):
    """Pure: returns both result and log message"""
    if operation == "add":
        result = x + y
        log_message = f"LOG: Added {x} + {y} = {result}"
    elif operation == "multiply":
        result = x * y
        log_message = f"LOG: Multiplied {x} * {y} = {result}"
    else:
        result = 0
        log_message = "LOG: Unknown operation"

    return result, log_message

print(f"\n📋 LOGGING DEMO")
print("=" * 20)

# Test logging functions
print("❌ Impure version (with side effects):")
result1 = calculate_with_logging_impure(5, 3, "add")
result2 = calculate_with_logging_impure(4, 7, "multiply")

print("\n✅ Pure version (no side effects):")
result3, log3 = calculate_with_logging_pure(5, 3, "add")
result4, log4 = calculate_with_logging_pure(4, 7, "multiply")
print(log3)  # Explicitly handle logging
print(log4)

# Advanced: Pure function with dependency injection
def create_pure_calculator(logger_func=None):
    """Factory function that creates a pure calculator"""

    def calculate(x, y, operation):
        """Pure calculation function"""
        operations = {
            'add': lambda a, b: a + b,
            'subtract': lambda a, b: a - b,
            'multiply': lambda a, b: a * b,
            'divide': lambda a, b: a / b if b != 0 else float('inf')
        }

        if operation in operations:
            result = operations[operation](x, y)
            log_message = f"Calculated: {x} {operation} {y} = {result}"
        else:
            result = 0
            log_message = f"Unknown operation: {operation}"

        # Pure function returns all effects as data
        return {
            'result': result,
            'log_message': log_message,
            'success': operation in operations
        }

    return calculate

print(f"\n🏭 DEPENDENCY INJECTION DEMO")
print("=" * 35)

# Create pure calculator
pure_calc = create_pure_calculator()

# Use the calculator
calc_result = pure_calc(10, 3, "divide")
print(f"Result: {calc_result['result']}")
print(f"Log: {calc_result['log_message']}")
print(f"Success: {calc_result['success']}")

# The logging effect is data that can be handled externally
if calc_result['log_message']:
    print(f"External logger: {calc_result['log_message']}")