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:
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[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:
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, typeOr[G, B]
(which can be written in infix form asG Or B
) can be expressed in curried form asOr.GOOD[G]#BAD[B]
. Leaving off the finalBAD
type parameter yields a "type lambda," such asOr.GOOD[Int]#BAD
.For example, consider this method that takes two type parameters, a type constructor named
Context
and a type namedA
:Because
List
takes a single type parameter, it fits the shape ofContext
, it can be simply passed toexample
--i.e., the compiler will inferContext
asList
:But because
Or
takes two type parameters,G
for the "good" type andB
for the "bad" type, it cannot simply be passed, because the compiler doesn't know which ofG
or B you'd want to abstract over:You must therefore tell the compiler which one you want with a "type lambda." Here's an example:
The alternate type lambda syntax provided by this trait is more concise and hopefully easier to remember and read:
You can read
Or.GOOD[Int]#BAD
as: anOr
with its "good" type fixed toInt
and its "bad" type left unspecified.