y-yu · May 23, 2016 01:03
diff --git a/DatabaseAndHttpException.scala b/DatabaseAndHttpException.scala
 object DatabaseAndHttpException {
  implicit val databaseException = new :->[DatabaseException, DatabaseAndHttpException] {
    def cast(a: DatabaseException): DatabaseAndHttpException =
      DatabaseAndHttpException(s"database: ${a.m}")
  }

  implicit val httpException = new :->[HttpException, DatabaseAndHttpException] {
    def cast(a: HttpException): DatabaseAndHttpException =
      DatabaseAndHttpException(s"http: ${a.m}")
  }
 }
diff --git a/file0.scala b/file0.scala
 trait RootException extends Throwable

 case class DatabaseException(m: String) extends RootException

 case class HttpException(m: String) extends RootException

 trait FileException extends RootException

 case class ReadException(m: String) extends FileException

 case class WriteException(m: String) extends FileException
diff --git a/file1.txt b/file1.txt
 RootException
 |
 +---- DatabaseException
 |
 +---- HttpException
 |
 +---- FileException
      |
      +---- ReadException
      |
      +---- WriteException
diff --git a/file10.scala b/file10.scala
 case class DatabaseAndHttpException(m: String) extends RootException
diff --git a/file11.txt b/file11.txt
 RootException
 |
 +---- DatabaseException
 |
 +---- HttpException
 |
 +---- FileException
 |     |
 |     +---- ReadException
 |     |
 |     +---- WriteException
 |
 +---- DatabaseAndHttpException
diff --git a/file14.scala b/file14.scala
 def left[A](e: A) = Left[A, Unit](e)

 val e1 = left(DatabaseException("db error"))
 val e2 = left(HttpException("http error"))

 val e3 = for {
  a <- e1
  b <- e2
 } yield ()
diff --git a/file15.txt b/file15.txt
 Error:(18, 9) could not find implicit value for parameter L2: utils.:->[utils.DatabaseException,utils.HttpException]
      a <- e1
        ^
diff --git a/file16.scala b/file16.scala
 val e3 = for {
  a <- e1
  b <- e2.as[DatabaseAndHttpException]
 } yield ()
diff --git a/file17.txt b/file17.txt
 RootException
 |
 +---- DatabaseException
 |
 +---- HttpException
 |
 +---- FileException
 |     |
 |     +---- ReadException
 |     |
 |     +---- WriteException
 |
 +---- DatabaseAndHttpException
diff --git a/file18.scala b/file18.scala
 val e4 = for {
  a <- e1
 } yield ()
diff --git a/file19.txt b/file19.txt
 Error:(20, 9) could not find implicit value for parameter L2: utils.:->[utils.DatabaseException,L2]
      a <- e1
        ^
diff --git a/file2.scala b/file2.scala
 val result = for {
  x <- databaseService(???) // Either[DatabaseException, A]
  y <- httpService(???)     // Either[HttpException, A]
 } yield ()
diff --git a/file20.scala b/file20.scala
 implicit def self[A]= new :->[A, A] {
  def cast(a: A): A = a
 }
diff --git a/file22.scala b/file22.scala
 trait FileException extends RootException

 case class ReadException(m: String) extends FileException

 case class WriteException(m: String) extends FileException
diff --git a/file23.txt b/file23.txt
 RootException
 |
 +---- FileException
      |
      +---- ReadException
      |
      +---- WriteException
diff --git a/file24.scala b/file24.scala
 val e5 = left(ReadException("file read error"))
 val e6 = left(WriteException("file read error"))

 val e7 = for {
  a <- e5
  b <- e6
 } yield ()
diff --git a/file25.txt b/file25.txt
 Error:(29, 9) could not find implicit value for parameter L2: utils.:->[utils.ReadException,utils.WriteException]
      a <- e5
        ^
diff --git a/file26.scala b/file26.scala
 val e7 = for {
  a <- e5
  b <- e6.as[FileException]
 } yield ()
diff --git a/file27.txt b/file27.txt
 Error:(30, 17) could not find implicit value for parameter L2: utils.:->[utils.WriteException,utils.FileException]
      b <- e6.as[FileException]
                ^
