Higher-Order Functions & Function Factories (Python)

def apply_twice(fn, value):
    # This function TAKES another function as an argument!
    return fn(fn(value))  # Call fn twice

def add_one(x):
    return x + 1

# We pass add_one INTO apply_twice
result = apply_twice(add_one, 5)
print(result)  # 7 → add_one(add_one(5)) = add_one(6) = 7

def greet(name):
    return f"Hello, {name}!"

say_hello = greet
print(say_hello("Alex"))

def apply_each(fn, values):
    return [fn(v) for v in values]

print(apply_each(lambda x: x * 2, [1, 2, 3]))

def power(exponent):
    # This outer function "configures" the inner function
    def inner(base):
        return base ** exponent  # Uses exponent from outer scope!
    return inner  # Return the inner function itself

# Create specialized functions
square = power(2)  # square remembers exponent=2
cube = power(3)    # cube remembers exponent=3

# Now use them!
print(square(5))  # 25 (5²)
print(cube(5))    # 125 (5³)
print(power(4)(2))  # 16 (2⁴) - can also use directly!

def make_counter():
    count = 0  # This variable gets "captured" by the closure
    
    def inc():
        nonlocal count  # "I want to MODIFY the outer variable"
        count += 1
        return count
    
    return inc  # Return the inner function with its "backpack"

# Create two separate counters
counter1 = make_counter()
counter2 = make_counter()

print(counter1())  # 1 - counter1's count
print(counter1())  # 2 - counter1's count
print(counter2())  # 1 - counter2 has its OWN count!
pri
...

def logger(prefix):
    def log(message):
        print(f"[{prefix}] {message}")
    return log

info = logger("INFO")
warn = logger("WARNING")

info("Server started")
warn("CPU usage high")

def min_length(n):
    def validate(value):
        return len(value) >= n
    return validate

validate_password = min_length(8)
print(validate_password("hello123"))  # True

def track(fn):  # Step 1: Takes a function
    def wrapper(*args, **kwargs):  # Step 2: Create wrapper (closure!)
        print("Calling:", fn.__name__)  # Extra behavior BEFORE
        result = fn(*args, **kwargs)    # Call original function
        print("Done!")                   # Extra behavior AFTER
        return result
    return wrapper  # Step 3: Return the wrapper

@track  # This is the same as: greet = track(greet)
def greet():
    print("Hello!")

greet()  # Now greet is actually wr
...

def compose(f, g):
    # Returns a NEW function that applies g first, then f
    return lambda x: f(g(x))

def double(n): return n * 2
def add_one(n): return n + 1

# Create a pipeline: first add_one, then double
combined = compose(double, add_one)

# compose(f, g) means: f(g(x))
# So combined(3) = double(add_one(3)) = double(4) = 8
print(combined(3))  # 8

# You can chain more!
triple = lambda x: x * 3
mega = compose(triple, combined)  # triple(double(add_one(x)))
print(mega(3))  # triple(8) = 
...

import time

def rate_limiter(max_calls, per_seconds):
    calls = []

    def decorator(fn):
        def wrapper(*args, **kwargs):
            nonlocal calls
            now = time.time()

            calls = [t for t in calls if now - t < per_seconds]

            if len(calls) >= max_calls:
                raise Exception("Rate limit exceeded")

            calls.append(now)
            return fn(*args, **kwargs)
        return wrapper
    return decorator

@rate_limiter(3, 5)
def fetch():
  
...

def scaler(min_value, max_value):
    def scale(x):
        return (x - min_value) / (max_value - min_value)
    return scale

normalize = scaler(0, 255)
print(normalize(128))  # 0.5019...

def query_builder(table):
    def where(**conditions):
        clause = " AND ".join(f"{k}='{v}'" for k, v in conditions.items())
        return f"SELECT * FROM {table} WHERE {clause}"
    return where

users_query = query_builder("users")
print(users_query(name="Alex", age=20))