def outer():
    x = 1
    def inner():
        nonlocal x
        x += 1
        return x
    return inner

f = outer()
print(f(), f())

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            return [func(*args, **kwargs) for _ in range(n)]
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    return f"Hi, {name}"

print(greet("Leo"))

from functools import partial

def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
print(square(4))

def counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

a = counter()
b = counter()
print(a(), b(), a())

def outer(x):
    def inner():
        return x + 1
    x = 10
    return inner()

print(outer(5))

class A:
    @staticmethod
    def stat(): return "static"
    
    @classmethod
    def cls(cls): return cls.__name__

print(A.stat(), A.cls())

from typing import Callable

def apply_twice(f: Callable[[int], int], x: int) -> int:
    return f(f(x))

print(apply_twice(lambda x: x + 1, 3))

import inspect

def f(a, b=2, *args, **kwargs): pass

sig = inspect.signature(f)
print(len(sig.parameters))

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

print(add(3)(4))

def sum(x, y):
    return x * y

print(sum([1, 2], 2))

def make():
    def f(): return "hi"
    f.data = 42
    return f

g = make()
print(g(), g.data)