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 ultérieurement, vous l’encapsulez dans un Proc ou un 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

Une lambda est similaire, mais plus stricte : elle vérifie que vous transmettez le bon nombre d’arguments. La forme fléchée -> est la notation 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éfixant avec & :

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

Utilisez une lambda lorsque vous souhaitez une vérification plus stricte des arguments ; utilisez un Proc lorsque vous souhaitez un comportement plus souple et plus indulgent.

Défi

Facile

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

Lisez ensuite une liste d’entiers séparés par des virgules et affichez, sur des lignes distinctes :

Le résultat de l’appel à tripler.call(10)
Les nombres saisis multipliés par 3 (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, mapper numbers avec &tripler, joindre avec ", "