Procs et Lambdas

Fait partie de la section Logique et Flux du Journey Ruby de Coddy. Leçon 19 sur 56.

Un bloc n'est pas un objet, vous ne pouvez pas le stocker dans une variable. Lorsque vous voulez un morceau de code que vous pouvez transmettre, enregistrer et appeler plus tard, vous l'enveloppez dans un Proc ou une lambda.

Un Proc est créé avec Proc.new ou le mot-clé proc. Appelez-le avec .call :

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

Un lambda est similaire mais plus strict, il vérifie que vous passez le bon nombre d'arguments. La forme avec flèche -> est la syntaxe courante :

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

Les deux peuvent être transmis à une méthode qui attend un bloc en les préfaçant par & :

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

Utilisez un lambda quand vous voulez une vérification des arguments plus stricte ; utilisez un Proc quand vous voulez un comportement plus léger et plus tolérant.

Défi

Facile

Créez une lambda nommée tripler qui prend un nombre et le renvoie multiplié par 3.

Ensuite, lisez une liste d'entiers séparés par des virgules et affichez, sur des lignes séparées :

Le résultat de l'appel tripler.call(10)
Les nombres en entrée triplés (utilisez map(&tripler)) et joints avec ,

Pour l'entrée 1,2,3, la sortie est :

30
3, 6, 9

Essayez vous-même

# TODO: définir `tripler` comme un lambda

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

# TODO: ligne 1, afficher tripler.call(10)
# TODO: ligne 2, map numbers avec &tripler, joindre avec ", "