Les blocs en Ruby

{ |tuto| tuto.to_beta }

a marqué ce sujet comme résolu.
Auteur du sujet

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

+0 -0

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.

+1 -0

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

Édité par GaaH

+0 -0
Auteur du sujet

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.

+0 -0

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 :)

+0 -0
Auteur du sujet

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. :)

+0 -0

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.

+0 -0
Auteur du sujet

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

GaaH

Je sais, ce fut un plaisir :)

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.

GaaH

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.

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.

GaaH

Merci !

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte