Add exercises/solutions-4.md

exercises/solutions-4.md

+# 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
+  }
+}
+```