Packages

object Liskov extends LiskovInstances

Source
Liskov.scala
Linear Supertypes
LiskovInstances, AnyRef, Any
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): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  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): Boolean
    Definition Classes
    AnyRef
  22. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  23. def finalize(): Unit
    Attributes
    protected[java.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]: Boolean
    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): Boolean
    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(): String
    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
    @native() @throws( ... )
  53. implicit def witness[A, B](lt: <~<[A, B]): (A) ⇒ B

    We can witness equality by using it to convert between types

Inherited from LiskovInstances

Inherited from AnyRef

Inherited from Any

Ungrouped