Procs e Lambdas

Parte da seção Lógica e Fluxo do Journey de Ruby da Coddy — lição 19 de 56.

Um bloco não é um objeto, você não pode armazená-lo em uma variável. Quando você quer um pedaço de código que possa passar adiante, salvar e chamar mais tarde, você o envolve em um Proc ou um lambda.

Um Proc é criado com Proc.new ou a palavra-chave proc. Chame-o com .call:

double = proc { |n| n * 2 }
puts double.call(5)   # 10
puts double.call(7)   # 14

Uma lambda é semelhante, mas mais rigorosa; ela verifica se você passa o número correto de argumentos. A forma de seta -> é a grafia comum:

square = ->(n) { n * n }
puts square.call(4)   # 16
puts square.(4)       # 16  (abreviação para .call)

Ambos podem ser passados para um método que espera um bloco prefixando com &:

[1, 2, 3].map(&double)   # [2, 4, 6]
[1, 2, 3].map(&square)   # [1, 4, 9]

Use uma lambda quando você quiser uma verificação de argumentos mais rigorosa; use uma Proc quando quiser um comportamento mais leve e flexível.

Desafio

Fácil

Crie uma lambda chamada tripler que recebe um número e o retorna multiplicado por 3.

Em seguida, leia uma lista de inteiros separados por vírgula e imprima, em linhas separadas:

O resultado da chamada tripler.call(10)
Os números de entrada triplicados (use map(&tripler)) e unidos com ,

Para a entrada 1,2,3, a saída é:

30
3, 6, 9

Folha de consulta

Proc – bloco reutilizável armazenado em uma variável:

double = proc { |n| n * 2 }
double.call(5)   # 10

Lambda – verificação de argumentos mais rigorosa, sintaxe de seta:

square = ->(n) { n * n }
square.call(4)   # 16
square.(4)       # 16 (abreviação)

Passe um Proc/lambda para um método que espera um bloco usando &:

[1, 2, 3].map(&double)   # [2, 4, 6]

Experimente você mesmo

# TODO: definir `tripler` como uma lambda

numbers = gets.chomp.split(",").map(&:to_i)

# TODO: linha 1, imprimir tripler.call(10)
# TODO: linha 2, mapear numbers com &tripler, unir com ", "