o

scalaz

# Liskov 

### Companion class Liskov

#### object Liskov extends LiskovInstances

Source
Liskov.scala
Linear Supertypes
Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. Liskov
2. LiskovInstances
3. AnyRef
4. Any
1. Hide All
2. Show All
Visibility
1. Public
2. All

### Type Members

1. type <~<[-A, +B] = Liskov[A, B]

A convenient type alias for Liskov

2. type >~>[+B, -A] = Liskov[A, B]

A flipped alias, for those used to their arrows running left to right

### Value Members

1. final def !=(arg0: Any)
Definition Classes
AnyRef → Any
2. final def ##(): Int
Definition Classes
AnyRef → Any
3. final def ==(arg0: Any)
Definition Classes
AnyRef → Any
4. final def asInstanceOf[T0]: T0
Definition Classes
Any
5. def clone()
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
6. def co[T[+_], A, A2](a: <~<[A, A2]): <~<[T[A], T[A2]]

We can lift subtyping into any covariant type constructor

7. def co2[T[+_, _], Z, A, B](a: <~<[A, Z]): <~<[T[A, B], T[Z, B]]
8. def co2_2[T[_, +_], Z, A, B](a: <~<[B, Z]): <~<[T[A, B], T[A, Z]]
9. def co3[T[+_, _, _], Z, A, B, C](a: <~<[A, Z]): <~<[T[A, B, C], T[Z, B, C]]
10. def co4[T[+_, _, _, _], Z, A, B, C, D](a: <~<[A, Z]): <~<[T[A, B, C, D], T[Z, B, C, D]]
11. def contra[T[-_], A, A2](a: <~<[A, A2]): <~<[T[A2], T[A]]

We can lift subtyping into any contravariant type constructor

12. def contra1_2[T[-_, _], Z, A, B](a: <~<[A, Z]): <~<[T[Z, B], T[A, B]]
13. def contra1_3[T[-_, _, _], Z, A, B, C](a: <~<[A, Z]): <~<[T[Z, B, C], T[A, B, C]]
14. def contra1_4[T[-_, _, _, _], Z, A, B, C, D](a: <~<[A, Z]): <~<[T[Z, B, C, D], T[A, B, C, D]]
15. def contra2_2[T[_, -_], Z, A, B](a: <~<[B, Z]): <~<[T[A, Z], T[A, B]]
16. def contra2_3[T[_, -_, _], Z, A, B, C](a: <~<[B, Z]): <~<[T[A, Z, C], T[A, B, C]]
17. def contra2_4[T[_, -_, _, _], Z, A, B, C, D](a: <~<[B, Z]): <~<[T[A, Z, C, D], T[A, B, C, D]]
18. def contra3_3[T[_, _, -_], Z, A, B, C](a: <~<[C, Z]): <~<[T[A, B, Z], T[A, B, C]]
19. def contra3_4[T[_, _, -_, _], Z, A, B, C, D](a: <~<[C, Z]): <~<[T[A, B, Z, D], T[A, B, C, D]]
20. def contra4_4[T[_, _, _, -_], Z, A, B, C, D](a: <~<[D, Z]): <~<[T[A, B, C, Z], T[A, B, C, D]]
21. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
22. def equals(arg0: Any)
Definition Classes
AnyRef → Any
23. def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
24. def force[A, B]: <~<[A, B]

Unsafely force a claim that A is a subtype of B

25. final def getClass(): Class[_]
Definition Classes
AnyRef → Any
Annotations
@native()
26. def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
27. final def isInstanceOf[T0]
Definition Classes
Any
28. implicit def isa[A, B >: A]: <~<[A, B]

Lift Scala's subtyping relationship

29. def lift2[T[+_, +_], A, A2, B, B2](a: <~<[A, A2], b: <~<[B, B2]): <~<[T[A, B], T[A2, B2]]

lift2(a,b) = co1_2(a) compose co2_2(b)

30. def lift3[T[+_, +_, +_], A, A2, B, B2, C, C2](a: <~<[A, A2], b: <~<[B, B2], c: <~<[C, C2]): <~<[T[A, B, C], T[A2, B2, C2]]

lift3(a,b,c) = co1_3(a) compose co2_3(b) compose co3_3(c)

31. def lift4[T[+_, +_, +_, +_], A, A2, B, B2, C, C2, D, D2](a: <~<[A, A2], b: <~<[B, B2], c: <~<[C, C2], d: <~<[D, D2]): <~<[T[A, B, C, D], T[A2, B2, C2, D2]]

lift4(a,b,c,d) = co1_3(a) compose co2_3(b) compose co3_3(c) compose co4_4(d)

32. def liftF1[F[-_, +_], A, A2, R, R2](a: <~<[A, A2], r: <~<[R, R2]): <~<[F[A2, R], F[A, R2]]

Lift subtyping into a Function1-like type liftF1(a,r) = contra1_2(a) compose co2_2(b)

33. def liftF2[F[-_, -_, +_], A, A2, B, B2, R, R2](a: <~<[A, A2], b: <~<[B, B2], r: <~<[R, R2]): <~<[F[A2, B2, R], F[A, B, R2]]

Lift subtyping into a function liftF2(a,b,r) = contra1_3(a) compose contra2_3(b) compose co3_3(c)

34. def liftF3[F[-_, -_, -_, +_], A, A2, B, B2, C, C2, R, R2](a: <~<[A, A2], b: <~<[B, B2], c: <~<[C, C2], r: <~<[R, R2]): <~<[F[A2, B2, C2, R], F[A, B, C, R2]]

Lift subtyping into a function liftF3(a,b,c,r) = contra1_4(a) compose contra2_4(b) compose contra3_4(c) compose co3_4(d)

35. def liftF4[F[-_, -_, -_, -_, +_], A, A2, B, B2, C, C2, D, D2, R, R2](a: <~<[A, A2], b: <~<[B, B2], c: <~<[C, C2], d: <~<[D, D2], r: <~<[R, R2]): <~<[F[A2, B2, C2, D2, R], F[A, B, C, D, R2]]

Lift subtyping into a function

36. implicit val liskov: Category[<~<]

Subtyping forms a category

Subtyping forms a category

Definition Classes
LiskovInstances
37. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
38. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
39. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
40. implicit def refl[A]: <~<[A, A]

Subtyping is reflexive

41. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
42. def toString()
Definition Classes
AnyRef → Any
43. def trans[A, B, C](f: <~<[B, C], g: <~<[A, B]): <~<[A, C]

Subtyping is transitive

44. def unco[F[_], Z, A](a: <~<[F[A], F[Z]])(implicit arg0: Injective[F]): <~<[A, Z]
45. def unco2_1[F[+_, _], Z, A, B](a: <~<[F[A, B], F[Z, B]])(implicit arg0: Injective2[F]): <~<[A, Z]
46. def unco2_2[F[_, +_], Z, A, B](a: <~<[F[A, B], F[A, Z]])(implicit arg0: Injective2[F]): <~<[B, Z]
47. def uncontra[F[-_], Z, A](a: <~<[F[A], F[Z]])(implicit arg0: Injective[F]): <~<[Z, A]
48. def uncontra2_1[F[-_, _], Z, A, B](a: <~<[F[A, B], F[Z, B]])(implicit arg0: Injective2[F]): <~<[Z, A]
49. def uncontra2_2[F[_, -_], Z, A, B](a: <~<[F[A, B], F[A, Z]])(implicit arg0: Injective2[F]): <~<[Z, B]
50. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
51. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
52. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
53. implicit def witness[A, B](lt: <~<[A, B]): (A) ⇒ B

We can witness equality by using it to convert between types