Alles was vor einer Zuweisung einer volatile Variable im Code steht passiert vorher und umgekehrt. Wenn du nur volatile Variablen verwendest (oder in jeder zweiten Zeile), ist die Reihenfolge entsprechend fest.
Jopp, bin jetzt auch bei den Lambda Kalkül Folien angekommen, da steht das bei der alpha-Konversion extra dabei [keine freien Variablen]. Und bulsa hats ja mittlerweile im andern Thread verlinkt.
Wie die Abstraktionen zustande kommen, das ist mir zwar halbwegs klar, aber wie kommt man bitte auf die Applikationen?
Trete da gerade auf der Stelle… :-/
Im Prinzip sind die Applikationen alles, was ohne “.” aufeinander angewendet wird. Zum Beispiel eben “Hans” auf “Wurst” oder der ganze Ausdruck “(\ Wurst Salat. Hans Wurst)” auf “Kraut”. Aber vorsicht: “Kraut” auf “Wurst” ist falsch, denn die Applikation ist linksassoziativ und vor “Kraut” steht ja noch was da! Das bedeutet: Schau links vor “Kraut” nach der Funktion, die darauf angewendet wird. Erst wenn du die gefunden hast (und sie auf “Kraut” angewendet hast), kannst du das Resultat auf “Wurst” loslassen.
1: len/2
2: s+=a
3: leer
4: b.await()
5:
for (int i = 0; i < len -1; i+=2) {
t.join()
}
A4. Schreibtischlauf
a) 2, 4, 5
b) 1, 4, 5
c) 2<1; 5<4; 5<1
d) 8
e) 6
f) 8, wie bei d), da eigenständige Objekte
A5. Mengen (hier Scala Listen)
a)
def einfuegen: Int => List[Int] => List[Int] = {
x => ls => ls match {
case Nil => List(x)
case ls => if (ls.contains(x)) ls else x::ls
}
}
b)
def entfernen: Int => List[Int] => List[Int] = {
x => ls => ls match {
case Nil => Nil
case l::ls => if (x==l) ls else l::entfernen(x)(ls)
}
}
c)
def einfach: List[Int] => List[Int] => List[Int] = {
xs => ys => (xs, ys) match {
case (Nil, Nil) => Nil
case (xs, Nil) => xs
case (Nil, ys) => ys
case (x::xs, y::ys) => if (x==y) einfach(xs)(ys) else x::y::einfach(xs)(ys)
}
}
also ich bin mir zwar selber nicht ganz sicher, bei der Aufgabe 3 aber "2: s+=a " sollte eigentlich nicht funktionieren oder sehe ich das falsch? Denn a=i , und i =0 beim ersten Schleifendurchlauf, deshalb a=0, s= s+a entspricht somit s=s+0 = s und somit müsste das doch eine endloschleife sein, da a auch nicht mehr geändert wird, oder habe ich mich jetzt verguckt?
zu 5:
for (int i = 0; i < len -1; i+=2) {
t.join()
}
sollte ebenfalls nicht funktionieren weil t in der schleife bekannt ist und die schleife vor dem 5er-block schon endet.
mein alternativ-vorschlag wäre es in der CyclicBarrier, noch +1 hinzuzufuegen und im 5er-Block die for-schleife aus block 2 zu übernehmen (wie auch immer block 2 korrekt ausschauen mag) und in jedem schleifendurchlauf b.await() aufzurufen.