Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
# Exercise 1 : Implementing map and filter on Futures
```scala
trait Future[T] { self =>
def map[S](f: T => S): Future[S] =
new Future[S] {
def onComplete(callback: Try[S] => Unit): Unit = self.onComplete {
case Success(v) => callback(Success(f(v)))
case Failure(e) => callback(Failure(e))
}
}
def filter(f: T => Boolean): Future[T] =
new Future[T] {
def onComplete(callback: Try[T] => Unit): Unit = self.onComplete {
case Success(v) =>
if (f(v)) callback(Success(v))
else callback(Failure(new NoSuchElementException("...")))
case Failure(e) => callback(Failure(e))
}
}
}
```
# Exercise 2 : Coordinator / Worker
```scala
class Coordinator extends Actor {
var availableWorkers: List[ActorRef] = Nil
var pendingRequests: List[Request] = Nil
def receive: Receive = {
case Ready =>
if (pendingRequests.isEmpty) {
availableWorkers = availableWorkers :+ sender
}
else {
val request = pendingRequests.head
pendingRequests = pendingRequests.tail
sender ! request
}
case request: Request => availableWorkers match {
case worker :: rest =>
worker ! request
availableWorkers = rest
case Nil =>
pendingRequests = pendingRequests :+ request
}
}
}
class Worker(coordinator: ActorRef) extends Actor {
coordinator ! Ready
def receive: Receive = {
case Request(f) =>
f()
coordinator ! Ready
}
}
```