Procs y Lambdas

Parte de la sección Lógica y flujo del Journey de Ruby de Coddy — lección 19 de 56.

Un bloque no es un objeto, no puedes guardarlo en una variable. Cuando quieres una porción de código que puedas pasar de un lado a otro, guardar y llamar más tarde, lo envuelves en un Proc o un lambda.

Un Proc se crea con Proc.new o la palabra clave proc. Llámalo con .call:

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

Una lambda es similar pero más estricta, comprueba que pases el número correcto de argumentos. La forma de flecha -> es la grafía común:

square = ->(n) { n * n }
puts square.call(4)   # 16
puts square.(4)       # 16  (abreviatura de .call)

Ambos pueden pasarse a un método que espera un bloque anteponiendo &:

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

Usa una lambda cuando quieras una comprobación de argumentos más estricta; usa un Proc cuando quieras un comportamiento más ligero y permisivo.

Desafío

Fácil

Crea una lambda llamada tripler que reciba un número y lo devuelva multiplicado por 3.

Luego lee una lista de enteros separados por comas e imprime, en líneas separadas:

El resultado de llamar a tripler.call(10)
Los números de entrada triplicados (usa map(&tripler)) y unidos con ,

Para la entrada 1,2,3, la salida es:

30
3, 6, 9

Hoja de referencia

Proc – bloque reutilizable almacenado en una variable:

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

Lambda – comprobación de argumentos más estricta, sintaxis de flecha:

square = ->(n) { n * n }
square.call(4)   # 16
square.(4)       # 16 (abreviatura)

Pasa un Proc/lambda a un método que espera un bloque usando &:

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

Pruébalo tú mismo

# TODO: definir `tripler` como un lambda

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

# TODO: línea 1, imprimir tripler.call(10)
# TODO: línea 2, mapear numbers con &tripler, unir con ", "