1. Ozma: Extending Scala with Oz concurrency
Sébastien Doeraene

2. Tail recursion modulo cons
def append[A](front: List[A], back: List[A]): List[A] =
if (front.isEmpty) back
else front.head :: append(front.tail, back)

3. Declarative concurrency
def map[A, B](list: List[A], f: A => B): List[B] =
if (list.isEmpty) Nil
else f(list.head) :: map(list.tail, f)
def cmap[A, B](list: List[A], f: A => B): List[B] =
if (list.isEmpty) Nil
else thread(f(list.head)) :: cmap(list.tail, f)

4. Declarative agents
def displayEvenSquares() {
val integers = thread(gen(0))
val evens = thread(integers filter (_ % 2 == 0))
val evenSquares = thread(evens map (x => x*x))
evenSquares foreach println
}
def gen(from: Int): List[Int] =
from :: gen(from+1)

5. Lazy execution
def displayEvenSquares() {
val integers = gen(0)
val evens = integers.lazified filter (_ % 2 == 0)
val evenSquares = evens.lazified map (x => x*x)
evenSquares foreach println
}
def gen(from: Int): List[Int] = byNeedFuture {
from :: gen(from+1)
}

6. Ports
def partialBarrier(m: Int, tasks: List[() => Unit]) {
val (stream, port) = Port.newPort[Unit]
for (task <­ tasks)
thread { task(); port.send(()) }
stream(m­1) // wait until has at least m elements
}
println("start")
partialBarrier(2, List(
() => { sleep(1000); println("a") },
() => { sleep(3000); println("b") },
() => { sleep(2000); println("c") }
))
println("peekaboo")

7. Methodology (if still time remaining)
● Start with straightforward functional programs on lists
● Proove correctness with sequential methods
● Add thread expressions where needed
● Add concurrency, does not change result
● Add ports where needed
● Add nondeterminism exactly where needed, not more
● Add byNeedFuture and .lazified where needed
● Make computations optional, does not change result