Packages

sealed abstract class LazyEither[A, B] extends AnyRef

scala.Either, but with a value by name.

Source
LazyEither.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. LazyEither
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. def ?[X](left: => X, right: => X): X

    Catamorphism of the constructor chosen.

  2. def ap[C](f: => LazyEither[A, (B) => C]): LazyEither[A, C]
  3. def bimap[C, D](f: (=> A) => C, g: (=> B) => D): LazyEither[C, D]
  4. def exists(f: (=> B) => Boolean): Boolean
  5. def flatMap[AA >: A, C](f: (=> B) => LazyEither[AA, C]): LazyEither[AA, C]
  6. def fold[X](left: (=> A) => X, right: (=> B) => X): X
  7. def foldRight[Z](z: => Z)(f: (B, => Z) => Z): Z
  8. def forall(f: (=> B) => Boolean): Boolean
  9. def foreach(f: (=> B) => Unit): Unit
  10. def getOrElse[BB >: B](default: => BB): BB
  11. def isLeft: Boolean
  12. def isRight: Boolean
  13. def left: LeftProjection[A, B]
  14. def leftMap[C](f: (=> A) => C): LazyEither[C, B]

    Run the given function on the left value.

  15. def map[C](f: (=> B) => C): LazyEither[A, C]
  16. def orElse(x: => LazyEither[A, B]): LazyEither[A, B]
  17. def swap: LazyEither[B, A]
  18. def toDisjunction: \/[A, B]
  19. def toEither: Either[A, B]
  20. def toIList[BB >: B]: IList[BB]
  21. def toLazyList: LazyList[B]
  22. def toLazyOption: LazyOption[B]
  23. def toList: List[B]
  24. def toMaybe[BB >: B]: Maybe[BB]
  25. def toOption: Option[B]
  26. def traverse[G[_], C](f: (B) => G[C])(implicit arg0: Applicative[G]): G[LazyEither[A, C]]

Deprecated Value Members

  1. def disjunction: \/[A, B]
    Annotations
    @deprecated
    Deprecated

    (Since version 7.3.0) Use toDisjunction