# 순수 함수의 예
def add(x, y):
    return x + y

# 순수하지 않은 함수의 예
total = 0
def add_to_total(x):
    global total
    total += x
    return total

# 부작용이 없는 방식으로 작성하기
def create_adder(initial=0):
    def add(x):
        return initial + x
    return add

add_to_5 = create_adder(5)
print(add_to_5(10))  # 15

from functools import reduce

# map: 모든 요소에 함수 적용
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))
print(squares)  # [1, 4, 9, 16, 25]

# filter: 조건에 맞는 요소만 선택
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4]

# reduce: 요소들을 하나로 줄임
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 120

# 리스트 컴프리헨션을 활용한 대안
squares_comp = [x**2 for x in numbers]
evens_comp = [x for x in numbers if x % 2 == 0]

# 여러 함수를 조합한 데이터 처리
result = reduce(
    lambda acc, x: acc + x,
    filter(lambda x: x > 10,
           map(lambda x: x**2, numbers))
)
print(result)  # 16 + 25 = 41

def multiply_by(n):
    def multiplier(x):
        return x * n
    return multiplier

times_two = multiply_by(2)
times_three = multiply_by(3)

print(times_two(5))    # 10
print(times_three(5))  # 15

# 함수를 인자로 받는 고차 함수
def apply_twice(func, arg):
    return func(func(arg))

def add_five(x):
    return x + 5

print(apply_twice(add_five, 10))  # 10 + 5 + 5 = 20

# 데코레이터도 고차 함수의 일종이다
def log_function_call(func):
    def wrapper(*args, **kwargs):
        print(f"함수 {func.__name__} 호출됨")
        return func(*args, **kwargs)
    return wrapper

@log_function_call
def greet(name):
    return f"안녕, {name}!"

print(greet("철수"))  # "함수 greet 호출됨" 출력 후 "안녕, 철수!" 반환

from typing import NamedTuple
import copy

class Point(NamedTuple):
    x: int
    y: int

def move_point(point, dx, dy):
    return Point(point.x + dx, point.y + dy)

p1 = Point(1, 2)
p2 = move_point(p1, 3, 4)  # 새로운 객체 생성
print(p1)  # Point(x=1, y=2) - 원본 변경 없음
print(p2)  # Point(x=4, y=6) - 새 객체 반환

# 불변 리스트 흉내내기
def append_to_list(lst, item):
    # 원본 리스트를 변경하지 않고 새 리스트 반환
    new_list = lst.copy()
    new_list.append(item)
    return new_list

original = [1, 2, 3]
modified = append_to_list(original, 4)
print(original)  # [1, 2, 3] - 원본 변경 없음
print(modified)  # [1, 2, 3, 4] - 새 리스트 반환

# 중첩 데이터 구조에서의 불변성
def update_user_email(user_dict, new_email):
    # 딕셔너리 깊은 복사
    new_user = copy.deepcopy(user_dict)
    new_user['email'] = new_email
    return new_user

user = {'name': '홍길동', 'email': '[email protected]', 'settings': {'theme': 'dark'}}
updated_user = update_user_email(user, '[email protected]')
print(user['email'])  # [email protected]
print(updated_user['email'])  # [email protected]

def compose(f, g):
    return lambda x: f(g(x))

def double(x):
    return x * 2

def increment(x):
    return x + 1

# 함수 합성
double_then_increment = compose(increment, double)
increment_then_double = compose(double, increment)

print(double_then_increment(3))  # 3*2 + 1 = 7
print(increment_then_double(3))  # (3+1)*2 = 8

# 여러 함수 합성하기
def compose_all(*functions):
    def compose_two(f, g):
        return lambda x: f(g(x))
    
    if not functions:
        return lambda x: x  # 항등 함수
    
    return functools.reduce(compose_two, functions)

def square(x):
    return x * x

# square(double(increment(x)))
composed = compose_all(square, double, increment)
print(composed(3))  # square(double(increment(3))) = square(double(4)) = square(8) = 64

# 부분 적용 함수
from functools import partial

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

add_five = partial(add, 5)  # x=5로 고정
print(add_five(10))  # 15

import functools

def pipeline(*funcs):
    def wrapper(x):
        result = x
        for f in funcs:
            result = f(result)
        return result
    return wrapper

# 데이터 처리 함수들
clean = lambda x: x.strip().lower()
split_words = lambda x: x.split()
count_words = lambda x: len(x)