diff --git a/file28.scala b/file28.scala
 implicit def superclass[A, B >: A] = new :->[A, B] {
  def cast(a: A): B = a
 }
diff --git a/file3.scala b/file3.scala
 case class DatabaseAndHttpException(m: String) extends RootException
diff --git a/file30.scala b/file30.scala
 val e7 = for {
  a <- e5
  b <- e6.as[FileException]
 } yield ()
diff --git a/file4.scala b/file4.scala
 trait RootException extends Throwable

 case class DatabaseException(m: String) extends RootException
diff --git a/file5.txt b/file5.txt
 RootException
 |
 +---- DatabaseException
diff --git a/file6.scala b/file6.scala
 def string_of_int(i: Int): String = i.toString
diff --git a/file8.scala b/file8.scala
 implicit val float_of_int = new :->[Int, Float] {
  def cast(a: Int): Float = a.toFloat
 }
diff --git a/file9.scala b/file9.scala
 for {
  x <- databaseService(???) // Either[DatabaseException, A]
  y <- httpService(???)     // Either[HttpException, A]
 } yield ()
diff --git a/Implicit.scala b/Implicit.scala
 object Implicit {
  implicit class ExceptionEither[L <: RootException, R](val ee: Either[L, R]) {
    def map[L2 <: RootException, R2](f: R => R2)(implicit L2: L :-> L2): Either[L2, R2] = ee match {
      case Left(e)  => Left(L2.cast(e))
      case Right(v) => Right(f(v))
    }

    def flatMap[L2 <: RootException, R2](f: R => Either[L2, R2])(implicit L2: L :-> L2): Either[L2, R2] = ee match {
      case Left(e)  => Left(L2.cast(e))
      case Right(v) => f(v)
    }

    def as[L2 <: RootException](implicit L2: L :-> L2): Either[L2, R] = ee match {
      case Left(e)  => Left(L2.cast(e))
      case Right(v) => Right(v)
    }
  }
 }
diff --git a/Transform.scala b/Transform.scala
 object :-> {
  implicit def superclass[A, B >: A] = new :->[A, B] {
    def cast(a: A): B = a
  }
 }
	object DatabaseAndHttpException {
	implicit val databaseException = new :->[DatabaseException, DatabaseAndHttpException] {
	def cast(a: DatabaseException): DatabaseAndHttpException =
	DatabaseAndHttpException(s"database: ${a.m}")
	}

	implicit val httpException = new :->[HttpException, DatabaseAndHttpException] {
	def cast(a: HttpException): DatabaseAndHttpException =
	DatabaseAndHttpException(s"http: ${a.m}")
	}
	}
	trait RootException extends Throwable

	case class DatabaseException(m: String) extends RootException

	case class HttpException(m: String) extends RootException

	trait FileException extends RootException

	case class ReadException(m: String) extends FileException

	case class WriteException(m: String) extends FileException
	RootException
	\|
	+---- DatabaseException
	\|
	+---- HttpException
	\|
	+---- FileException
	\|
	+---- ReadException
	\|
	+---- WriteException
	def left[A](e: A) = Left[A, Unit](e)

	val e1 = left(DatabaseException("db error"))
	val e2 = left(HttpException("http error"))

	val e3 = for {
	a <- e1
	b <- e2
	} yield ()
	Error:(18, 9) could not find implicit value for parameter L2: utils.:->[utils.DatabaseException,utils.HttpException]
	a <- e1
	^
	val e3 = for {
	a <- e1
	b <- e2.as[DatabaseAndHttpException]
	} yield ()
	Error:(20, 9) could not find implicit value for parameter L2: utils.:->[utils.DatabaseException,L2]
	a <- e1
	^
	val result = for {
	x <- databaseService(???) // Either[DatabaseException, A]
	y <- httpService(???) // Either[HttpException, A]
	} yield ()
	val e5 = left(ReadException("file read error"))
	val e6 = left(WriteException("file read error"))

	val e7 = for {
	a <- e5
	b <- e6
	} yield ()
	Error:(29, 9) could not find implicit value for parameter L2: utils.:->[utils.ReadException,utils.WriteException]
	a <- e5
	^