Left

Instance Constructors

new Left(value: A)

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def &>[A1 >: A, C](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, C]

A symbolic alias for zipParRight.
A symbolic alias for zipParRight.

Definition Classes
These
final def *>[A1 >: A, C](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, C]

A symbolic alias for zipRight.
A symbolic alias for zipRight.

Definition Classes
These
final def <&[A1 >: A, C](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, Nothing]

A symbolic alias for zipParLeft.
A symbolic alias for zipParLeft.

Definition Classes
These
final def <&>[A1 >: A, C](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, (Nothing, C)]

A symbolic alias for zipPar.
A symbolic alias for zipPar.

Definition Classes
These
final def <*[A1 >: A, C](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, Nothing]

A symbolic alias for zipLeft.
A symbolic alias for zipLeft.

Definition Classes
These
final def <*>[A1 >: A, C](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, (Nothing, C)]

A symbolic alias for zip.
A symbolic alias for zip.

Definition Classes
These
final def <+>[A1 >: A, C](that: ⇒ These[A1, C])(implicit arg0: Associative[A1]): These[A1, Either[Nothing, C]]

A symbolic alias for orElseEither.
A symbolic alias for orElseEither.

Definition Classes
These
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def >>=[A1 >: A, C](f: (Nothing) ⇒ These[A1, C])(implicit arg0: Associative[A1]): These[A1, C]

A symbolic alias for flatMap.
A symbolic alias for flatMap.

Definition Classes
These
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def bimap[A2, C](f: (A) ⇒ A2, g: (Nothing) ⇒ C): These[A2, C]

Transforms both the A value and the B value with the specified functions f and g.
Transforms both the A value and the B value with the specified functions f and g.

Definition Classes
These
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def flatMap[A1 >: A, C](f: (Nothing) ⇒ These[A1, C])(implicit arg0: Associative[A1]): These[A1, C]

Returns a new computation based on the successful result of this computation.
Returns a new computation based on the successful result of this computation. If this computation contains a success the new computation will be performed, even if this computation also contains errors. Any errors produced by the two computations will be combined using the Associative instance for A. If this computation does not contain a success then the original failure will be returned unchanged.

Definition Classes
These
final def flatten[A1 >: A, C](implicit ev: <:<[Nothing, These[A1, C]], ev2: Associative[A1]): These[A1, C]

Flattens a nested These computation to a single level.
Flattens a nested These computation to a single level.

Definition Classes
These
final def flip: These[Nothing, A]

Flips the left and right values.
Flips the left and right values.

Definition Classes
These
final def fold[C](left: (A) ⇒ C, right: (Nothing) ⇒ C)(both: (A, Nothing) ⇒ C): C

Folds each of the possibile cases into a summary value.
Folds each of the possibile cases into a summary value.

Definition Classes
These
final def forEach[F[+_], C](f: (Nothing) ⇒ F[C])(implicit arg0: IdentityBoth[F], arg1: Covariant[F]): F[These[A, C]]

Transforms the successful result of this compuation with the specified effectual function, leaving any error value unchanged.
Transforms the successful result of this compuation with the specified effectual function, leaving any error value unchanged.

Definition Classes
These
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def isBoth: Boolean

Returns whether this value is a Both.
Returns whether this value is a Both.

Definition Classes
These
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isLeft: Boolean

Returns whether this value is a Left.
Returns whether this value is a Left.

Definition Classes
These
final def isRight: Boolean

Returns whether this value is a Right.
Returns whether this value is a Right.

Definition Classes
These
final def map[C](f: (Nothing) ⇒ C): These[A, C]

Transforms the B value with the specified function.
Transforms the B value with the specified function.

Definition Classes
These
final def mapLeft[A2](f: (A) ⇒ A2): These[A2, Nothing]

Transforms the A value with the specified function.
Transforms the A value with the specified function.

Definition Classes
These
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def orElse[A1 >: A, B1 >: Nothing](that: ⇒ These[A1, B1])(implicit arg0: Associative[A1]): These[A1, B1]

