diff options
| -rw-r--r-- | src/library/scala/Either.scala | 303 | ||||
| -rw-r--r-- | src/library/scala/List.scala | 43 | ||||
| -rw-r--r-- | src/library/scala/Option.scala | 14 | ||||
| -rw-r--r-- | test/pending/scalacheck/CheckEither.scala | 253 |
4 files changed, 611 insertions, 2 deletions
diff --git a/src/library/scala/Either.scala b/src/library/scala/Either.scala new file mode 100644 index 0000000000..990141a883 --- /dev/null +++ b/src/library/scala/Either.scala @@ -0,0 +1,303 @@ +package scala + +/** + * <p> + * The <code>Either</code> type represents a value of one of two possible types (a disjoint union). + * The data constructors; <code>Left</code> and <code>Right</code> represent the two possible + * values. The <code>Either</code> type is often used as an alternative to + * <code>scala.Option</code> where <code>Left</code> represents failure (by convention) and + * <code>Right</code> is akin to <code>Some</code>. + * </p> + * + * @author <a href="mailto:research@workingmouse.com">Tony Morris</a>, Workingmouse + * @version 1.0, 11/10/2008 + */ +sealed trait Either[+A, +B] { + /** + * Projects this <code>Either</code> as a <code>Left</code>. + */ + lazy val left = Either.LeftProjection(this) + + /** + * Projects this <code>Either</code> as a <code>Right</code>. + */ + lazy val right = Either.RightProjection(this) + + /** + * Deconstruction of the <code>Either</code> type (in contrast to pattern matching). + */ + def fold[X](fa: A => X, fb: B => X) = this match { + case Left(a) => fa(a) + case Right(b) => fb(b) + } + + /** + * If this is a <code>Left</code>, then return the left value in <code>Right</code> or vice versa. + */ + lazy val swap = this match { + case Left(a) => Right(a) + case Right(b) => Left(b) + } + + /** + * Returns <code>true</code> if this is a <code>Left</code>, <code>false</code> otherwise. + */ + lazy val isLeft = this match { + case Left(_) => true + case Right(_) => false + } + + /** + * Returns <code>true</code> if this is a <code>Right</code>, <code>false</code> otherwise. + */ + lazy val isRight = this match { + case Left(_) => false + case Right(_) => true + } +} +/** + * The left side of the disjoint union, as opposed to the <code>Right</code> side. + * + * @author <a href="mailto:research@workingmouse.com">Tony Morris</a>, Workingmouse + * @version 1.0, 11/10/2008 + */ +final case class Left[+A, +B](a: A) extends Either[A, B] +/** + * The right side of the disjoint union, as opposed to the <code>Left</code> side. + * + * @author <a href="mailto:research@workingmouse.com">Tony Morris</a>, Workingmouse + * @version 1.0, 11/10/2008 + */ +final case class Right[+A, +B](b: B) extends Either[A, B] + +object Either { + /** + * Projects an <code>Either</code> into a <code>Left</code>. + * + * @author <a href="mailto:research@workingmouse.com">Tony Morris</a>, Workingmouse + * @version 1.0, 11/10/2008 + */ + final case class LeftProjection[+A, +B](e: Either[A, B]) { + /** + * Returns the value from this <code>Left</code> or throws <code>Predef.NoSuchElementException</code> + * if this is a <code>Right</code>. + * + * @throws Predef.NoSuchElementException if the option is empty. + */ + lazy val get = e match { + case Left(a) => a + case Right(_) => throw new NoSuchElementException("Either.left.value on Right") + } + + /** + * Executes the given side-effect if this is a <code>Left</code>. + * + * @param e The side-effect to execute. + */ + def foreach(f: A => Unit) = e match { + case Left(a) => f(a) + case Right(_) => {} + } + + /** + * Returns the value from this <code>Left</code> or the given argument if this is a + * <code>Right</code>. + */ + def getOrElse[AA >: A](or: => AA) = e match { + case Left(a) => a + case Right(_) => or + } + + /** + * Returns <code>true</code> if <code>Right</code> or returns the result of the application of + * the given function to the <code>Left</code> value. + */ + def forall(f: A => Boolean) = e match { + case Left(a) => f(a) + case Right(_) => true + } + + /** + * Returns <code>false</code> if <code>Right</code> or returns the result of the application of + * the given function to the <code>Left</code> value. + */ + def exists(f: A => Boolean) = e match { + case Left(a) => f(a) + case Right(_) => false + } + + /** + * Binds the given function across <code>Left</code>. + * + * @param The function to bind across <code>Left</code>. + */ + def flatMap[BB >: B, X](f: A => Either[X, BB]) = e match { + case Left(a) => f(a) + case Right(b) => Right(b) + } + + /** + * Maps the function argument through <code>Left</code>. + */ + def map[X](f: A => X) = e match { + case Left(a) => Left(f(a)) + case Right(b) => Right(b) + } + + /** + * Returns <code>None</code> if this is a <code>Right</code> or if the given predicate + * <code>p</code> does not hold for the left value, otherwise, returns a <code>Left</code>. + */ + def filter[Y](p: A => Boolean): Option[Either[A, Y]] = e match { + case Left(a) => if(p(a)) Some(Left(a)) else None + case Right(b) => None + } + + /** + * Returns a <code>Seq</code> containing the <code>Left</code> value if it exists or an empty + * <code>Seq</code> if this is a <code>Right</code>. + */ + lazy val toSeq = e match { + case Left(a) => Seq.singleton(a) + case Right(_) => Seq.empty + } + + /** + * Returns a <code>Some</code> containing the <code>Left</code> value if it exists or a + * <code>None</code> if this is a <code>Right</code>. + */ + lazy val toOption = e match { + case Left(a) => Some(a) + case Right(_) => None + } + } + + /** + * Projects an <code>Either</code> into a <code>Right</code>. + * + * @author <a href="mailto:research@workingmouse.com">Tony Morris</a>, Workingmouse + * @version 1.0, 11/10/2008 + */ + final case class RightProjection[+A, +B](e: Either[A, B]) { + /** + * Returns the value from this <code>Right</code> or throws + * <code>Predef.NoSuchElementException</code> if this is a <code>Left</code>. + * + * @throws Predef.NoSuchElementException if the projection is <code>Left</code>. + */ + lazy val get = e match { + case Left(_) => throw new NoSuchElementException("Either.right.value on Left") + case Right(a) => a + } + + /** + * Executes the given side-effect if this is a <code>Right</code>. + * + * @param e The side-effect to execute. + */ + def foreach(f: B => Unit) = e match { + case Left(_) => {} + case Right(b) => f(b) + } + + /** + * Returns the value from this <code>Right</code> or the given argument if this is a + * <code>Left</code>. + */ + def getOrElse[BB >: B](or: => BB) = e match { + case Left(_) => or + case Right(b) => b + } + + /** + * Returns <code>true</code> if <code>Left</code> or returns the result of the application of + * the given function to the <code>Right</code> value. + */ + def forall(f: B => Boolean) = e match { + case Left(_) => true + case Right(b) => f(b) + } + + /** + * Returns <code>false</code> if <code>Left</code> or returns the result of the application of + * the given function to the <code>Right</code> value. + */ + def exists(f: B => Boolean) = e match { + case Left(_) => false + case Right(b) => f(b) + } + + /** + * Binds the given function across <code>Right</code>. + * + * @param The function to bind across <code>Right</code>. + */ + def flatMap[AA >: A, Y](f: B => Either[AA, Y]) = e match { + case Left(a) => Left(a) + case Right(b) => f(b) + } + + /** + * Maps the function argument through <code>Right</code>. + */ + def map[Y](f: B => Y) = e match { + case Left(a) => Left(a) + case Right(b) => Right(f(b)) + } + + /** + * Returns <code>None</code> if this is a <code>Left</code> or if the given predicate + * <code>p</code> does not hold for the right value, otherwise, returns a <code>Right</code>. + */ + def filter[X](p: B => Boolean): Option[Either[X, B]] = e match { + case Left(_) => None + case Right(b) => if(p(b)) Some(Right(b)) else None + } + + /** + * Returns a <code>Seq</code> containing the <code>Right</code> value if it exists or an empty + * <code>Seq</code> if this is a <code>Left</code>. + */ + lazy val toSeq = e match { + case Left(_) => Seq.empty + case Right(b) => Seq.singleton(b) + } + + /** + * Returns a <code>Some</code> containing the <code>Right</code> value if it exists or a + * <code>None</code> if this is a <code>Left</code>. + */ + lazy val toOption = e match { + case Left(_) => None + case Right(b) => Some(b) + } + } + + /** + * Joins an <code>Either</code> through <code>Left</code>. + */ + def joinLeft[A, B](es: Either[Either[A, B], B]) = + es.left.flatMap(x => x) + + /** + * Joins an <code>Either</code> through <code>Right</code>. + */ + def joinRight[A, B](es: Either[A, Either[A, B]]) = + es.right.flatMap(x => x) + + /** + * Takes an <code>Either</code> to its contained value within <code>Left</code> or + * <code>Right</code>. + */ + def merge[T](e: Either[T, T]) = e match { + case Left(t) => t + case Right(t) => t + } + + /** + * If the condition satisfies, return the given A in <code>Left</code>, otherwise, return the + * given B in <code>Right</code>. + */ + def cond[A, B](test: Boolean, right: => B, left: => A) = + if(test) Right(right) else Left(left) +} diff --git a/src/library/scala/List.scala b/src/library/scala/List.scala index f87b034cde..6f4b52b4fd 100644 --- a/src/library/scala/List.scala +++ b/src/library/scala/List.scala @@ -145,10 +145,10 @@ object List { b.toList } - /** Transforms a list of pair into a pair of lists. + /** Transforms a list of pairs into a pair of lists. * * @param xs the list of pairs to unzip - * @return a pair of lists: the first list in the pair contains the list + * @return a pair of lists. */ def unzip[A,B](xs: List[(A,B)]): (List[A], List[B]) = { val b1 = new ListBuffer[A] @@ -162,6 +162,45 @@ object List { (b1.toList, b2.toList) } + /** Transforms an iterable of pairs into a pair of lists. + * + * @param xs the iterable of pairs to unzip + * @return a pair of lists. + */ + def unzip[A,B](xs: Iterable[(A,B)]): (List[A], List[B]) = + xs.foldRight[(List[A], List[B])]((Nil, Nil)) { + case ((x, y), (xs, ys)) => (x :: xs, y :: ys) + } + + /** + * Returns the <code>Left</code> values in the given <code>Iterable</code> of <code>Either</code>s. + */ + def lefts[A, B](es: Iterable[Either[A, B]]) = + es.foldRight[List[A]](Nil)((e, as) => e match { + case Left(a) => a :: as + case Right(_) => as + }) + + /** + * Returns the <code>Right</code> values in the given<code>Iterable</code> of <code>Either</code>s. + */ + def rights[A, B](es: Iterable[Either[A, B]]) = + es.foldRight[List[B]](Nil)((e, bs) => e match { + case Left(_) => bs + case Right(b) => b :: bs + }) + + /** Transforms an Iterable of Eithers into a pair of lists. + * + * @param xs the iterable of Eithers to separate + * @return a pair of lists. + */ + def separate[A,B](es: Iterable[Either[A,B]]): (List[A], List[B]) = + es.foldRight[(List[A], List[B])]((Nil, Nil)) { + case (Left(a), (lefts, rights)) => (a :: lefts, rights) + case (Right(b), (lefts, rights)) => (lefts, b :: rights) + } + /** Converts an iterator to a list. * * @param it the iterator to convert diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala index 8652386975..b24b575216 100644 --- a/src/library/scala/Option.scala +++ b/src/library/scala/Option.scala @@ -112,6 +112,20 @@ sealed abstract class Option[+A] extends Product { */ def toList: List[A] = if (isEmpty) List() else List(this.get) + + /** An <code>Either</code> that is a <code>Left</code> with the given argument + * <code>left</code> if this is empty, or a <code>Right</code> if this is nonempty with the + * option's value. + */ + def toRight[X](left: => X) = + if (isEmpty) Left(left) else Right(this.get) + + /** An <code>Either</code> that is a <code>Right</code> with the given argument + * <code>right</code> if this is empty, or a <code>Left</code> if this is nonempty with the + * option's value. + */ + def toLeft[X](right: => X) = + if (isEmpty) Right(right) else Left(this.get) } /** Class <code>Some[A]</code> represents existing values of type diff --git a/test/pending/scalacheck/CheckEither.scala b/test/pending/scalacheck/CheckEither.scala new file mode 100644 index 0000000000..a6c728451b --- /dev/null +++ b/test/pending/scalacheck/CheckEither.scala @@ -0,0 +1,253 @@ + +// To run these tests: +// 1) wget http://scalacheck.googlecode.com/files/ScalaCheck-1.2.jar +// 2) scalac -classpath ScalaCheck-1.2.jar Either.scala +// 3) scala -classpath .:ScalaCheck-1.2.jar scala.CheckEither +// 4) observe passing tests + +import org.scalacheck.Arbitrary +import org.scalacheck.Arbitrary.{arbitrary, arbThrowable} +import org.scalacheck.Gen.oneOf +import org.scalacheck.{Prop, StdRand} +import org.scalacheck.Prop._ +import org.scalacheck.ConsoleReporter.{testReport, propReport} +import org.scalacheck.Test.{Params, check} +import org.scalacheck.ConsoleReporter.testStatsEx +import Function.tupled + +object CheckEither { + implicit def arbitraryEither[X, Y](implicit xa: Arbitrary[X], ya: Arbitrary[Y]): Arbitrary[Either[X, Y]] = + Arbitrary[Either[X, Y]](oneOf(arbitrary[X].map(Left(_)), arbitrary[Y].map(Right(_)))) + + val prop_either1 = property((n: Int) => Left(n).either(x => x, b => error("fail")) == n) + + val prop_either2 = property((n: Int) => Right(n).either(a => error("fail"), x => x) == n) + + val prop_swap = property((e: Either[Int, Int]) => e match { + case Left(a) => e.swap.right.value == a + case Right(b) => e.swap.left.value == b + }) + + val prop_isLeftRight = property((e: Either[Int, Int]) => e.isLeft != e.isRight) + + object CheckLeftProjection { + val prop_valueE = property((n: Int, s: String) => Left(n).left.valueE(s) == n) + + val prop_value = property((n: Int) => Left(n).left.value == n) + + val prop_on = property((e: Either[Int, Int]) => e.left.on((_: Int) + 1) == (e match { + case Left(a) => a + case Right(b) => b + 1 + })) + + val prop_getOrElse = property((e: Either[Int, Int], or: Int) => e.left.getOrElse(or) == (e match { + case Left(a) => a + case Right(_) => or + })) + + val prop_forall = property((e: Either[Int, Int]) => + e.left.forall(_ % 2 == 0) == (e.isRight || e.left.value % 2 == 0)) + + val prop_exists = property((e: Either[Int, Int]) => + e.left.exists(_ % 2 == 0) == (e.isLeft && e.left.value % 2 == 0)) + + val prop_flatMapLeftIdentity = property((e: Either[Int, Int], n: Int, s: String) => { + def f(x: Int) = if(x % 2 == 0) Left(s) else Right(s) + Left(n).left.flatMap(f(_)) == f(n)}) + + val prop_flatMapRightIdentity = property((e: Either[Int, Int]) => e.left.flatMap(Left(_)) == e) + + val prop_flatMapComposition = property((e: Either[Int, Int]) => { + def f(x: Int) = if(x % 2 == 0) Left(x) else Right(x) + def g(x: Int) = if(x % 7 == 0) Right(x) else Left(x) + e.left.flatMap(f(_)).left.flatMap(g(_)) == e.left.flatMap(f(_).left.flatMap(g(_)))}) + + val prop_mapIdentity = property((e: Either[Int, Int]) => e.left.map(x => x) == e) + + val prop_mapComposition = property((e: Either[String, Int]) => { + def f(s: String) = s.toLowerCase + def g(s: String) = s.reverse + e.left.map(x => f(g(x))) == e.left.map(x => g(x)).left.map(f(_))}) + + val prop_filter = property((e: Either[Int, Int], x: Int) => e.left.filter(_ % 2 == 0) == + (if(e.isRight || e.left.value % 2 != 0) None else Some(e))) + + val prop_ap = property((e1: Either[Int, Int], e2: Either[Int, Int]) => { + val ee2 = e2.left map (n => (x: Int) => x + n) + e1.left.ap(ee2) == (ee2 match { + case Left(f) => e1 match { + case Left(a) => Left(f(a)) + case Right(b) => Right(b) + } + case Right(b) => Right(b) + }) + }) + + val prop_seq = property((e: Either[Int, Int]) => e.left.seq == (e match { + case Left(a) => Seq.singleton(a) + case Right(_) => Seq.empty + })) + + val prop_option = property((e: Either[Int, Int]) => e.left.option == (e match { + case Left(a) => Some(a) + case Right(_) => None + })) + } + + object CheckRightProjection { + val prop_valueE = property((n: Int, s: String) => Right(n).right.valueE(s) == n) + + val prop_value = property((n: Int) => Right(n).right.value == n) + + val prop_on = property((e: Either[Int, Int]) => e.right.on((_: Int) + 1) == (e match { + case Left(a) => a + 1 + case Right(b) => b + })) + + val prop_getOrElse = property((e: Either[Int, Int], or: Int) => e.right.getOrElse(or) == (e match { + case Left(_) => or + case Right(b) => b + })) + + val prop_forall = property((e: Either[Int, Int]) => + e.right.forall(_ % 2 == 0) == (e.isLeft || e.right.value % 2 == 0)) + + val prop_exists = property((e: Either[Int, Int]) => + e.right.exists(_ % 2 == 0) == (e.isRight && e.right.value % 2 == 0)) + + val prop_flatMapLeftIdentity = property((e: Either[Int, Int], n: Int, s: String) => { + def f(x: Int) = if(x % 2 == 0) Left(s) else Right(s) + Right(n).right.flatMap(f(_)) == f(n)}) + + val prop_flatMapRightIdentity = property((e: Either[Int, Int]) => e.right.flatMap(Right(_)) == e) + + val prop_flatMapComposition = property((e: Either[Int, Int]) => { + def f(x: Int) = if(x % 2 == 0) Left(x) else Right(x) + def g(x: Int) = if(x % 7 == 0) Right(x) else Left(x) + e.right.flatMap(f(_)).right.flatMap(g(_)) == e.right.flatMap(f(_).right.flatMap(g(_)))}) + + val prop_mapIdentity = property((e: Either[Int, Int]) => e.right.map(x => x) == e) + + val prop_mapComposition = property((e: Either[Int, String]) => { + def f(s: String) = s.toLowerCase + def g(s: String) = s.reverse + e.right.map(x => f(g(x))) == e.right.map(x => g(x)).right.map(f(_))}) + + val prop_filter = property((e: Either[Int, Int], x: Int) => e.right.filter(_ % 2 == 0) == + (if(e.isLeft || e.right.value % 2 != 0) None else Some(e))) + + val prop_ap = property((e1: Either[Int, Int], e2: Either[Int, Int]) => { + val ee2 = e2.right map (n => (x: Int) => x + n) + e1.right.ap(ee2) == (ee2 match { + case Left(a) => Left(a) + case Right(f) => e1 match { + case Left(a) => Left(a) + case Right(b) => Right(f(b)) + } + }) + }) + + val prop_seq = property((e: Either[Int, Int]) => e.right.seq == (e match { + case Left(_) => Seq.empty + case Right(b) => Seq.singleton(b) + })) + + val prop_option = property((e: Either[Int, Int]) => e.right.option == (e match { + case Left(_) => None + case Right(b) => Some(b) + })) + } + + val prop_Either_left = property((n: Int) => Either.left(n).left.value == n) + + val prop_Either_right = property((n: Int) => Either.right(n).right.value == n) + + val prop_Either_joinLeft = property((e: Either[Either[Int, Int], Int]) => e match { + case Left(ee) => Either.joinLeft(e) == ee + case Right(n) => Either.joinLeft(e) == Right(n) + }) + + val prop_Either_joinRight = property((e: Either[Int, Either[Int, Int]]) => e match { + case Left(n) => Either.joinRight(e) == Left(n) + case Right(ee) => Either.joinRight(e) == ee + }) + + val prop_Either_lefts = property((es: List[Either[Int, Int]]) => + Either.lefts(es) == es.filter(_.isLeft).map(_.left.value)) + + val prop_Either_rights = property((es: List[Either[Int, Int]]) => + Either.rights(es) == es.filter(_.isRight).map(_.right.value)) + + val prop_Either_leftRights = property((es: List[Either[Int, Int]]) => + Either.rights(es) == es.filter(_.isRight).map(_.right.value)) + + val prop_Either_throws = property((n: Int) => + Either.throws(n) == Right(n) && Either.throws(error("error")).isLeft) + + val prop_Either_throwIt = property((e: Either[Throwable, Int]) => + try { + Either.throwIt(e) == e.right.value + } catch { + case (t) => e.isLeft && e.left.value == t + }) + + val prop_Either_reduce = property((e: Either[Int, Int]) => + Either.reduce(e) == (e match { + case Left(a) => a + case Right(a) => a + })) + + val prop_Either_iif = property((c: Boolean, a: Int, b: Int) => + Either.iif(c, a, b) == (if(c) Right(b) else Left(a))) + + val tests = List( + ("prop_either1", prop_either1), + ("prop_either2", prop_either2), + ("prop_swap", prop_swap), + ("prop_isLeftRight", prop_isLeftRight), + ("Left.prop_valueE", CheckLeftProjection.prop_valueE), + ("Left.prop_value", CheckLeftProjection.prop_value), + ("Left.prop_getOrElse", CheckLeftProjection.prop_getOrElse), + ("Left.prop_forall", CheckLeftProjection.prop_forall), + ("Left.prop_exists", CheckLeftProjection.prop_exists), + ("Left.prop_flatMapLeftIdentity", CheckLeftProjection.prop_flatMapLeftIdentity), + ("Left.prop_flatMapRightIdentity", CheckLeftProjection.prop_flatMapRightIdentity), + ("Left.prop_flatMapComposition", CheckLeftProjection.prop_flatMapComposition), + ("Left.prop_mapIdentity", CheckLeftProjection.prop_mapIdentity), + ("Left.prop_mapComposition", CheckLeftProjection.prop_mapComposition), + ("Left.prop_filter", CheckLeftProjection.prop_filter), + ("Left.prop_ap", CheckLeftProjection.prop_ap), + ("Left.prop_seq", CheckLeftProjection.prop_seq), + ("Left.prop_option", CheckLeftProjection.prop_option), + ("Right.prop_valueE", CheckRightProjection.prop_valueE), + ("Right.prop_value", CheckRightProjection.prop_value), + ("Right.prop_getOrElse", CheckRightProjection.prop_getOrElse), + ("Right.prop_forall", CheckRightProjection.prop_forall), + ("Right.prop_exists", CheckRightProjection.prop_exists), + ("Right.prop_flatMapLeftIdentity", CheckRightProjection.prop_flatMapLeftIdentity), + ("Right.prop_flatMapRightIdentity", CheckRightProjection.prop_flatMapRightIdentity), + ("Right.prop_flatMapComposition", CheckRightProjection.prop_flatMapComposition), + ("Right.prop_mapIdentity", CheckRightProjection.prop_mapIdentity), + ("Right.prop_mapComposition", CheckRightProjection.prop_mapComposition), + ("Right.prop_filter", CheckRightProjection.prop_filter), + ("Right.prop_ap", CheckRightProjection.prop_ap), + ("Right.prop_seq", CheckRightProjection.prop_seq), + ("Right.prop_option", CheckRightProjection.prop_option), + ("prop_Either_left", prop_Either_left), + ("prop_Either_right", prop_Either_right), + ("prop_Either_joinLeft", prop_Either_joinLeft), + ("prop_Either_joinRight", prop_Either_joinRight), + ("prop_Either_lefts", prop_Either_lefts), + ("prop_Either_rights", prop_Either_rights), + ("prop_Either_leftRights", prop_Either_leftRights), + ("prop_Either_throws", prop_Either_throws), + ("prop_Either_throwIt", prop_Either_throwIt), + ("prop_Either_reduce", prop_Either_reduce), + ("prop_Either_iif", prop_Either_iif) + ) + + def main(args: Array[String]) = + tests foreach (tupled((name, prop) => + testStatsEx(name, testReport(check(Params(500, 0, 0, 500, StdRand), prop, propReport))))) +} + |