J'ai du mal à comprendre quand et pourquoi la valeur détenue par un Scalar
conteneur poussé est affectée après la poussée. Je vais essayer d'illustrer le problème que j'ai rencontré dans un contexte plus compliqué dans deux exemples stylisés.
* Exemple 1 * Dans le premier exemple, un scalaire $i
est poussé sur un tableau @b
dans le cadre de a List
. Après le push, la valeur détenue par le scalaire est explicitement mise à jour dans les itérations ultérieures de la boucle for à l'aide de l' $i++
instruction. Ces mises à jour ont un effet sur la valeur du tableau @b
: à la fin de la boucle for, @b[0;0]
est égal à 3
et non plus 2
.
my @b;
my $i=0;
for 1..3 -> $x {
$i++;
say 'Loose var $i: ', $i.VAR.WHICH, " ", $i.VAR.WHERE;
if $x == 2 {
@b.push(($i,1));
say 'Pushed $i : ', @b[0;0].VAR.WHICH, " ", @b[0;0].VAR.WHERE;
}
}
say "Post for-loop";
say "Array : ", @b;
say 'Pushed $i : ', @b[0;0].VAR.WHICH, " ", @b[0;0].VAR.WHERE;
Exemple de sortie 1:
Loose var $i: Scalar|94884317665520 139900170768608
Loose var $i: Scalar|94884317665520 139900170768648
Pushed $i : Scalar|94884317665520 139900170768648
Loose var $i: Scalar|94884317665520 139900170768688
Post for-loop
Array : [(3 1)]
Pushed $i : Scalar|94884317665520 139900170768688
* Exemple 2 * Dans le deuxième exemple, le scalaire $i
est la variable de boucle. Même si $i
est mis à jour après avoir été poussé (maintenant implicitement plutôt qu'explicitement), la valeur de $i
in array @c
ne
change pas après la poussée; c'est-à-dire après la boucle for, ce n'est toujours 2
pas le cas 3
.
my @c;
for 1..3 -> $i {
say 'Loose var $i: ', $i.VAR.WHICH, " ", $i.VAR.WHERE;
if $i == 2 {
@c.push(($i,1));
say 'Pushed $i : ', @c[0;0].VAR.WHICH, " ", @c[0;0].VAR.WHERE;
}
}
say "Post for-loop";
say "Array : ", @c;
say 'Pushed $i : ', @c[0;0].VAR.WHICH, " ", @c[0;0].VAR.WHERE;;
Exemple de sortie 2:
Loose var $i: Scalar|94289037186864 139683885277408
Loose var $i: Scalar|94289037186864 139683885277448
Pushed $i : Scalar|94289037186864 139683885277448
Loose var $i: Scalar|94289037186864 139683885277488
Post for-loop
Array : [(2 1)]
Pushed $i : Scalar|94289037186864 139683885277448
Question: Pourquoi $i
dans @b
l'exemple 1 mis à jour après la poussée, alors que $i
dans @c
l'exemple 2 n'est pas?
edit : Suite au commentaire de @ timotimo, j'ai inclus la sortie de .WHERE
dans les exemples. Cela montre que l'identité scalaire (WHICH / logique) $i
reste la même, tandis que son adresse mémoire change à travers les différentes itérations de boucle. Mais cela n'explique pas pourquoi dans l'exemple 2 le scalaire poussé reste lié à la même identité QUI en combinaison avec une ancienne adresse ("448).
la source
.WHERE
place de.WHICH
vous pouvez voir que le scalaire est en fait un objet différent à chaque fois autour de la boucle. Cela se produit car les blocs pointus sont "appelés" et la signature est "liée" à chaque appel.Réponses:
Une valeur scalaire n'est qu'un conteneur. Vous pouvez les considérer comme une sorte de pointeur intelligent, plutôt que comme une valeur primitive.
Si vous faites une mission
vous modifiez la valeur scalaire, le conteneur reste le même.
Considérer
et
Les deux fonctionnent comme prévu. Mais: Dans les deux cas, la chose dans la liste n'est plus modifiable, car il n'y a pas de conteneur.
mourra donc. Alors, utilisez simplement la variable de boucle, non?
Non.
même si nous parcourons une liste de choses mutables.
Il n'y a donc pas d'aliasing ici, à la place la variable de boucle est toujours le même conteneur et obtient des valeurs attribuées provenant des autres conteneurs.
Nous pouvons cependant le faire.
Une façon de rendre "la chose" mutable est d'utiliser une variable intermédiaire.
fonctionne bien. Ou plus court et plus dans le contexte d'origine
Voir également:
https://perl6advent.wordpress.com/2017/12/02/#theoneandonly https://docs.perl6.org/language/containers
la source
($x,1)
, vous pouvez aussi faire ce[$x,1]
qui pourrait créer un nouveau conteneur (aussi1
, d' ailleurs)Int
objet ->Int
est remplacé dans la boucle -> le conteneur pointe vers nouveauInt
), mais pas le second.Après avoir joué avec et réfléchi à ma question ci-dessus pendant un certain temps, je parierai une réponse ... C'est une pure conjecture de ma part, alors n'hésitez pas à dire que c'est insensé si c'est le cas, et si vous le savez, Pourquoi...
Dans le premier exemple,
$i
est défini en dehors de la portée lexicale de la boucle for. Par conséquent,$i
existe indépendamment de la boucle et de ses itérations. Quand$i
est référencé depuis l'intérieur de la boucle, il n'y en a qu'un seul$i
qui peut être affecté. C'est cela$i
qui est poussé@b
et dont le contenu est modifié par la suite dans la boucle.Dans le deuxième exemple,
$i
est défini à l'intérieur de la portée lexicale de la boucle for. Comme l'a souligné @timotimo, le bloc pointé est appelé pour chaque itération, comme un sous-programme;$i
est donc fraîchement déclaré pour chaque itération, et étendu au bloc respectif. Quand$i
est référencé à l'intérieur de la boucle, la référence est au bloc-itération spécifique$i
, qui cesserait normalement d'exister lorsque l'itération de boucle respective se termine. Mais parce qu'à un moment donné$i
est poussé à@c
, la référence au bloc spécifique à l' itération la$i
valeur de maintien2
ne peut être supprimé par le garbage collector après la fin de l'itération. Il restera en existence ..., mais restera différent des$i
versions ultérieures.la source