La rolls des blogs

( For non-french readers : I am not giving up writing in english … Read the next post! )

Si vous venez d’un autre langage, le terme procédure (associé au terme fonction) doit vous dire quelque chose. Vaguement ….

Allez quelques connaissances (méconnaissances) tirées de ma mémoire pour poser les bases.

Par exemple, en PHP il existe deux types de fonctions. Les fonctions natives (built-in) et les fonctions “codées” par l’utilisateur.
Ces dernières se séparent en deux types : les fonctions et les procédures.

La différence entre les deux ? Une procédure est un groupe d’instructions qui ne renvoie pas de valeur. Une fonction est une procédure qui renvoie une valeur.

Et ruby dans tout ça ??

C’est complètement différent et je dirai même plus les procédures Ruby sont très éloignés des procédures PHP. En ruby il n’y a que des objets (les méthodes sont des objets) et les méthodes renvoient toujours une valeur.
Vous avez déjà vu ou même codé des choses comme ceci :

[1,2,3,4,5,6].each do |nb|
  # Un code quelconque : des instructions ...
end

C’ette méthode est native à Enumerable (module que la classe Array inclut)
La méthode Array#each prend 0 paramètre mais un block. Le block est tout ce qui se trouve entre do et end.
On pourrait le représenter en Ruby comme ceci :

def each(&block)
  # Un truc compliqué à écrire en ruby
end

Ne vous y trompez pas “&block” n’est pas un argument. C’est la notation ruby pour dire que la méthode each s’accompagne obligatoirement d’un block.

Autre exemple :

class Bar
 
  def my_proc(&procedure)
     @foo_proc = procedure
  end
 
  def recall
    @foo_proc.call
  end
end
 
bar = Bar.new
bar.my_proc do
# Pas de code
end
 #=> #<Proc:0x00000>

Il se trouve que la procédure est une instance de la classe Proc.
Sans trop de surprise mêmes les procédures sont des objets. Et oui, en ruby tout est objet.

Quel est l’intérêt me direz-vous?

Cela change tout !!! En PHP les prcoédures sont codées en dur, en ruby on peut générer à la volée des suites d’instructions sans pour autant avoir à implémenter une méthode !!!

Illustration :

On sait que les blocks sont des instances de la classe Proc. La solution est facile, il suffit de créer des instances de Proc et les passer comme blocks d’une méthode acceptant un block.

p1 = Proc.new do
 puts "Je suis p1"
end
 
p2 = Proc.new do
  puts "Je suis p2"
end
 
bar = Bar.new
bar.my_proc(&p1)
# Je suis p1
#=> nil
bar.foo_proc 
#=> #<Proc:0x164564ab>
 
bar.recall
# Je suis p1
#=> nil
 
bar.my_proc(&p2)
# Je suis p2
#=> #<Proc:0x054ecdab>
 
bar.recall
# Je suis p2
#=> nil
 
bar2 = Bar.new
bar2.my_proc(&p2)
# Je suis p2
#=> #<Proc:0x054ecdab>
 
bar2.instance_eval("@foo_proc") == bar.instance_eval("@foo_proc") 
#=> true

Vous avez compris l’intérêt? Les blocks sont bien des suites d’instructions mais plus que cela, ce sont des objets !!! L’illustration précédente montre qu’on peut partager des suites d’instructions entre différents objets, générer ces instructions dynamiquement !

En route pour la méta-programmation avec Ruby !!!