Les blocs en Ruby

Bonjour !

Comme je l'avais dit sur le sujet concernant un tutoriel sur Ruby, je comptais faire un tutoriel expliquant le pourquoi du comment des blocs. J'ai donc écrit ce tutoriel que vous trouverez en bêta ici-même.

Si le fond du tutoriel me satisfait (en tant qu'auteur), je sens que quelque chose ne va pas trop au niveau des explications ou de la façon dont je l'ai écrit, mais je n'arrive pas à mettre le doigt dessus… Le voici donc tout prêt à se faire lyncher par tout le monde (n'hésitez pas).

Surtout, si quelque chose ne paraît pas (assez) clair, mérite plus de développement, dites-le. Si au contraire, certaines choses sont trop développées, dites-le aussi.

Merci beaucoup tout le monde !
Bisou

En toute première lecture, le premier paragraphe qui part sans avertissement sur une introduction à Haskell est un poil violant. Et du coup je suis remonté en haut de la page pour vérifier que c'etait bien dans le titre un cours sur Ruby.

N'aurais tu pas moyen de te passer de Haskell ? Je pense qu'a la fin de cette premiere partie tu as déjà perdu les 3/4 des lecteurs.

Je vois ! Oui, bien sûr, je peux tâcher de présenter ça autrement.
Merci du commentaire.

Bien le bonjour !

Comme suggéré, j'ai changé la première partie afin d'obtenir un cours plus simple à comprendre et plus… Ruby. Je suis ouvert à d'autre suggestions. Nouvelle bêta disponible ici.

Merci beaucoup !

Tant qu'a parler des Proc, pourquoi ne pas parler des lambdas ?

1
2
3
4
5
6
7

def f(func)
  func.call
end

f lambda { puts 'lambda'}
f -> { puts 'lambda' }
f Proc.new { puts 'Proc' }

La différence entre Proc et lambda semble se situer au niveau des valeurs retournées, et de leur comportement sur le nombre de paramètres attendus. Cette présentation résume a peu près ça

Il faudrait aussi parler des conversions lambda/Proc -> block

1
2
3
4
5
6
7
8
9

def f_block(&block)
  yield
end

lambda = -> { puts 'lambda' }
proc = Proc.new { puts 'Proc' }

f_block &lambda
f_block &proc

L'idée, c'est que j'utilise les Proc comme cheminement vers les blocs. J'essaie d'introduire la notion de fermeture en douceur. D'abord en ayant un objet bien concret (une Proc) puis en ayant une écriture "inline" de celui-ci (le bloc). Parler des lambdas est quelque chose de très intéressant, je pourrai m'y atteler dans un autre tuto éventuellement, mais ici, ça tire vers le hors sujet (dans le sens où je compte pas épiloguer sur les Proc).

Je parle des conversions Proc/bloc à la fin, mais si ce n'est pas assez visible, je vais faire un effort de clarté, new beta incoming.

Ok comme tu veux. J'ai parlé de ça puisque je ne vois pas grande différence entre lambda et Proc (mis a part ce qui est mentionné dans le lien du dessus). Du coup, ça ferait d'une pierre deux coups.

Sinon, il me semble que tu ne parle nul part du mot clé yield. Celui ci est utilisé dans du code, et une brève explication de son utilités serait appréciable. (Cela dit, les exemples sont assez clairs, ce n'est peut être pas nécessaire)

Maintenant, j'ai une petite question. A quoi sert la conversion Method -> Proc ? Puisque, en pratique, les deux semble fonctionner de la même manière.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def func(f, *args)
  f.call *args
end

def a(b, c)
  puts b*c
end

func(method(:a), 5, 5)
func(method(:a).to_proc, 5, 5)

La différence entre les deux m'a l'air d'être assez subtile. Si jamais quelqu'un peut éclairer ma lanterne

La différence entre Method et Proc est simplement que Method ne répond pas à new. Tu ne peux pas créer de Method à la volée. Pour le reste, une Method n'est finalement qu'une Proc (je peux me tromper, mais il me semble).

La conversion que je fais est une question de cohérence dans mes propos. Je parle de donner une Proc à manger et je donne une Method => pas cohérent. Partant du principe que le lecteur me croit sur parole et ne s'y connait pas en Proc, Method, Block, je fais une conversion explicite pour envoyer la Proc que j'ai promise auparavant. Cependant, en ne prenant en compte que le fonctionnement du programme, tu as raison.

Le mot-clef yield est mis en avant juste au-dessus de la conversion Proc/bloc. Mais de même, je vais rajouter un paragraphe pour mettre tout le monde d'accord.

Merci des feedbacks au fait.

La question sur la différence Proc/Method était de la curiosité, je ne te reprochais pas d'avoir fait comme tu as fait

A priori je n'ai rien d'autre à redire. Peut être ajouter un TP à la fin. Je pense par exemple a l'implémentation d'une classe répondant à each, par exemple un tableau trié ou une liste chainée.

PS : je ne l'ai pas encore dit, mais chouette tuto. Ça me donne envie d'en faire un du même acabit, court, simple et concis.

Je sais, ce fut un plaisir

Hummm, non, si vraiment la plèbe veut des exercices, autant ouvrir un thread "Exercices Ruby" sur le forum, ce serait plus propre je trouve.

Merci !