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:
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:
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:
Trait providing a concise type lambda syntax for
Ortypes 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, typeOr[G, B](which can be written in infix form asG Or B) can be expressed in curried form asOr.BAD[B]#GOOD[G]. Leaving off the finalGtype parameter yields a "type lambda," such asOr.BAD[ErrorMessage]#GOOD.For example, consider this method that takes two type parameters, a type constructor named
Contextand a type namedA:Because
Listtakes a single type parameter, it fits the shape ofContext, it can be simply passed toexample--i.e., the compiler will inferContextasList:But because
Ortakes two type parameters,Gfor the "good" type andBfor the "bad" type, it cannot simply be passed, because the compiler doesn't know which ofGor 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:
You can read
Or.BAD[String]#GOODas: anOrwith its "bad" type fixed toStringand its "good" type left unspecified.