scalaz

# LiskovFunctions

#### trait LiskovFunctions extends AnyRef

Source
Liskov.scala
Linear Supertypes
AnyRef, Any
Known Subclasses
Ordering
1. Alphabetic
2. By inheritance
Inherited
1. LiskovFunctions
2. AnyRef
3. Any
1. Hide All
2. Show all
Visibility
1. Public
2. All

### Value Members

1. #### final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
2. #### final def !=(arg0: Any): Boolean

Definition Classes
Any
3. #### final def ##(): Int

Definition Classes
AnyRef → Any
4. #### final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
5. #### final def ==(arg0: Any): Boolean

Definition Classes
Any
6. #### final def asInstanceOf[T0]: T0

Definition Classes
Any
7. #### def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
8. #### def co[T[_], A, A2](a: <~<[A, A2]): <~<[T[A], T[A2]]

We can lift subtyping into any invariant or covariant type constructor

12. #### def contra[T[-_], A, A2](a: <~<[A, A2]): <~<[T[A2], T[A]]

We can lift subtyping into any contravariant type constructor

22. #### final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
23. #### def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
24. #### def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
25. #### def force[A, B]: <~<[A, B]

Unsafely force a claim that A is a subtype of B

26. #### final def getClass(): Class[_]

Definition Classes
AnyRef → Any
27. #### def hashCode(): Int

Definition Classes
AnyRef → Any

29. #### final def isInstanceOf[T0]: Boolean

Definition Classes
Any
30. #### implicit def isa[A, B >: A]: <~<[A, B]

Lift Scala's subtyping relationship

31. #### 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)

32. #### 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)

33. #### 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)

34. #### 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)

35. #### 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)

36. #### 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)

37. #### 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

38. #### final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
39. #### final def notify(): Unit

Definition Classes
AnyRef
40. #### final def notifyAll(): Unit

Definition Classes
AnyRef
41. #### implicit def refl[A]: <~<[A, A]

Subtyping is reflexive

42. #### final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
43. #### def toString(): String

Definition Classes
AnyRef → Any
44. #### def trans[A, B, C](f: <~<[B, C], g: <~<[A, B]): <~<[A, C]

Subtyping is transitive

51. #### final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
52. #### final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
53. #### final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
54. #### implicit def witness[A, B](lt: <~<[A, B]): (A) ⇒ B

We can witness equality by using it to convert between types