Definition Classes
These
final def orElseEither[A1 >: A, C](that: ⇒ These[A1, C])(implicit arg0: Associative[A1]): These[A1, Either[Nothing, C]]

Definition Classes
These
def reduceMap[C](f: (A) ⇒ C, g: (Nothing) ⇒ C)(implicit C: Associative[C]): C

Definition Classes
These
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def toEither: Either[A, Nothing]

Converts this value to an Either containing a Right if this value contains a success or a Left otherwise, discarding information about any errors in the case of success.
Converts this value to an Either containing a Right if this value contains a success or a Left otherwise, discarding information about any errors in the case of success.

Definition Classes
These
final def toOption: Option[Nothing]

Converts this value to an Option containing Some if this value contains a success or None otherwise, discarding information about any errors in the case of success.
Converts this value to an Option containing Some if this value contains a success or None otherwise, discarding information about any errors in the case of success.

Definition Classes
These
final def toValidation: Validation[A, Nothing]

Converts this value to a validation success if this value contains a success or a validation failure otherwise, discarding information about any errors in the case of success.
Converts this value to a validation success if this value contains a success or a validation failure otherwise, discarding information about any errors in the case of success.

Definition Classes
These
final def toValidationNonEmptyChunk[A1](implicit ev: <:<[A, NonEmptyChunk[A1]]): Validation[A1, Nothing]

Converts this value to a validation success if this value contains a success or a validation failure otherwise, submerging multiple errors into the structure of the validation and discarding information about any errors in the case of success.
Converts this value to a validation success if this value contains a success or a validation failure otherwise, submerging multiple errors into the structure of the validation and discarding information about any errors in the case of success.

Definition Classes
These
val value: A
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def zip[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, (Nothing, C)]

Combines this computation sequentially with that computation, combining their results into a tuple.
Combines this computation sequentially with that computation, combining their results into a tuple. If this computation does not return a success that computation will not be performed. If both computations are performed any errors will be combined using the Associative instance for A.

Definition Classes
These
final def zipLeft[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, Nothing]

Combines this computation sequentially with that computation, returning only the left value.
Combines this computation sequentially with that computation, returning only the left value. If this computation does not return a success that computation will not be performed. If both computations are performed any errors will be combined using the Associative instance for A.

Definition Classes
These
final def zipPar[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, (Nothing, C)]

Combines this computation with that computation into a tuple, performing both computations even if this computation does not return a success and combining any errors using the Commutative instance for A.
Combines this computation with that computation into a tuple, performing both computations even if this computation does not return a success and combining any errors using the Commutative instance for A.

Definition Classes
These
final def zipParLeft[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, Nothing]

Combines this computation with that computation and returning only the left value, performing both computations even if this computation does not return a success and combining any errors using the Commutative instance for A.
Combines this computation with that computation and returning only the left value, performing both computations even if this computation does not return a success and combining any errors using the Commutative instance for A.

Definition Classes
These
final def zipParRight[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, C]

Combines this computation with that computation and returning only the right value, performing both computations even if this computation does not return a success and combining any errors using the Commutative instance for A.
Combines this computation with that computation and returning only the right value, performing both computations even if this computation does not return a success and combining any errors using the Commutative instance for A.

Definition Classes
These
final def zipRight[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, C]

Combines this computation sequentially with that computation, returning only the right value.
Combines this computation sequentially with that computation, returning only the right value. If this computation does not return a success that computation will not be performed. If both computations are performed any errors will be combined using the Associative instance for A.

Definition Classes
These
final def zipWith[A1 >: A, C, D](that: These[A1, C])(f: (Nothing, C) ⇒ D)(implicit arg0: Associative[A1]): These[A1, D]

Combines this computation sequentially with that computation, combining their results with the specified function.
Combines this computation sequentially with that computation, combining their results with the specified function. If this computation does not return a success that computation will not be performed. If both computations are performed any errors will be combined using the Associative instance for A.

