iX -- Perl 6 Tutorial - #121257 (Raku / Perl 6)

moritz

2009-05-05 21:19

User since
2007-05-11
923 Artikel
HausmeisterIn

2009-05-05T17:36:10 sid burn
2009-05-05T08:09:37 moritz
Wenn du Junctions als Menge auffassen willst, erzeugt ein binaerer Operator also das karthesische Produkt von zwei Mengen.

Hallo, der Satz war eher das entscheidene.

Für mich nochmal zusammengfest. Also bei Operatoionen auf Junctions, werden praktisch alle Werte der Junction bearbeitet. Das Ergebnis ist immer wieder auch eine neue Junction. Wird mit zwei Junctions operiert, wird wie du sagtest das kathesiche Produkt gebildet. Also jeder wird mit jedem anderen Wert Multipliziert. aus 2|3|4 * 2|3|4 wird dann praktisch:

2 * 2 = 4
2 * 3 = 6
2 * 4 = 8
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
4 * 2 = 8
4 * 3 = 12
4 * 4 = 16

Richtig soweit. Wichtig dabei ist, dass es eben nicht nur eine Menge von Zahlen ist, sondern dass zu der Menge noch ein Kollapsverhalten gibt - hier any().

Quote
Die resultierende Junction ist dann 4|6|8|6|9|12|8|12|16 und mit dieser neuen Junction wird der vergleich gemacht. Wenn natürlich autothreading an ist, oder implementiert ist, wird das ganze parallelisiert auf mehrere Threads verteilt.

Der Vorgang heisst immer "autothreading", egal ob es parallelisiert ist oder nicht.

Quote
Zumindest kann ich mir so jetzt die any() * any() verknüpfung erklären. Allerdiengs hackt es bei mir noch bei deiner verkürzung die du im Artikel geschrieben hast.
Code: (dl )
1
2
3
sub primetest(Int $n) {
    none(2..$n-1) * any(2..$n-1) == $n
}
Um es mal selber zu versuchen. Es wird wieder das kathesiche produkt gebildet. genauso wie bei einem any() * any(). Das ergebnis ist das gleiche, aber alle werte enthalten praktisch immer noch eine negierung.

Das ist nicht ganz so einfach. Die Negierung ist nicht in den Werten, sondern im Kollapsverhalten

Wenn du any(...)*any(...) bildest, dann wird daraus eine any()-Junction, die weitere any()-Junctions enthält, deren Werte die Produkte sind. Ineinandergeschachtelte Junctions gleichen Typs kann man abflachen, also any(1, any(2)) ist das gleiche wie any(1, 2).

Wenn du none(...)*any(...) bildest, dann wird daraus eine none-Junction, in der Any-Junctions stehen, deren Werte die Produkte sind. Allerdings kann man Junctions, die aus verschiedenen Typen bestehen, nicht abflachen.

Spielen wir mal einen einfachen Fall durch, $n = 4.
Dann finden also intern folgende Umformungen statt:

Code: (dl )

none(2, 3) * any(2, 3) == 4
# autothreading über den *, zweites Argument
=> none(2 * any(2, 3), 3 * any(2, 3)) == 4
# autothreading über den *, erstes Argument
=> none(any(2*2, 2*4), any(3*2, 3*3)) == 4
# autothreading über das ==
=> none(any(4, 8) == 4, any(6, 9) == 4)
=> none(any(4 == 4, 8 == 4), any(6 == 4, 9 == 4))
=> none(any(True, False), any(False, False))

So, jetzt ist die Junction fertig. Wenn das ganze im Boolschen Kontext ausgewertet wird, kollabiert die Junction

Code: (dl )

1
2
3

none(any(True, False), any(False, False))
=> none(True, False)
=> False

Quote
Wenn also verglichen wird und das ergebnis mit == $n wahr ist, wird es wegen dem none() nochmals negiert wodurch es dann falsch wird?

Fast, siehe Oben. Nicht der Vergleich ist das besondern, über das == findet das Autothreading genauso statt wie über die Multiplikation. Der Boolsche Kontext sorgt am Ende für die Auswertung (und damit die Negation).

Perl 6 - Perls Zukunft