New test exercising implicit function types

Author: odersky

tests/run/config.check

@@ -0,0 +1,2 @@
+Some(Person(Name(John,Doe),Age(20)))
+None

tests/run/config.scala

@@ -0,0 +1,123 @@
+case class Name(first: String, last: String)
+case class Age(age: Int)
+case class Person(name: Name, age: Age)
+case class Config(name: String, age: Int)
+
+
+
+object Imperative {
+  import Configs._
+  import Exceptions._
+
+  // Algebraic Effects
+
+  def readName: Possibly[Configured[Name]] = {
+    val parts = config.name.split(" ")
+    require(parts.length >= 2)
+    Name(parts(0), parts.tail.mkString(" "))
+  }
+
+  def readAge: Configured[Possibly[Age]] = {
+    val age = config.age
+    require(1 <= age && age <= 150)
+    Age(age)
+  }
+
+  def readPerson: Configured[Option[Person]] =
+    attempt(
+      Some(Person(readName, readAge))
+    ).onError(None)
+
+  def main(args: Array[String]) = {
+    println(readPerson(Config("John Doe", 20)))
+    println(readPerson(Config("Incognito", 99)))
+  }
+}
+
+object Configs {
+  type Configured[T] = implicit Config => T
+  def config: Configured[Config] = implicitly[Config]
+}
+
+object Exceptions {
+
+  private class E extends Exception
+
+  class CanThrow private[Exceptions] () {
+    private[Exceptions] def throwE() = throw new E
+  }
+
+  type Possibly[T] = implicit CanThrow => T
+
+  def require(p: Boolean)(implicit ct: CanThrow): Unit =
+    if (!p) ct.throwE()
+
+  def attempt[T](op: Possibly[T]) = new OnError(op)
+
+  class OnError[T](op: Possibly[T]) {
+    def onError(fallback: => T): T =
+      try op(new CanThrow)
+      catch { case ex: E => fallback }
+  }
+}
+
+object Test extends App {
+  import Configs._
+  import Exceptions._
+
+  type PC[T] = Possibly[Configured[T]]
+
+  val names: PC[List[Name]] = readName :: Nil
+  val firstNames: PC[List[String]] = names.map(_.first)
+  val longest: PC[String] = firstNames.maxBy(_.length)
+
+  def readName: Configured[Possibly[Name]] = {
+    val parts = config.name.split(" ")
+    require(parts.length >= 2)
+    Name(parts(0), parts.tail.mkString(" "))
+  }
+
+  def readAge: Possibly[Configured[Age]] = {
+    val age = config.age
+    require(1 <= age && age <= 150)
+    Age(age)
+  }
+
+  def readPerson: Configured[Option[Person]] =
+    attempt(
+      Some(Person(readName, readAge))
+    ).onError(None)
+
+  val config1 = Config("John Doe", 20)
+  val config2 = Config("Incognito", 99)
+
+  println(readPerson(config1))
+  println(readPerson(config2))
+}
+
+object OptionTest extends App {
+
+  def readName(config: Config): Option[Name] = {
+    val parts = config.name.split(" ")
+    if (parts.length >= 2) Some(Name(parts(0), parts.tail.mkString(" ")))
+    else None
+  }
+
+  def readAge(config: Config): Option[Age] = {
+    val age = config.age
+    if (1 <= age && age <= 150) Some(Age(age)) else None
+  }
+
+  def readPerson(config: Config): Option[Person] =
+    for {
+      name <- readName(config)
+      age <- readAge(config)
+    }
+    yield Person(name, age)
+
+  val config1 = Config("John Doe", 20)
+  val config2 = Config("Incognito", 99)
+
+  println(readPerson(config1))
+  println(readPerson(config2))
+}