Quand vous exécutez une commande à l'échelle d'un groupe, qui peut être un appel de fonction ou une affectation, la commande sera propagée en parallèle à chaque membre du groupe et à leurs sous-groupes. Cela s'appelle la diffusion (ou broadcast). Cela peut s'appliquer aussi aux classes, puisque vous pouvez définir un groupe contenant chaque instanciation de classe-fille. Une approche habituelle est de nommer le groupe associé à une classe avec le pluriel du nom de la classe, en ajoutant un simple "s".

Tout d'abord, observons comment une affectation est diffusée:

class a;
a1 = new a;
group as {a,a1};
a1.x = 42;
as.x = 4;
a.x;
[139464:notag] 4.000000
a1.x;
[146711:notag] 4.000000

La diffusion fonctionne de manière similaire avec les fonctions:

class a {
  var x;
  function f();
};

function a.f() {
  echo x;
};
a1 = new a;
group as {a,a1};
a.x = 1;
a1.x = 2;
as.f();
[139464:notag] *** 1.000000
[139464:notag] *** 2.000000

La fonction précédente f est en réalité exécutée de la façon suivante:

a.f() & a1.f();

Diffuser revient donc à dupliquer les commandes en parallèle.

Les sous-groupes sont naturellement parcourus dans le processus.

Les fonctions diffusées peuvent s'avérer très utiles pour exécuter des tâches en parallèle dans un groupe d'objets, sans avoir à utiliser for& ou une construction similaire. La diffusion et l'héritage se complètent mutuellement, ainsi quand la diffusion est achevée, la définition de la fonction peut être recherchée en remontant dans la hiérarchie de classe, comme dans l'exemple suivant:

class a {
  var x;
  function init(v);
  function f();
};
function a.init(v) { x=v; };
function a.f() {
  echo x;
};
a1 = new a(1);
a2 = new a(2);
a3 = new a(3);
function a1.f() { echo "Je suis différent !"};
group unetdeux {a1,a2};
unetdeux.f();
[139464:notag] *** 2.000000
[139464:notag] *** Je suis différent !

La diffusion est clairement un concept nouveau dans les mains des programmeurs. Vous pouvez l'utiliser ou non, mais nous croyons que cela permettra d'obtenir des programmes plus concis, en regroupant les actions logiques en une ligne, au lieu d'utiliser des boucles for ou un concept itératif similaire. Cela renforce également l'idée que certaines actions doivent être exécutées en parallèle sur un groupe d'objets, ce qui peut rend votre code plus sensé.