Or
Related Docs:
class Or
| package scalactic
Trait providing a concise type lambda syntax for Or types partially applied on their "bad" type.
Trait providing a concise type lambda syntax for Or types partially applied on their "bad" type.
This trait is used to curry the type parameters of Or, which takes two type parameters,
into a type (this trait) which takes one parameter, and another (its type member) which
takes the other. For example, type Or[G, B] (which can be written in infix form
as G Or B) can be expressed in curried form as Or.BAD[B]#GOOD[G].
Leaving off the final G type parameter yields a "type lambda," such as Or.BAD[ErrorMessage]#GOOD.
For example, consider this method that takes two type parameters, a type constructor named Context and a
type named A:
scala> def example[Context[_], A](ca: Context[A]) = ca example: [Context[_], A](ca: Context[A])Context[A]
Because List takes a single type parameter, it fits the shape of Context,
it can be simply passed to example--i.e., the compiler will infer Context as List:
scala> example(List(1, 2, 3)) res0: List[Int] = List(1, 2, 3)
But because Or takes two type parameters, G for the "good" type and B for the "bad" type, it
cannot simply be passed, because the compiler doesn't know which of G or B you'd want to abstract over:
scala> example(Good(3))
<console>:26: error: no type parameters for method example: (ca: Context[A])Context[A] exist
so that it can be applied to arguments (org.scalactic.Good[Int,Nothing])
--- because ---
argument expression's type is not compatible with formal parameter type;
found : org.scalactic.Good[Int,Nothing]
required: ?Context[?A]
example(Good(3))
^
<console>:26: error: type mismatch;
found : org.scalactic.Good[Int,Nothing]
required: Context[A]
example(Good(3))
^
You must therefore tell the compiler which one you want with a "type lambda." Here's an example:
scala> example[({type L[G] = G Or String})#L, Int](Good(3))
res1: org.scalactic.Or[Int,String] = Good(3)
The alternate type lambda syntax provided by this trait is more concise and hopefully easier to remember and read:
scala> example[Or.BAD[String]#GOOD, Int](Good(3)) res2: org.scalactic.Or[Int,String] = Good(3)
You can read Or.BAD[String]#GOOD as: an Or with its "bad" type
fixed to String and its "good" type left unspecified.
Trait providing a concise type lambda syntax for Or types partially applied on their "good" type.
Trait providing a concise type lambda syntax for Or types partially applied on their "good" type.
This trait is used to curry the type parameters of Or, which takes two type parameters,
into a type (this trait) which takes one parameter, and another (its type member) which
takes the other. For example, type Or[G, B] (which can be written in infix form
as G Or B) can be expressed in curried form as Or.GOOD[G]#BAD[B].
Leaving off the final BAD type parameter yields a "type lambda," such as Or.GOOD[Int]#BAD.
For example, consider this method that takes two type parameters, a type constructor named Context and a
type named A:
scala> def example[Context[_], A](ca: Context[A]) = ca example: [Context[_], A](ca: Context[A])Context[A]
Because List takes a single type parameter, it fits the shape of Context,
it can be simply passed to example--i.e., the compiler will infer Context as List:
scala> example(List(1, 2, 3)) res0: List[Int] = List(1, 2, 3)
But because Or takes two type parameters, G for the "good" type and B for the "bad" type, it
cannot simply be passed, because the compiler doesn't know which of G or B you'd want to abstract over:
scala> example(Good(3))
<console>:26: error: no type parameters for method example: (ca: Context[A])Context[A] exist
so that it can be applied to arguments (org.scalactic.Good[Int,Nothing])
--- because ---
argument expression's type is not compatible with formal parameter type;
found : org.scalactic.Good[Int,Nothing]
required: ?Context[?A]
example(Good(3))
^
<console>:26: error: type mismatch;
found : org.scalactic.Good[Int,Nothing]
required: Context[A]
example(Good(3))
^
You must therefore tell the compiler which one you want with a "type lambda." Here's an example:
scala> example[({type L[B] = Int Or B})#L, String](Good(3))
res1: org.scalactic.Or[Int,String] = Good(3)
The alternate type lambda syntax provided by this trait is more concise and hopefully easier to remember and read:
scala> example[Or.GOOD[Int]#BAD, String](Good(3)) res15: org.scalactic.Or[Int,String] = Good(3)
You can read Or.GOOD[Int]#BAD as: an Or with its "good" type
fixed to Int and its "bad" type left unspecified.
Constructs a new Or from the given Option.
Constructs a new Or from the given Option.
the Option to convert to an Or
the Bad value to use if the Option passed as option is None.
a new Or whose Good type is the Option's type and whose
Bad type is the type of the passed orElse parameter.
Constructs a new Or from the given Either.
Constructs a new Or from the given Either.
Note that values effectively “switch sides” when converting an Either to an Or. If the type of the
Either which you pass to Or.from is Either[ErrorMessage, Int] for example, the result will be an
Or[Int, ErrorMessage]. The reason is that the convention for Either is that Left is used for “bad”
values and Right is used for “good” ones. If you with to keep the types on the same side, invoke swap on the
Either before passing it to from.
the Either to convert to an Or
a new Or whose Good type is the Either's Right type and whose
Bad type is Either's Left type.
Constructs a new Or from the given Try.
Constructs a new Or from the given Try.
the Try to convert to an Or
a new Or whose Good type is the Try's Success type and whose
Bad type is Throwable.
The companion object for
Orproviding factory methods for creatingOrs fromEithers andTrys.