🧠 클로저(Closure)가 뭔데?

클로저를 이해하려면 먼저 스코프(Scope)를 알아야 해. 스코프는 변수가 살아있는 범위야. 보통 함수가 끝나면 그 안의 변수들은 사라지잖아? 근데 클로저는 달라.

예를 들어볼게:

def make_counter
  count = 0  # 이 변수를 클로저가 기억함!
  
  increment = lambda do
    count += 1
    puts count
  end
  
  increment
end

counter = make_counter
counter.call  # => 1
counter.call  # => 2
counter.call  # => 3

봐봐! make_counter 메서드가 끝났는데도 count 변수가 살아있어. Lambda가 그 변수를 "포획(capture)"해서 기억하고 있기 때문이야. 이게 바로 클로저의 마법이야! ✨

Ruby에서 클로저는 세 가지 형태로 존재해:

이 세 가지가 어떻게 다른지 하나씩 파헤쳐보자!

📦 Block: Ruby의 가장 기본적인 클로저

블록은 Ruby에서 가장 자주 쓰이는 클로저 형태야. 근데 신기한 건, 블록은 객체가 아니야! 그냥 코드 덩어리야. 메서드에 붙여서 전달하는 코드 조각이라고 생각하면 돼.

블록의 두 가지 문법

[1, 2, 3].each do |n|
  puts n * 2
end

[1, 2, 3].each { |n| puts n * 2 }

yield로 블록 실행하기

메서드 안에서 블록을 실행하려면 yield 키워드를 써. 이게 블록을 "호출"하는 방법이야:

def greet
  puts "안녕하세요!"
  yield  # 여기서 블록이 실행됨
  puts "또 만나요!"
end

greet { puts "저는 Ruby입니다!" }
# => 안녕하세요!
# => 저는 Ruby입니다!
# => 또 만나요!

블록에 값을 넘겨줄 수도 있어:

def calculate(a, b)
  result = yield(a, b)  # 블록에 a, b를 넘겨줌
  puts "결과: #{result}"
end

calculate(10, 5) { |x, y| x + y }   # => 결과: 15
calculate(10, 5) { |x, y| x * y }   # => 결과: 50

block_given?으로 블록 존재 확인

블록이 없는데 yield를 호출하면 에러가 나. 그래서 block_given?으로 먼저 확인하는 게 좋아:

def optional_block
  if block_given?
    yield
  else
    puts "블록이 없어요!"
  end
end

optional_block { puts "블록 있음!" }  # => 블록 있음!
optional_block                         # => 블록이 없어요!

블록과 클로저: 외부 변수 포획

블록도 클로저야! 정의된 시점의 변수를 기억해:

message = "Hello, Ruby!"

[1, 2, 3].each do |n|
  puts "#{n}: #{message}"  # 외부 변수 message에 접근 가능!
end

# => 1: Hello, Ruby!
# => 2: Hello, Ruby!
# => 3: Hello, Ruby!

& 연산자: 블록을 Proc으로, Proc을 블록으로

블록을 메서드 파라미터로 받고 싶을 때 & 연산자를 써:

def capture_block(&block)  # &로 블록을 Proc으로 변환해서 받음
  puts block.class  # => Proc
  block.call        # 블록 실행
end

capture_block { puts "나는 블록이었는데 Proc이 됐어!" }
# => Proc
# => 나는 블록이었는데 Proc이 됐어!

반대로 Proc을 블록으로 변환할 수도 있어:

double = Proc.new { |n| n * 2 }

[1, 2, 3].map(&double)  # &로 Proc을 블록으로 변환!
# => [2, 4, 6]

# Symbol도 & 연산자로 블록처럼 쓸 수 있어!
["hello", "world"].map(&:upcase)
# => ["HELLO", "WORLD"]

🎁 Proc: 블록을 객체로 만들다

블록은 객체가 아니라서 변수에 저장하거나 나중에 재사용하기가 불편해. 그래서 등장한 게 Proc(프로시저)야! Proc은 블록을 객체로 만든 거야. 변수에 저장하고, 메서드에 전달하고, 나중에 실행할 수 있어.

Proc 만드는 방법

# 방법 1: Proc.new
greet = Proc.new { |name| puts "안녕, #{name}!" }

# 방법 2: proc 메서드 (Proc.new와 동일)
greet2 = proc { |name| puts "안녕, #{name}!" }

# 실행 방법들
greet.call("Ruby")   # => 안녕, Ruby!
greet.("Python")     # => 안녕, Python!
greet["JavaScript"]  # => 안녕, JavaScript!

