Computer >> 컴퓨터 >  >> 프로그래밍 >> Ruby

루비 클로저 완벽 이해하기: 블록, 프로시저, 람다의 차이점

루비 매직(Ruby Magic) 시리즈에서는 우리가 매일 사용하는 기능들 뒤에 숨겨진 마법을 파헤쳐 그 동작 원리를 이해하는 것을 좋아합니다. 이번 에피소드에서는 블록(Block), 프로시저(Proc), 람다(Lambda) 사이의 차이점을 자세히 살펴보겠습니다.

일급 함수(first-class function)를 지원하는 프로그래밍 언어에서는 함수를 변수에 저장하거나 다른 함수의 인자로 전달할 수 있습니다. 심지어 함수가 다른 함수를 반환값으로 사용하는 것도 가능합니다.

클로저(closure)란 환경(environment)을 가진 일급 함수를 말합니다. 여기서 환경이란 클로저가 생성된 시점에 존재하던 변수들에 대한 매핑을 의미합니다. 클로저는 해당 변수들이 다른 스코프에 정의되어 있더라도 이 변수들에 대한 접근 권한을 계속 유지합니다.

루비에는 엄밀한 의미의 일급 함수는 없지만, 대신 블록, 프로시저, 람다라는 형태의 클로저가 존재합니다. 블록은 코드 조각을 메서드에 전달할 때 사용되고, 프로시저와 람다는 코드 블록을 변수에 저장할 수 있게 해줍니다.

블록(Block)

루비에서 블록은 나중에 실행하기 위해 만들어 두는 코드 조각입니다. 블록은 메서드에 전달되며, 메서드 내부에서 do와 end 키워드 사이의 코드를 yield로 실행합니다. 가장 대표적인 예시가 열거 가능한 객체(enumerable)를 순회하는 #each 메서드입니다.

[1,2,3].each do |n|
  puts "#{n}!"
end
 
[1,2,3].each { |n| puts "#{n}!" } # 한 줄로 표현한 동일한 코드

이 예제에서는 블록이 Array#each 메서드에 전달되며, 각 배열 요소마다 블록이 실행되어 콘솔에 값이 출력됩니다.

def each
  i = 0
  while i < size
    yield at(i)
    i += 1
  end
end

위의 단순화된 Array#each 구현 예제에서 while 루프 안에서 yield가 호출되어, 배열의 모든 요소에 대해 전달된 블록이 실행됩니다. 주목할 점은 이 메서드에 인자가 없다는 것입니다. 블록은 암묵적으로 메서드에 전달되기 때문입니다.

암묵적 블록 전달과 yield 키워드

루비에서 메서드는 블록을 암묵적(implicit)으로도, 명시적(explicit)으로도 받을 수 있습니다. 암묵적 블록 전달은 메서드 내부에서 yield 키워드를 호출하는 방식으로 동작합니다. yield 키워드는 특별한 키워드로, 전달된 블록을 찾아 호출해 줍니다. 따라서 블록을 메서드의 인자 목록에 직접 추가할 필요가 없습니다.

루비는 암묵적 블록 전달을 허용하기 때문에, 어떤 메서드든 블록과 함께 호출할 수 있습니다. 메서드 내부에서 yield를 호출하지 않으면 전달된 블록은 simply 무시됩니다.

irb> "foo bar baz".split { p "block!" }
=> ["foo", "bar", "baz"]

반면 호출된 메서드가 실제로 yield를 한다면, 전달된 블록이 발견되어 yield에 넘긴 인자들과 함께 호출됩니다.

def each
  return to_enum(:each) unless block_given?
 
  i = 0
  while i < size
    yield at(i)
    i += 1
  end
end

이 예제는 블록이 전달되지 않은 경우 Enumerator 인스턴스를 반환합니다.

yield와 block_given? 키워드는 현재 스코프에서 블록을 찾습니다. 이 덕분에 블록을 암묵적으로 전달할 수 있지만, 블록이 변수에 저장되지 않기 때문에 코드에서 블록에 직접 접근할 수 없다는 한계도 있습니다.

명시적으로 블록 전달하기

메서드에서 블록을 명시적으로 받으려면 앰퍼샌드(&) 파라미터(보통 &block이라 부름)를 인자로 추가하면 됩니다. 블록이 이제 명시적이 되었으므로, yield에 의존하는 대신 결과 객체에 바로 #call 메서드를 사용할 수 있습니다.

&block 인자는 일반적인 인자가 아니므로, 블록 외의 다른 것으로 이 메서드를 호출하면 ArgumentError가 발생합니다.

def each_explicit(&block)
  return to_enum(:each) unless block
 
  i = 0
  while i < size
    block.call at(i)
    i += 1
  end
end

이렇게 전달된 블록이 변수에 저장되면, 자동으로 프로시저(proc)로 변환됩니다.

프로시저(Proc)

"프로시저"는 Proc 클래스의 인스턴스로, 실행할 코드 블록을 담고 있으며 변수에 저장할 수 있습니다. 프로시저를 생성하려면 Proc.new를 호출하고 블록을 전달하면 됩니다.

proc = Proc.new { |n| puts "#{n}!" }

프로시저는 변수에 저장할 수 있으므로, 일반 인자처럼 메서드에 전달하는 것도 가능합니다. 이 경우 프로시저가 명시적으로 전달되므로 앰퍼샌드를 사용하지 않습니다.

def run_proc_with_random_number(proc)
  proc.call(random)
end
 
proc = Proc.new { |n| puts "#{n}!" }
run_proc_with_random_number(proc)

