object As extends AsInstances with Serializable
- Alphabetic
- By Inheritance
- As
- Serializable
- Serializable
- AsInstances
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
co[T[+_], A, A2](a: As[A, A2]): As[T[A], T[A2]]
We can lift subtyping into any covariant type constructor
- def co2[T[+_, _], Z, A, B](a: As[A, Z]): As[T[A, B], T[Z, B]]
-
def
co2_2[T[_, +_], Z, A, B](a: As[B, Z]): As[T[A, B], T[A, Z]]
Widen a F[X,+A] to a F[X,B] if (A As B).
Widen a F[X,+A] to a F[X,B] if (A As B). This can be used to widen the output of a Function1, for example.
- def co3[T[+_, _, _], Z, A, B, C](a: As[A, Z]): As[T[A, B, C], T[Z, B, C]]
- def co3_2[T[_, +_, _], Z, A, B, C](a: As[B, Z]): As[T[A, B, C], T[A, Z, C]]
- def co3_3[T[+_, _, +_], Z, A, B, C](a: As[C, Z]): As[T[A, B, C], T[A, B, Z]]
-
def
compose[A, B, C](f: As[B, C], g: As[A, B]): As[A, C]
Subtyping is transitive
-
def
conF[A, B, C](ev: As[B, A])(fa: (A) ⇒ C): (B) ⇒ C
Use this relationship to narrow the input type of a Function1
-
def
contra[T[-_], A, B](a: As[A, B]): As[T[B], T[A]]
We can lift a subtyping relationship into a contravariant type constructor.
We can lift a subtyping relationship into a contravariant type constructor.
Given that F has the shape: F[-_], we show that: (A As B) implies (F[B] As F[A])
- def contra1_2[T[-_, _], Z, A, B](a: As[A, Z]): As[T[Z, B], T[A, B]]
- def contra1_3[T[-_, _, _], Z, A, B, C](a: As[A, Z]): As[T[Z, B, C], T[A, B, C]]
- def contra2_2[T[_, -_], Z, A, B](a: As[B, Z]): As[T[A, Z], T[A, B]]
- def contra2_3[T[_, -_, _], Z, A, B, C](a: As[B, Z]): As[T[A, Z, C], T[A, B, C]]
- def contra3_3[T[_, _, -_], Z, A, B, C](a: As[C, Z]): As[T[A, B, Z], T[A, B, C]]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
fromPredef[A, B](eq: <:<[A, B]): As[A, B]
It can be convenient to convert a <:< value into a
<~<
value.It can be convenient to convert a <:< value into a
<~<
value. This is not strictly valid as while it is almost certainly true thatA <:< B
impliesA <~< B
it is not the case that you can create evidence ofA <~< B
except via a coercion. Use responsibly. -
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
invF[C, D, A, B](ev1: As[D, C], ev2: As[A, B])(fa: (C) ⇒ A): (D) ⇒ B
Use this relationship to widen the output type and narrow the input type of a Function1
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
lift2[T[+_, +_], A, A2, B, B2](a: As[A, A2], b: As[B, B2]): As[T[A, B], T[A2, B2]]
widen two types for binary type constructors covariant in both parameters
widen two types for binary type constructors covariant in both parameters
lift2(a,b) = co1_2(a) compose co2_2(b)
-
implicit
val
liskov: Category[As]
- Definition Classes
- AsInstances
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
onF[X, A, B](ev: As[A, B])(fa: (X) ⇒ A): (X) ⇒ B
Use this relationship to widen the output type of a Function1
-
implicit
def
refl[A]: As[A, A]
Subtyping is reflexive
-
def
reify[A, B >: A]: As[A, B]
reify a subtype relationship as a Liskov relationship
reify a subtype relationship as a Liskov relationship
- Annotations
- @inline()
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
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( ... ) @native()
-
implicit
def
witness[A, B](lt: As[A, B]): (A) ⇒ B
We can witness the relationship by using it to make a substitution *