세 가지 호출 방법이 있는데, 가장 명시적인 .call을 주로 써. .()는 Ruby 1.9+에서 추가된 문법이고, []는 좀 특이하게 생겼지만 유효한 문법이야.

Proc의 유연한 인자 처리

Proc은 인자 개수에 대해 매우 관대해. 인자가 부족하면 nil로 채우고, 넘치면 그냥 무시해:

flexible = Proc.new { |a, b, c| puts "#{a}, #{b}, #{c}" }

flexible.call(1, 2, 3)     # => 1, 2, 3
flexible.call(1, 2)        # => 1, 2,    (c는 nil)
flexible.call(1, 2, 3, 4)  # => 1, 2, 3 (4는 무시)
flexible.call              # => , ,      (모두 nil)

def test_proc_return
  my_proc = Proc.new { return "Proc에서 리턴!" }
  my_proc.call
  puts "이 줄은 절대 실행 안 됨!"  # 실행 안 됨!
end

puts test_proc_return  # => "Proc에서 리턴!"

Proc 안의 return이 메서드 전체를 종료시켜버렸어. 이게 의도한 동작이라면 괜찮지만, 모르고 쓰면 버그의 원인이 돼!

Proc으로 클로저 활용하기

Proc이 클로저라는 걸 실제로 느껴볼 수 있는 예제야:

def make_multiplier(factor)
  Proc.new { |n| n * factor }  # factor를 포획!
end

double = make_multiplier(2)
triple = make_multiplier(3)

puts double.call(5)   # => 10
puts triple.call(5)   # => 15
puts double.call(10)  # => 20

make_multiplier 메서드가 끝났는데도 factor 변수가 살아있어! 각각의 Proc이 자기만의 factor를 기억하고 있는 거야. 이게 클로저의 진짜 힘이야! 💪

Proc을 이용한 콜백 패턴

class Button
  def initialize(label)
    @label = label
    @on_click = nil
  end
  
  def on_click(&block)
    @on_click = block  # 블록을 Proc으로 저장
  end
  
  def click!
    puts "#{@label} 버튼 클릭!"
    @on_click.call if @on_click
  end
end

btn = Button.new("확인")
btn.on_click { puts "확인 버튼이 눌렸어요! 🎉" }
btn.click!
# => 확인 버튼 클릭!
# => 확인 버튼이 눌렸어요! 🎉

이런 콜백 패턴은 실제 Ruby 프레임워크(Rails 등)에서 엄청 많이 쓰여. 이제 Rails 코드 볼 때 이해가 될 거야! 😄

λ Lambda: 함수에 가장 가까운 클로저

Lambda는 Proc의 특별한 버전이야. 기술적으로는 Proc 객체인데, 두 가지 중요한 차이점이 있어. Lambda는 더 함수답게 동작해!

Lambda 만드는 방법

# 방법 1: lambda 키워드
greet = lambda { |name| puts "안녕, #{name}!" }

# 방법 2: -> 화살표 문법 (Ruby 1.9+, 가장 많이 씀!)
greet2 = ->(name) { puts "안녕, #{name}!" }

# 여러 줄 Lambda
process = ->(x, y) do
  result = x + y
  puts "결과: #{result}"
  result
end

greet.call("Ruby")    # => 안녕, Ruby!
greet2.call("Python") # => 안녕, Python!
process.call(3, 4)    # => 결과: 7

Lambda vs Proc: 두 가지 핵심 차이

차이 1: 인자 처리 — Lambda는 엄격해!

# Proc: 인자 개수 달라도 OK
my_proc = Proc.new { |a, b| puts "#{a}, #{b}" }
my_proc.call(1)        # => 1,    (에러 없음, b는 nil)
my_proc.call(1, 2, 3)  # => 1, 2 (에러 없음, 3은 무시)

# Lambda: 인자 개수 다르면 에러!
my_lambda = lambda { |a, b| puts "#{a}, #{b}" }
my_lambda.call(1, 2)   # => 1, 2 (OK)
my_lambda.call(1)      # => ArgumentError: wrong number of arguments!
my_lambda.call(1,2,3)  # => ArgumentError: wrong number of arguments!

차이 2: return 동작 — Lambda는 안전해!

# Proc의 return: 메서드 전체를 종료
def proc_return_test
  my_proc = Proc.new { return "Proc return" }
  my_proc.call
  "이 줄은 실행 안 됨"  # 실행 안 됨!
end