# 파이프라인 생성
word_counter = pipeline(clean, split_words, count_words)

text = "  Hello World  "
print(word_counter(text))  # 2

# 데이터 변환 파이프라인
def transform_data(data):
    # 함수형 접근 방식으로 데이터 변환
    return (
        data
        | pipe(filter_invalid_entries)
        | pipe(normalize_fields)
        | pipe(enrich_with_external_data)
        | pipe(calculate_statistics)
    )

# 파이프 연산자 흉내내기
def pipe(func):
    def wrapper(data):
        return func(data)
    return wrapper

# 함수형 에러 처리 - Maybe 모나드 패턴
class Maybe:
    def __init__(self, value=None):
        self.value = value
    
    @classmethod
    def just(cls, value):
        return cls(value)
    
    @classmethod
    def nothing(cls):
        return cls(None)
    
    def bind(self, func):
        if self.value is None:
            return self
        try:
            result = func(self.value)
            if isinstance(result, Maybe):
                return result
            return Maybe.just(result)
        except:
            return Maybe.nothing()
    
    def get_or_else(self, default):
        return self.value if self.value is not None else default

# Maybe 모나드 사용 예시
def safe_divide(x, y):
    return Maybe.just(x / y) if y != 0 else Maybe.nothing()

def safe_sqrt(x):
    return Maybe.just(x ** 0.5) if x >= 0 else Maybe.nothing()

# 안전한 계산 파이프라인
def calculate(x, y):
    return (Maybe.just(x)
            .bind(lambda v: safe_divide(v, y))
            .bind(safe_sqrt)
            .get_or_else("계산 불가"))

print(calculate(16, 4))  # 2.0
print(calculate(16, 0))  # "계산 불가"
print(calculate(-16, 4))  # "계산 불가"

# 일반적인 재귀 - 팩토리얼 계산
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n-1)

print(factorial(5))  # 120

# 꼬리 재귀(Tail Recursion) - 스택 오버플로우 방지
def factorial_tail(n, acc=1):
    if n <= 1:
        return acc
    return factorial_tail(n-1, n*acc)

print(factorial_tail(5))  # 120

# 피보나치 수열 - 메모이제이션으로 성능 개선
def fibonacci(n, memo=None):
    if memo is None:
        memo = {}
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    
    memo[n] = fibonacci(n-1, memo) + fibonacci(n-2, memo)
    return memo[n]

print(fibonacci(10))  # 55

# 트램폴린(Trampoline) 패턴 - 꼬리 재귀 시뮬레이션
def trampoline(func, *args, **kwargs):
    result = func(*args, **kwargs)
    while callable(result):
        result = result()
    return result

def factorial_trampoline(n, acc=1):
    if n <= 1:
        return acc
    return lambda: factorial_trampoline(n-1, n*acc)

print(trampoline(factorial_trampoline, 5))  # 120

# 내장 함수 활용
from functools import reduce, partial
import itertools
import operator

data = [1, 2, 3, 4, 5]

# 부분 적용 함수
multiply = lambda x, y: x * y
double = partial(multiply, 2)

# 연산자 모듈 활용
total = reduce(operator.add, data)
product = reduce(operator.mul, data)

# itertools 활용
combinations = list(itertools.combinations(data, 2))
permutations = list(itertools.permutations(data, 2))

# 무한 시퀀스 생성과 슬라이싱
infinite = itertools.count(1)
first_10 = list(itertools.islice(infinite, 10))

# 외부 라이브러리 - toolz
# pip install toolz
try:
    from toolz import compose, curry, pipe

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

    def double(x):
        return x * 2

    # 커링
    curried_add = curry(add)
    add_5 = curried_add(5)
    
    # 합성
    transform = compose(double, add_5)
    
    # 파이프
    result = pipe(10, add_5, double)
except ImportError:
    print("toolz 라이브러리가 설치되어 있지 않습니다.")

# 함수형 데이터 구조 - pyrsistent
# pip install pyrsistent
try:
    import pyrsistent as pyr
    
    # 불변 리스트
    v = pyr.pvector([1, 2, 3])
    v2 = v.append(4)  # 새 벡터 반환
    
    # 불변 맵
    m = pyr.pmap({'a': 1, 'b': 2})
    m2 = m.set('c', 3)  # 새 맵 반환
except ImportError:
    print("pyrsistent 라이브러리가 설치되어 있지 않습니다.")