프로시저를 미리 만들어 메서드에 전달하는 대신, 앞서 살펴본 루비의 앰퍼샌드 파라미터 문법을 활용해 블록을 직접 넘기는 방법도 있습니다.

def run_proc_with_random_number(&proc)
  proc.call(random)
end
 
run_proc_with_random_number { |n| puts "#{n}!" }

메서드 인자에 앰퍼샌드가 추가된 것에 주목하세요. 이렇게 하면 전달된 블록이 프로시저 객체로 변환되어 메서드 스코프의 변수에 저장됩니다.

팁: 특정 상황에서는 메서드 안에서 프로시저를 갖고 있는 것이 유용하지만, 블록을 프로시저로 변환하는 과정에서 성능 저하가 발생합니다. 가능하다면 암묵적 블록을 사용하는 것이 좋습니다.

#to_proc

심볼(Symbol), 해시(Hash), 메서드는 각자의 #to_proc 메서드를 통해 프로시저로 변환될 수 있습니다. 가장 자주 볼 수 있는 활용 예는 심볼로부터 생성된 프로시저를 메서드에 전달하는 것입니다.

[1,2,3].map(&:to_s)
[1,2,3].map {|i| i.to_s }
[1,2,3].map {|i| i.send(:to_s) }

이 예제는 배열의 각 요소에 대해 #to_s를 호출하는 세 가지 동등한 방법을 보여줍니다. 첫 번째 방식에서는 앰퍼샌드가 붙은 심볼이 전달되는데, 이때 #to_proc 메서드가 호출되어 자동으로 프로시저로 변환됩니다. 마지막 두 줄은 그 프로시저가 내부적으로 어떻게 동작하는지를 보여주는 것입니다.

class Symbol
  def to_proc
    Proc.new { |i| i.send(self) }
  end
end

단순화된 예제이지만, Symbol#to_proc의 구현을 통해 내부에서 무슨 일이 일어나는지 확인할 수 있습니다. 이 메서드는 하나의 인자를 받아 self를 전송(send)하는 프로시저를 반환합니다. 이 맥락에서 self는 심볼이므로, 결국 Integer#to_s 메서드가 호출되는 것입니다.

람다(Lambda)

람다는 본질적으로 몇 가지 차별화된 특징을 가진 프로시저입니다. 람다는 두 가지 측면에서 "일반적인" 메서드에 더 가깝습니다. 바로 호출 시 인자 개수를 엄격하게 검사하고, "일반적인" 방식으로 반환한다는 점입니다.

인자를 기대하는 람다를 인자 없이 호출하거나, 인자를 받지 않는 람다에 인자를 전달하면 루비는 ArgumentError를 발생시킵니다.

irb> lambda (a) { a }.call
ArgumentError: wrong number of arguments (given 0, expected 1)
        from (irb):8:in `block in irb_binding'
        from (irb):8
        from /Users/jeff/.asdf/installs/ruby/2.3.0/bin/irb:11:in `<main>'

또한 람다는 return 키워드를 메서드와 동일한 방식으로 처리합니다. 프로시저를 호출하면 프로그램의 제어권이 프로시저 내부의 코드 블록으로 넘어갑니다. 따라서 프로시저가 반환되면 현재 스코프도 함께 반환됩니다. 즉, 함수 내부에서 프로시저가 호출되고 그 프로시저가 return을 호출하면, 그 함수 역시 즉시 반환됩니다.

def return_from_proc
  a = Proc.new { return 10 }.call
  puts "This will never be printed."
end

이 함수는 제어권을 프로시저에 넘기므로, 프로시저가 반환되는 순간 함수 자체도 반환됩니다. 따라서 이 예제의 함수를 호출하면 출력문은 절대 실행되지 않고 10을 반환합니다.

def return_from_lambda
  a = lambda { return 10 }.call
  puts "The lambda returned #{a}, and this will be printed."
end

반면 람다를 사용하면 출력문이 실제로 실행됩니다. 람다 안에서 return을 호출하는 것은 메서드 안에서 return을 호출하는 것과 같은 방식으로 동작하기 때문에, 변수 a에는 10이 할당되고 해당 문장이 콘솔에 출력됩니다.

블록, 프로시저, 람다 정리

블록, 프로시저, 람다를 깊이 있게 살펴봤으니, 이제 다시 한 걸음 물러나 핵심 내용을 비교·정리해 보겠습니다.

  • 블록은 루비에서 코드 조각을 함수에 전달할 때 폭넓게 사용됩니다. yield 키워드를 사용하면 블록을 프로시저로 변환하지 않고도 암묵적으로 전달할 수 있습니다.
  • 앰퍼샌드가 붙은 파라미터를 사용하면, 메서드에 블록을 전달했을 때 메서드의 컨텍스트 안에서 프로시저가 됩니다. 프로시저는 블록처럼 동작하지만 변수에 저장할 수 있다는 차이가 있습니다.
  • 람다는 메서드처럼 동작하는 프로시저입니다. 즉, 인자 개수(arity)를 엄격하게 검사하고, 부모 스코프가 아닌 자기 자신의 범위에서 메서드처럼 반환합니다.

이것으로 루비의 클로저에 대한 탐구를 마무리합니다. 어휘적 스코프(lexical scope)와 바인딩(binding)처럼 클로저에 대해 더 배울 내용이 많지만, 이는 다음 에피소드로 남겨두겠습니다. 그동안 루비 매직의 다음 회차에서 읽고 싶은 주제가 있다면 @AppSignal을 통해 알려주세요.