+TestChecksReturningProj.scala
+ Either.None

 object Either
+  private case object None extends Either[Nothing, Nothing] {
+    def isLeft = false
+    def isRight = false
+  }
{RightAsLeft, LeftAsRight}=>Either.None; most 'e match' once again checked; Tests updated

-private case class RightAsLeft[+A, +B](r: Right[A, B]) extends Either[A, B] {
-private case class LeftAsRight[+A, +B](l: Left[A, B]) extends Either[A, B] {

  final case class LeftProjection[+A, +B](e: Either[A, B]) {

-    def get = (e: @unchecked) match {
+    def get = e match {
and similar

-      case LeftAsRight(_) =>  throw new NoSuchElementException("Either.left.value on Right")
+      case Either.None =>  throw new NoSuchElementException("None.get")

-    def foreach[U](f: A => U) = (e: @unchecked) match {
+    def foreach[U](f: A => U) = e match {

-      case LeftAsRight(_) => {}
+      case Either.None => {}

-    def getOrElse[AA >: A](or: => AA) = (e: @unchecked) match {
+    def getOrElse[AA >: A](or: => AA) = e match {

-      case LeftAsRight(_) => or
+      case Either.None => or

-    def forall(f: A => Boolean) = (e: @unchecked) match {
+    def forall(f: A => Boolean) = e match {

-      case LeftAsRight(_) => true
+      case Either.None => true

-    def exists(f: A => Boolean) = (e: @unchecked) match {
+    def exists(f: A => Boolean) = e match {

-      case LeftAsRight(_) => false
+      case Either.None => false

-    def flatMap[BB >: B, X](f: A => LeftProjection[X, BB]): LeftProjection[X, BB] =
-      (e: @unchecked) match {

-        case LeftAsRight(Left(a)) => (f(a).e: @unchecked) match {

+    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: @unchecked) match {
+    def map[X](f: A => X): LeftProjection[X, B] = e match {

-      case LeftAsRight(Left(a)) => LeftProjection(LeftAsRight(Left(f(a))))
+      case Either.None => LeftProjection(Either.None)

-    def withFilter(p: A => Boolean): LeftProjection[A, B] = (e: @unchecked) match {
-      case Left(a) => if (p(a)) LeftProjection(Left(a)) else LeftProjection(LeftAsRight(Left(a)))

+    def withFilter(p: A => Boolean): LeftProjection[A, B] = e match {
+      case Left(a) => if (p(a)) LeftProjection(Left(a)) else LeftProjection(Either.None)

+      case Either.None => LeftProjection(Either.None)

-    def toSeq = (e: @unchecked) match {
+    def toSeq = e match {

-      case LeftAsRight(_) => Seq.empty
+      case Either.None => Seq.empty

-    def toOption = (e: @unchecked) match {
+    def toOption = e match {

-      case Right(_) => None
-      case LeftAsRight(_) => None
+      case Right(_) => scala.None
+      case Either.None => scala.None

  final case class RightProjection[+A, +B](e: Either[A, B]) {

-    def get = (e: @unchecked) match {
-      case Left(_) =>  throw new NoSuchElementException("Either.right.value on Left")
-      case RightAsLeft(_) =>  throw new NoSuchElementException("Either.right.value on Left")

+    def get = e match {
+      case Left(_) => throw new NoSuchElementException("Either.right.value on Left")
+      case Either.None => throw new NoSuchElementException("None.get")

-    def foreach[U](f: B => U) = (e: @unchecked) match {
+    def foreach[U](f: B => U) = e match {

-      case RightAsLeft(_) => {}
+      case Either.None => {}

-    def getOrElse[BB >: B](or: => BB) = (e: @unchecked) match {
+    def getOrElse[BB >: B](or: => BB) = e match {

-      case RightAsLeft(_) => or
+      case Either.None => or

-    def forall(f: B => Boolean) = (e: @unchecked) match {
+    def forall(f: B => Boolean) = e match {

-      case RightAsLeft(_) => true
+      case Either.None => true

-    def exists(f: B => Boolean) = (e: @unchecked) match {
+    def exists(f: B => Boolean) = e match {

-      case RightAsLeft(_) => false
+      case Either.None => false

-    def flatMap[AA >: A, Y](f: B => RightProjection[AA, Y]): RightProjection[AA, Y] =
-      (e: @unchecked) match {

-        case RightAsLeft(Right(b)) => (f(b).e: @unchecked) match {

+    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: @unchecked) match {
+    def map[Y](f: B => Y): RightProjection[A, Y] = e match {

-      case RightAsLeft(Right(b)) => RightProjection(RightAsLeft(Right(f(b))))
+      case Either.None => RightProjection(Either.None)

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

-        if (p(b)) RightProjection(Right(b)) else RightProjection(RightAsLeft(Right(b)))
+        if (p(b)) RightProjection(Right(b)) else RightProjection(Either.None)
+      case Either.None => RightProjection(Either.None)

-    def toSeq = (e: @unchecked) match {
+    def toSeq = e match {

-      case RightAsLeft(_) => Seq.empty
+      case Either.None => Seq.empty

-    def toOption = (e: @unchecked) match {
-      case Left(_) => None
-      case RightAsLeft(_) => None
+    def toOption = e match {
+      case Left(_) => scala.None
+      case Either.None => scala.None

Tests
  test("left map false") {
-    left.e should equal(LeftAsRight(Left(2)))
+    left.e.toString should equal("None")

-    thrown.getMessage should equal("Either.left.value on Right")
+    thrown.getMessage should equal("None.get")

-    left.toOption should equal(None)
+    left.toOption should equal(scala.None)

  test("right map false") {
-    right.e should equal(RightAsLeft(Right(2)))
+    right.e.toString should equal("None")

-    thrown.getMessage should equal("Either.right.value on Left")
+    thrown.getMessage should equal("None.get")

-    right.toOption should equal(None)
+    right.toOption should equal(scala.None)

  test("two right generators with map false") {

-    right.e should equal(RightAsLeft(Right(2)))
+    right.e.toString should equal("None")

  test("two right generators with map false 2") {
-    right.e should equal(RightAsLeft(Right(2)))
+    right.e.toString should equal("None")