Functions, Scope, and Functional Programming

from typing import Callable, List, Any, Optional
from functools import wraps, reduce
import time
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def performance_monitor(func: Callable) -> Callable:
    """Decorator to monitor function performance."""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        logger.info(f"{func.__name__} executed in {end_time - start_time:.4f} seconds")
        return result
    return wrapper

def validate_input(func: Callable) -> Callable:
    """Decorator to validate function inputs."""
    @wraps(func)
    def wrapper(*args, **kwargs):
        # Example validation for numeric functions
        for arg in args:
            if not isinstance(arg, (int, float)):
                raise TypeError(f"Expected numeric type, got {type(arg)}")
        return func(*args, **kwargs)
    return wrapper

class FunctionAnalyzer:
    """Demonstrates advanced function concepts and patterns."""
    
    def __init__(self):
        self.cache = {}
        self._call_count = 0
    
    @performance_monitor
    @validate_input
    def fibonacci(self, n: int) -> int:
        """Calculate Fibonacci number with memoization."""
        if n in self.cache:
            return self.cache[n]
        
        if n <= 1:
            result = n
        else:
            result = self.fibonacci(n - 1) + self.fibonacci(n - 2)
        
        self.cache[n] = result
        return result
    
    def create_closure(self, multiplier: int) -> Callable[[int], int]:
        """Demonstrate closure concept."""
        def multiply(x: int) -> int:
            return x * multiplier
        return multiply
    
    def higher_order_function(self, func: Callable, data: List[Any]) -> List[Any]:
        """Apply a function to each element in a list."""
        return [func(item) for item in data]
    
    def compose_functions(self, *functions: Callable) -> Callable:
        """Compose multiple functions into a single function."""
        def composed(*args, **kwargs):
            result = functions[0](*args, **kwargs)
            for func in functions[1:]:
                result = func(result)
            return result
        return composed
    
    def partial_application(self, func: Callable, *args, **kwargs) -> Callable:
        """Create a new function with some arguments pre-filled."""
        from functools import partial
        return partial(func, *args, **kwargs)

def demonstrate_functional_programming():
    """Show functional programming concepts in action."""
    
    # Pure functions
    def add(a: int, b: int) -> int:
        """Pure function - no side effects."""
        return a + b
    
    def square(x: int) -> int:
        """Pure function - no side effects."""
        return x ** 2
    
    # Function composition
    add_and_square = lambda x, y: square(add(x, y))
    
    # Map, filter, reduce
    numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    # Map: transform each element
    squared_numbers = list(map(square, numbers))
    
    # Filter: select elements that meet criteria
    even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
    
    # Reduce: combine all elements
    sum_of_squares = reduce(lambda acc, x: acc + x, squared_numbers)
    
    return {
        "squared_numbers": squared_numbers,
        "even_numbers": even_numbers,
        "sum_of_squares": sum_of_squares,
        "add_and_square_example": add_and_square(3, 4)
    }

def main():
    """Run comprehensive function demonstration."""
    analyzer = FunctionAnalyzer()
    
    print("=== Advanced Function Concepts ===\n")
    
    # Test memoized Fibonacci
    print("Fibonacci with memoization:")
    for i in range(10):
        result = analyzer.fibonacci(i)
        print(f"  F({i}) = {result}")
    print()
    
    # Test closure
    print("Closure demonstration:")
    multiply_by_5 = analyzer.create_closure(5)
    multiply_by_10 = analyzer.create_closure(10)
    print(f"  multiply_by_5(7) = {multiply_by_5(7)}")
    print(f"  multiply_by_10(7) = {multiply_by_10(7)}")
    print()
    
    # Test higher-order function
    print("Higher-order function demonstration:")
    numbers = [1, 2, 3, 4, 5]
    squared = analyzer.higher_order_function(square, numbers)
    doubled = analyzer.higher_order_function(lambda x: x * 2, numbers)
    print(f"  Original: {numbers}")
    print(f"  Squared: {squared}")
    print(f"  Doubled: {doubled}")
    print()
    
    # Test function composition
    print("Function composition:")
    add_then_square = analyzer.compose_functions(add, square)
    result = add_then_square(3, 4)  # (3 + 4)² = 49
    print(f"  add_then_square(3, 4) = {result}")
    print()
    
    # Test functional programming
    print("Functional programming patterns:")
    fp_results = demonstrate_functional_programming()
    print(f"  Squared numbers: {fp_results['squared_numbers']}")
    print(f"  Even numbers: {fp_results['even_numbers']}")
    print(f"  Sum of squares: {fp_results['sum_of_squares']}")
    print(f"  Add and square example: {fp_results['add_and_square_example']}")

if __name__ == "__main__":
    main()