Bon, voilà LE truc qui m’ennuie en Ruby.
Ce n’est pas un gros problème, juste un non-raccourci qui pourrait être génial !

Un programme ruby est lu par l’interpréteur (et le plus souvent « compilé »).
Donc à partir de là on a accès à plein d’informations, mais pas au code des méthodes.
À quoi ça servirait ?

Je vois 2 choses :

1. Modifier à la volée une méthode.
   On peut déjà créer une méthode à l’exécution, et remplacer une méthode existante. Par contre on ne peut pas « modifier » une méthode.
   Je pense à la manière SmallTalk de coder : on lance le programme, et on code pendant l’exécution.
   À noter que pour cela, avoir les commentaires des méthodes serait un réel plus.
2. Sérialiser les blocs, les procs, et les classes générées/modifiée dynamiquement.
   Je mets en place mon environnement, puis j’exporte tout.
   Si on ne peut pas sérialiser une classe, je vois mal comment propager les classes générées.

Donc question : pourquoi les classes/méthodes/blocs ne sont-elles pas encore sérialisable ?

La réponse que j’imagine est que les Proc ne le sont pas, que les méthodes sont des formes de Proc et que les classes sont des Proc.
Donc pourquoi les Proc ne sont-elle pas sérialisables ?

Là je ne sais pas :/
En réfléchissant, on voit que les Proc sont des fermetures, donc qu’ils peuvent modifier des variables d’autres environnements.

Exemples:
def toto
var1 = 2
Proc.new { var1 += 1 }
end
ma_proc = toto # => toto est un générateur
ma_proc.call # => 3
ma_proc.call # => 4

On voit qu’il y a un problème ici : ma_proc est liée à la méthode toto.
On ne peut pas pas la sérialiser, car lors de la désérialisation, l’appel à var1 n’aura plus aucun sens.

La méthode employée par DRb pour le passage de bloc est de n’envoyer qu’un stub. Réponse logique : on ne peut pas envoyer l’objet, alors on le laisse sur place et les appels à ce bloc traverseront le réseau.

Moi j’aimerais ajouter quelque chose : un méthode de la classe Proc qui permet de savoir si un environnement autre est utilisé.
À partir de là c’est simple :

• Si c’est non, on ne dépend pas des autres environnement, donc peut sérialiser en tout quiétude.
• Si c’est oui, on a à faire à une fermeture qui s’affirme, donc on ne peut pas sérialiser et il faut envoyer un stub.

Ainsi on peut faire remote_enum.find {|el| … } sans que chaque exécution de notre bloc traverse le réseau.

Voilà, j’espère avoir été assez clair.
Cependant, peut-être qu’il existe déjà un moyen de résoudre ce problème et que je ne l’ai pas vu.
Des suggestions ?