# Lambda의 return: Lambda 자체만 종료
def lambda_return_test
  my_lambda = lambda { return "Lambda return" }
  result = my_lambda.call  # Lambda만 종료, 메서드는 계속!
  puts "Lambda 결과: #{result}"
  "메서드 정상 종료"  # 이 줄도 실행됨!
end

puts proc_return_test    # => "Proc return"
puts lambda_return_test
# => Lambda 결과: Lambda return
# => 메서드 정상 종료

Lambda로 고차 함수 만들기

Lambda는 함수형 프로그래밍에서 빛을 발해:

# 함수를 반환하는 함수 (고차 함수)
def compose(f, g)
  ->(x) { f.call(g.call(x)) }
end

double = ->(x) { x * 2 }
add_one = ->(x) { x + 1 }

double_then_add = compose(add_one, double)
add_then_double = compose(double, add_one)

puts double_then_add.call(5)  # => 11  (5*2=10, 10+1=11)
puts add_then_double.call(5)  # => 12  (5+1=6, 6*2=12)

커링(Currying): Lambda의 강력한 기능

커링은 여러 인자를 받는 함수를 하나씩 인자를 받는 함수들의 체인으로 변환하는 거야:

add = ->(a, b) { a + b }

# curry로 커링된 함수 생성
curried_add = add.curry

add5 = curried_add.(5)   # 첫 번째 인자만 적용
puts add5.(3)             # => 8  (5 + 3)
puts add5.(10)            # => 15 (5 + 10)

# 실용적인 예: 세금 계산기
tax_calculator = ->(rate, price) { price * (1 + rate) }
vat_10 = tax_calculator.curry.(0.1)  # 10% 세율 고정

puts vat_10.(1000)  # => 1100.0
puts vat_10.(5000)  # => 5500.0

커링을 쓰면 코드 재사용성이 엄청 올라가! 함수형 프로그래밍의 핵심 기법이야. 🔥

🔬 클로저 심화: 변수 포획과 바인딩

클로저가 변수를 "포획"한다고 했는데, 이게 정확히 어떻게 동작하는지 더 깊이 파보자. Ruby에서 클로저는 변수의 값이 아니라 참조(reference)를 포획해. 이게 무슨 말이냐면...

변수 참조 포획의 의미

x = 10

my_proc = Proc.new { puts x }
my_proc.call  # => 10

x = 20  # x를 변경!
my_proc.call  # => 20  (변경된 값이 반영됨!)

봐봐! Proc이 만들어진 시점의 값(10)이 아니라, 현재 x의 값(20)을 출력해. 이건 Proc이 x라는 변수 자체를 참조하고 있기 때문이야. 값을 복사한 게 아니야!

Binding 객체

Ruby에는 Binding이라는 특별한 객체가 있어. 현재 스코프의 변수 환경을 캡처하는 거야:

def get_binding(value)
  x = value
  binding  # 현재 바인딩을 반환
end

b = get_binding(42)
puts b.eval("x")  # => 42  (메서드가 끝났는데도 x에 접근!)

# ERB 템플릿에서 많이 쓰임
require 'erb'
name = "Ruby"
template = ERB.new("안녕, <%= name %>!")
puts template.result(binding)  # => 안녕, Ruby!

클로저로 상태 관리하기

클로저를 이용하면 객체 없이도 상태를 관리할 수 있어:

def make_stack
  data = []
  
  push = ->(item) { data.push(item) }
  pop = -> { data.pop }
  peek = -> { data.last }
  size = -> { data.size }
  
  { push: push, pop: pop, peek: peek, size: size }
end

stack = make_stack

stack[:push].call(1)
stack[:push].call(2)
stack[:push].call(3)

puts stack[:peek].call  # => 3
puts stack[:size].call  # => 3
puts stack[:pop].call   # => 3
puts stack[:size].call  # => 2

이게 바로 함수형 프로그래밍 스타일의 상태 관리야! 클래스 없이도 데이터를 캡슐화할 수 있어. 멋지지 않아? 😎

메모이제이션(Memoization)과 클로저

클로저를 이용한 메모이제이션은 성능 최적화의 핵심 기법이야:

def memoize(func)
  cache = {}
  ->(n) {
    cache[n] ||= func.call(n)
  }
end

# 피보나치 수열 (느린 버전)
slow_fib = ->(n) {
  n <= 1 ? n : slow_fib.call(n-1) + slow_fib.call(n-2)
}

# 메모이제이션 적용
fast_fib = memoize(slow_fib)

puts fast_fib.call(10)  # => 55
puts fast_fib.call(20)  # => 6765
# cache가 클로저로 유지되어 이미 계산한 값을 재사용!