Definition Classes
These
final def zipWithPar[A1 >: A, C, D](that: These[A1, C])(f: (Nothing, C) ⇒ D)(implicit arg0: Commutative[A1]): These[A1, D]

Combines this computation with that computation using the specified function, performing both computations even if this computation does not return a success and combining any errors using the Commutative instance for A.
Combines this computation with that computation using the specified function, performing both computations even if this computation does not return a success and combining any errors using the Commutative instance for A.

Definition Classes
These

Related Doc: package These

final case class Left[+A](value: A) extends These[A, Nothing] with Product with Serializable

Instance Constructors

new Left(value: A)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def &>[A1 >: A, C](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, C]

final def *>[A1 >: A, C](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, C]

final def <&[A1 >: A, C](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, Nothing]

final def <&>[A1 >: A, C](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, (Nothing, C)]

final def <*[A1 >: A, C](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, Nothing]

final def <*>[A1 >: A, C](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, (Nothing, C)]

final def <+>[A1 >: A, C](that: ⇒ These[A1, C])(implicit arg0: Associative[A1]): These[A1, Either[Nothing, C]]

final def ==(arg0: Any): Boolean

final def >>=[A1 >: A, C](f: (Nothing) ⇒ These[A1, C])(implicit arg0: Associative[A1]): These[A1, C]

final def asInstanceOf[T0]: T0

final def bimap[A2, C](f: (A) ⇒ A2, g: (Nothing) ⇒ C): These[A2, C]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

final def flatMap[A1 >: A, C](f: (Nothing) ⇒ These[A1, C])(implicit arg0: Associative[A1]): These[A1, C]

final def flatten[A1 >: A, C](implicit ev: <:<[Nothing, These[A1, C]], ev2: Associative[A1]): These[A1, C]

final def flip: These[Nothing, A]

final def fold[C](left: (A) ⇒ C, right: (Nothing) ⇒ C)(both: (A, Nothing) ⇒ C): C

final def forEach[F[+_], C](f: (Nothing) ⇒ F[C])(implicit arg0: IdentityBoth[F], arg1: Covariant[F]): F[These[A, C]]

final def getClass(): Class[_]

final def isBoth: Boolean

final def isInstanceOf[T0]: Boolean

final def isLeft: Boolean

final def isRight: Boolean

final def map[C](f: (Nothing) ⇒ C): These[A, C]

final def mapLeft[A2](f: (A) ⇒ A2): These[A2, Nothing]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def orElse[A1 >: A, B1 >: Nothing](that: ⇒ These[A1, B1])(implicit arg0: Associative[A1]): These[A1, B1]

final def orElseEither[A1 >: A, C](that: ⇒ These[A1, C])(implicit arg0: Associative[A1]): These[A1, Either[Nothing, C]]

def reduceMap[C](f: (A) ⇒ C, g: (Nothing) ⇒ C)(implicit C: Associative[C]): C

final def synchronized[T0](arg0: ⇒ T0): T0

final def toEither: Either[A, Nothing]

final def toOption: Option[Nothing]

final def toValidation: Validation[A, Nothing]

final def toValidationNonEmptyChunk[A1](implicit ev: <:<[A, NonEmptyChunk[A1]]): Validation[A1, Nothing]

val value: A

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def zip[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, (Nothing, C)]

final def zipLeft[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, Nothing]

final def zipPar[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, (Nothing, C)]

final def zipParLeft[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, Nothing]

final def zipParRight[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Commutative[A1]): These[A1, C]

final def zipRight[A1 >: A, C, D](that: These[A1, C])(implicit arg0: Associative[A1]): These[A1, C]

final def zipWith[A1 >: A, C, D](that: These[A1, C])(f: (Nothing, C) ⇒ D)(implicit arg0: Associative[A1]): These[A1, D]

final def zipWithPar[A1 >: A, C, D](that: These[A1, C])(f: (Nothing, C) ⇒ D)(implicit arg0: Commutative[A1]): These[A1, D]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from These[A, Nothing]

Inherited from AnyRef

Inherited from Any

Ungrouped