Either: support for 'if' in for-comprehensions, removed; new set of Tests; Readme.md updated

  final case class LeftProjection[+A, +B](e: Either[A, B]) {
     def get = e match {
-      case Either.None =>  throw new NoSuchElementException("None.get")

     def foreach[U](f: A => U) = e match {
-      case Either.None => {}

     def getOrElse[AA >: A](or: => AA) = e match {
-      case Either.None => or

     def forall(f: A => Boolean) = e match {
-      case Either.None => true

     def exists(f: A => Boolean) = e match {
-      case Either.None => false

     def flatMap[BB >: B, X](f: A => LeftProjection[X, BB]): LeftProjection[X, BB] = e match {
-      case Either.None => LeftProjection(Either.None)

     def map[X](f: A => X): LeftProjection[X, B] = e match {
-      case Either.None => LeftProjection(Either.None)

-    def withFilter(p: A => Boolean): LeftProjection[A, B] = e match {
+    // def withFilter(p: A => Boolean): LeftProjection[A, B] = e match {

     def toSeq = e match {
-      case Either.None => Seq.empty

     def toOption = e match {
-      case Either.None => scala.None

  final case class RightProjection[+A, +B](e: Either[A, B]) {
     def get = e match {
-      case Either.None => throw new NoSuchElementException("None.get")

     def foreach[U](f: B => U) = e match {
-      case Either.None => {}

     def getOrElse[BB >: B](or: => BB) = e match {
-      case Either.None => or

     def forall(f: B => Boolean) = e match {
-      case Either.None => true

     def exists(f: B => Boolean) = e match {
-      case Either.None => false

     def flatMap[AA >: A, Y](f: B => RightProjection[AA, Y]): RightProjection[AA, Y] = e match {
-      case Either.None => RightProjection(Either.None)

     def map[Y](f: B => Y): RightProjection[A, Y] = e match {
-      case Either.None => RightProjection(Either.None)

-    def withFilter(p: B => Boolean): RightProjection[A, B] = e match {
+    // def withFilter(p: B => Boolean): RightProjection[A, B] = e match {

     def toSeq = e match {
-      case Either.None => Seq.empty

     def toOption = e match {
-      case Either.None => scala.None

-  private case object None extends Either[Nothing, Nothing] {

Tests
-  test("left foreach true") {
-  test("left foreach false") {
-  test("right foreach true") {
-  test("right foreach false") {
-  test("left map true") {
-  test("left map false") {
-  test("right map true") {
-  test("right map false") {

+  test("foreach - Right") {
+  test("foreach - Left") {
+  test("map - Right") {
+  test("map - Left") {

-  test("two right generators with foreach - succeeds 1") {
-  test("two right generators with foreach - succeeds 2") {
-  test("two right generators with foreach - fails") {

+  test("foreach, two generators - Right 1") {
+  test("foreach, two generators - Right 2") {
+  test("foreach, two generators - Right 3") {

-  test("two right generators with foreach true") {
-  test("two right generators with foreach false") {

+  test("foreach, two generators - Left 1") {
+  test("foreach, two generators - Left 2") {
+  test("foreach, two generators - Left 3") {

-  test("two right generators with map - succeeds 1") {
-  test("two right generators with map - succeeds 2") {
-  test("two right generators with map - fails") {

+  test("map, two generators - Right 1") {
+  test("map, two generators - Right 2") {
+  test("map, two generators - Right 3") {

-  test("two right generators with map true") {
-  test("two right generators with map true 2") {
-  test("two right generators with map false") {
-  test("two right generators with map false 2") {

+  test("map, two generators - Left 1") {
+  test("map, two generators - Left 2") {
+  test("map, two generators - Left 3") {