Fixed challenge questions.

markhibberd · markhibberd · commit fe1b41dc1aed · 2013-12-03T07:53:06.000+11:00
diff --git a/README.md b/README.md
@@ -3,8 +3,8 @@
 
 This is the base project for the workshop.
 
-__note__: please test your environment as soon as possible, but remember to grab the
-latest copy of this repository the day before the workshop with a `git pull origin master`.
+__note__: please test your environment before you arrive so we can get
+started quickly on the day.
 
 ### Core
 
@@ -25,13 +25,6 @@ and scala syntax.
 
 Implement the missing methods from the Result data type.
 
-Result is a straight forward sum-type with three cases:
- - An explosion (i.e. an exception from somewhere), or
- - A failure message, or
- - A success value
-
-It could be thought of as a newtype for: Exception \/ String \/ A.
-
 
 ### Challenge 2
 
diff --git a/src/main/scala/challenge1/Result.scala b/src/main/scala/challenge1/Result.scala
@@ -154,36 +154,67 @@ object Result {
 
 
 /*
- * *Challenge* Exercise 1.5:
+ * *Challenge* Exercise 1.5: The worlds most trivial HTTP calculator.
  *
- * Given three methods which may succeed or fail:
- *  - data
- *  - count
- *  - user
+ * We are implementing a way to compute a number via a HTTP like
+ * API.
+ *  - We will send a method which is one of GET|POST|PUT|DELETE.
+ *  - We want to send an integer as a request body.
+ *  - We will send a path of what calculation to use.
  *
- * If the user is valid:
- *  - produce the string representing the user.
- * Otherwise, if the data and count are ok:
- *  - produce a string of the data and count concatenated together
- * Otherwise:
- *  - produce the string "bogus"
+ * Complete the implementation, some of the methods are provided
+ * with type signatures to get started.
  */
 object Example {
 
-  case class Input(path: String, data: String, count: Int, user: String, auth: Boolean)
+  /** Simplified method data type. */
+  sealed trait Method
+  case object Get extends Method
+  case object Post extends Method
+  case object Put extends Method
+  case object Delete extends Method
 
-  /* Extract data if path is valid */
-  def data(input: Input): Result[String] =
-    if (input.path == "/valid") Result.ok(input.data) else Result.fail(NotFound)
+  /*
+   * Parse the method if it is valid, otherwise fail with InvalidRequest.
+   *
+   * Hint: Scala defines String#toInt, but warning it throws exceptions if it is not a valid Int :|
+   */
+  def request(body: String): Result[Int] =
+    ???
 
-  /* Extract count iff we have greater than 0 */
-  def count(input: Input): Result[Int] =
-    if (input.count > 10) Result.ok(input.count) else Result.fail(InvalidRequest)
+  /* Parse the method if it is valid, otherwise fail with InvalidMethod. */
+  def method(method: String): Result[Method] =
+    ???
+
+  /*
+   * Route method and path to an implementation.
+   *
+   * A minimal implementation is:
+   *   GET /single -> n * 1
+   *   GET /double -> n * 2
+   *   GET /triple -> n * 3
+   *   PUT *       -> Unauthorized
+   *   POST *      -> Unauthorized
+   *   DELETE *    -> Unauthorized
+   *   *           -> NotFound
+   */
+  def route(method: Method, path: String): Result[Int => Int] =
+    ???
 
-  /* Extract user if it authorized */
-  def user(input: Input): Result[String] =
-    if (input.auth) Result.ok(input.user) else Result.fail(Unauthorized)
+  /*
+   * Attempt to compute an `answer`, by:
+   *  - determining method
+   *  - selecting implementation
+   *  - determing request value
+   *  - using the implementation and request value to compute an answer.
+   */
+  def service(path: String, methodx: String, body: String): Result[Int] =
+    ???
 
-  def answer(input: Input) =
+  /*
+   * Sometimes we always an `answer`, so default to 0 if
+   * our request failed in any way.
+   */
+  def run(path: String, method: String, body: String): Int =
     ???
 }
diff --git a/src/main/scala/challenge2/Reader.scala b/src/main/scala/challenge2/Reader.scala
@@ -74,11 +74,20 @@ object Reader {
   /*
    * Exercise 2.6:
    *
-   * Implement monoid type class for Reader[R, A], given a monoid for A.
+   * Sequence, a list of Readers, to a Reader of Lists.
    */
-  implicit def ReaderMonoid[R, A: Monoid]: Monoid[Reader[R, A]] =
+  def sequence[R, A](readers: List[Reader[R, A]]): Reader[R, List[A]] =
     ???
 
+  implicit def ReaderMonoid[R, A: Monoid]: Monoid[Reader[R, A]] =
+    new Monoid[Reader[R, A]] {
+      def zero: Reader[R, A] =
+        value[R, A](Monoid[A].zero)
+
+      def append(a: Reader[R, A], b: => Reader[R, A]) =
+        for { aa <- a; bb <- b } yield Monoid[A].append(aa, bb)
+    }
+
 
  class Reader_[R] {
     type l[a] = Reader[R, a]
@@ -93,3 +102,44 @@ object Reader {
         r flatMap f
     }
 }
+
+
+/*
+ * *Challenge* Exercise 2.7: Indirection.
+ *
+ * Lookup a specified config value, and then use its values
+ * as keys to look up a subsequent set of values.
+ *
+ * Complete the implementation, some of the methods are provided
+ * fill in the remainder, to complete the spec.
+ */
+object Example {
+  case class ConfigEntry(name: String, values: List[String])
+  case class Config(data: List[ConfigEntry])
+
+  /*
+   * For a single name, lookup all of the direct values for that name.
+   *
+   * Libraries available:
+   *   - The Reader.* libraries
+   *   - List[A] has `find` method that will provide a Option[A]
+   *   - Option[A] has a `getOrElse` method similar to challenge1.Result
+   *
+   * Hint: Starting with Reader.ask will help.
+   */
+  def direct(name: String): Reader[Config, List[String]] =
+    ???
+
+  /*
+   * For a single name, lookup all of the indirect values, that
+   * is those values whose key is a one of the direct values of
+   * the specified name.
+   *
+   * Libraries available:
+   *   - List[List[A]].flatten will produce a List[A].
+   *
+   * Hint: Starting with Reader.sequence will be important.
+   */
+  def indirect(name: String): Reader[Config, List[String]] =
+    ???
+}
diff --git a/src/main/scala/challenge3/Writer.scala b/src/main/scala/challenge3/Writer.scala
@@ -8,6 +8,9 @@ import core._, Syntax._
  */
 case class Writer[W, A](log: W, value: A) {
 
+  def run: (W, A) =
+    (log, value)
+
   /*
    * Exercise 3.1:
    *
@@ -51,15 +54,20 @@ object Writer {
    *
    * Implement tell.
    *
-   * Tell produces the writer content w and produces no value.
+   * Tell appends the writer content w and produces no value.
    *
    * Hint: Try using Writer constructor.
    */
   def tell[W](w: W): Writer[W, Unit] =
     ???
 
-  def writer[W, A](a: A)(w: W): Writer[W, A] =
-    Writer(w, a)
+  /*
+   * Exercise 3.5:
+   *
+   * Sequence, a list of Readers, to a Reader of Lists.
+   */
+  def sequence[W: Monoid, A](writers: List[Writer[W, A]]): Writer[W, List[A]] =
+    ???
 
   class Writer_[W] {
     type l[a] = Writer[W, a]
@@ -81,3 +89,77 @@ object Writer {
         Writer(Monoid[W].append(l.log, r.log), Monoid[A].append(l.value, r.value))
     }
 }
+
+/*
+ * *Challenge* Exercise 3.6: Stocks + Stats.
+ *
+ * We have some stock prices over time, and we make a simple
+ * adjustment:
+ *  Map across each ticker price and do an adjustment by adding
+ *  1000 cents to every value under 10000 and 10 cents to every
+ *  value equal to or over 10000.
+ *
+ * However, while we compute this answer we also want to caculate
+ * summary statistics for our data, specifically, min, max, total,
+ * and count.
+ *
+ * Use the Writer data type to compute stats whilst we calculate
+ * our adjustments.
+ *
+ * Complete the implementation, some of the methods are provided
+ * fill in the remainder, to complete the spec.
+ */
+object Example {
+  case class Stats(min: Int, max: Int, total: Int, count: Int)
+  case class Stock(ticker: String, date: String, cents: Int)
+
+  /**
+   * Implement our algorthim.
+   *
+   * Hint: Writer(W, A) and Writer.sequence will be useful here.
+   */
+  def stocks(data: List[Stock]): (Stats, List[Stock]) =
+    ???
+
+  /**
+   * A monoid for Stats.
+   */
+  implicit def StatsMonoid: Monoid[Stats] =
+    new Monoid[Stats] {
+      def zero =
+        ???
+      def append(l: Stats, r: => Stats) =
+        ???
+    }
+
+  def exampledata = List(
+    Stock("FAKE", "2012-01-01", 10000)
+  , Stock("FAKE", "2012-01-02", 10020)
+  , Stock("FAKE", "2012-01-03", 10022)
+  , Stock("FAKE", "2012-01-04", 10005)
+  , Stock("FAKE", "2012-01-05",  9911)
+  , Stock("FAKE", "2012-01-06",  6023)
+  , Stock("FAKE", "2012-01-07",  7019)
+  , Stock("CAKE", "2012-01-01",     1)
+  , Stock("CAKE", "2012-01-02",     2)
+  , Stock("CAKE", "2012-01-03",     3)
+  , Stock("CAKE", "2012-01-04",     4)
+  , Stock("CAKE", "2012-01-05",     5)
+  , Stock("CAKE", "2012-01-06",     6)
+  , Stock("CAKE", "2012-01-07",     7)
+  , Stock("BAKE", "2012-01-01", 99999)
+  , Stock("BAKE", "2012-01-02", 99999)
+  , Stock("BAKE", "2012-01-03", 99999)
+  , Stock("BAKE", "2012-01-04", 99999)
+  , Stock("BAKE", "2012-01-05", 99999)
+  , Stock("BAKE", "2012-01-06", 99999)
+  , Stock("BAKE", "2012-01-07", 99999)
+  , Stock("LAKE", "2012-01-01", 10012)
+  , Stock("LAKE", "2012-01-02",  7000)
+  , Stock("LAKE", "2012-01-03",  1234)
+  , Stock("LAKE", "2012-01-04",    10)
+  , Stock("LAKE", "2012-01-05",  6000)
+  , Stock("LAKE", "2012-01-06",  6099)
+  , Stock("LAKE", "2012-01-07",  5999)
+  )
+}
diff --git a/src/test/scala/challenge1/Challenge1Spec.scala b/src/test/scala/challenge1/Challenge1Spec.scala
@@ -35,4 +35,34 @@ object Challenge1Spec extends test.Spec {
     "fold with ok" ! prop((i: Int) =>
       Result.ok[Int](i).fold(_ => false, _ === i))
   }
+
+  "Example" should {
+    "single" ! {
+      Example.service("/single", "GET", "3") must_== Result.ok(3)
+    }
+    "double" ! {
+      Example.service("/double", "GET", "5") must_== Result.ok(10)
+    }
+    "triple" ! {
+      Example.service("/triple", "GET", "9") must_== Result.ok(27)
+    }
+    "handle invalid method" ! {
+      Example.service("/triple", "INVALID", "9") must_== Result.fail(InvalidMethod)
+    }
+    "handle invalid path" ! {
+      Example.service("/oops", "GET", "9") must_== Result.fail(NotFound)
+    }
+    "handle invalid request" ! {
+      Example.service("/triple", "GET", "huh?") must_== Result.fail(InvalidRequest)
+    }
+    "handle unathorized method" ! {
+      Example.service("/single", "POST", "8") must_== Result.fail(Unauthorized)
+    }
+    "default to 0 in failure" ! {
+      Example.run("oops", "GET", "1") must_== 0
+    }
+    "not default to 0 in success" ! {
+      Example.run("/double", "GET", "3") must_== 6
+    }
+  }
 }
