Copyright 2018 Tendril, Inc. All rights reserved.

Transcription

1

2 Type Parameter Power-Up! Variance, Bounds, and Inference

3 INTRO Motivations 3

4 INTRO Motivations Home Energy Report Generation System Free Monad Workflow stages extending common base class Workflow actions parameterized with a Report type Different Reports extend Report base class Single reports, Optional reports, Lists of reports 4

5 INTRO Helpful Compiler is Helpful [info] Compiling 1 Scala source to /Users/cphelps/learning/type-parameter-powerup/target/scala-2.12/test-classes... [error] /Users/cphelps/learning/type-parameter-powerup/src/test/scala/example/VarianceSpec.scala:55:14: covariant type A occurs in contravariant position in type A of value newwrapped [error] def swap(newwrapped: A): Wrapper[A] = new Wrapper(newwrapped) [error] ^ [error] one error found 5

6 INTRO Helpful Compiler is Helpful [info] Compiling 1 Scala source to /Users/cphelps/learning/type-parameter-powerup/target/scala-2.12/test-classes... [error] /Users/cphelps/learning/type-parameter-powerup/src/test/scala/example/VarianceSpec.scala:55:14: covariant type A occurs in contravariant position in type A of value newwrapped [error] def swap(newwrapped: A): Wrapper[A] = new Wrapper(newwrapped) [error] ^ [error] one error found 6

7 INTRO Motivations 7

8 INTRO Motivations Users o Signatures of APIs what is it looking for? o What will the API accept? o How do I make the API interact with my domain class hierarchy? o How do I make sense of these weird error messages? API Designers o What do I want to allow? o What sorts of flexibility do I want to offer? o How do I make sense of these weird error messages? 8

9 How I stopped worrying about variance: Just add +/- until it compiles Adriaan Moors

10 INTRO Overview Variance Constraints and Typeclasses Dotty / Scala 3 10

11 Variance 11

12 VARIANCE Inheritance and Substitution All values have a type Types have a supertype relationship up to Any Types have a subtype relationship down to Nothing References can store subclass instances Functions can be passed subclass instances Functions can return subclass instances 12

13 VARIANCE Liskov Substitution Principle Subtype Requirement: Let ϕ ( x ) be a property provable about objects x of type T. Then ϕ ( y ) should be true for objects y of type S where S is a subtype of T. [Liskov and Wing, 1994] If S is a subtype of T, then objects of type T in a program may be replaced with objects of type S without altering any of the desirable properties of that program. [Wikipedia] 13

14 VARIANCE Higher-Kinded Types Generic Classes Types with parameters Contain or implemented in terms of another type o List[Int] o List[T] 14

15 VARIANCE Two Axes of Subclassing Container Superclass Contents Superclass Contents Subclass Container Subclass 15

16 VARIANCE Variance Defined Variance is the correlation of subtyping relationships of complex types and the subtyping relationships of their component types. [Tour of Scala] A central question that comes up when mixing OO with polymorphism is: if U is a subclass of T, is Container[U] considered a subclass of Container[T]? [Twitter Scala School] 16

17 VARIANCE Apply the LSP Variance is the correlation of when we can substitute complex types and the when we can substitute their component types. [Tour of Scala] A central question that comes up when mixing OO with polymorphism is: if U is a subclass of T, can Container[U] be substituted for Container[T]? [Twitter Scala School] 17

18 VARIANCE Substituting Compatible Machines 18

19 VARIANCE Domain Data Animal abstract class Animal { def name: String } abstract class Pet extends Animal case class Cat(name: String) extends Pet Pet case class Dog(name: String) extends Pet Cat Dog 19

20 VARIANCE Invariance The Default Case No subclass relationship Cannot substitute Container[T] for Container[U] unless T is U Subclasses SubContainer[T] can be substituted for Container[T] Exposed vars must be invariant Influences type inference 20

21 VARIANCE Invariance Examples Animal class InvariantWrapper[A](wrapped: A) { def unwrapped: A = wrapped } val w: InvariantWrapper[Cat] = new InvariantWrapper(Cat( Morris")) Pet class SubWrapper[A](wrapped: A) extends InvariantWrapper(wrapped) {} Cat Dog val sw: InvariantWrapper[Cat] = new SubWrapper(Cat("Milo")) val aw: InvariantWrapper[Animal] = new InvariantWrapper[Cat](Cat("Bill")) 21

22 VARIANCE Invariance Examples Animal class InvariantWrapper[A](wrapped: A) { def unwrapped: A = wrapped } val w: InvariantWrapper[Cat] = new InvariantWrapper(Cat( Morris")) Pet class SubWrapper[A](wrapped: A) extends InvariantWrapper(wrapped) {} Cat Dog val sw: InvariantWrapper[Cat] = new SubWrapper(Cat("Milo")) type mismatch; found: InvariantWrapper[Cat] val aw: required: InvariantWrapper[Animal] = Note: example.cat <: example.animal, new but InvariantWrapper[Cat](Cat("Bill")) class is invariant in type A. 22

23 VARIANCE Covariance Sources of Values Subclass relationship when contents have a subclass relationship Can substitute Container[U] for Container[T] if U is a subclass of T Useful for extracting the contents of the container o Instances of U can be used where T instances are expected o Container[U] will produce T instances o Types are sound Problematic when adding or changing values 23

24 VARIANCE Covariance Examples class CovariantWrapper[+A](wrapped: A) { def unwrapped: A = wrapped } Animal def doit(thing: CovariantWrapper[Animal]) =??? Pet doit(new CovariantWrapper[Cat](Cat("Garfield"))) doit(new CovariantWrapper[Dog](Dog( Odie ))) Cat Dog doit(new CovariantWrapper[Any](Cat("Nermal"))) 24

25 VARIANCE Covariance Examples class CovariantWrapper[+A](wrapped: A) { def unwrapped: A = wrapped } Animal def doit(thing: CovariantWrapper[Animal]) =??? Cat Pet doit(new CovariantWrapper[Cat](Cat("Garfield"))) doit(new CovariantWrapper[Dog](Dog( Odie ))) Dog doit(new CovariantWrapper[Any](Cat("Nermal"))) type mismatch; found: CovariantWrapper[Any] required: CovariantWrapper[Animal] 25

26 VARIANCE Contravariance Consumers of Values Subclass relationship when contents have a superclass relationship Can substitute Container[T] for Container[U] if T is a superclass of U Useful for processors or consumers of values o Instances of U can be used where T instances are expected o Consumer[U] can consume T instances o Types are sound Problematic when returning or producing values 26

27 VARIANCE Contravariance Examples Animal abstract class Keeper[-A] { def tend(input: A): Unit } class DogSitter extends Keeper[Dog] { override def tend(input: Dog): Unit =??? } class ZooKeeper extends Keeper[Animal] {... } class PetSitter extends Keeper[Pet] {... } Cat Pet Dog val ds: Keeper[Dog] = new DogSitter ds.tend(dog("tintin")) val zoo: Keeper[Dog] = new ZooKeeper zoo.tend(dog("scooby")) val petco: Keeper[Pet] = new DogSitter petco.tend(dog("ceasar")) 27

28 VARIANCE Contravariance Examples Animal abstract class Keeper[-A] { def tend(input: A): Unit } class DogSitter extends Keeper[Dog] { override def tend(input: Dog): Unit =??? } class ZooKeeper extends Keeper[Animal] {... } class PetSitter extends Keeper[Pet] {... } Cat Pet Dog val ds: Keeper[Dog] = new DogSitter ds.tend(dog("tintin")) val zoo: Keeper[Dog] = new ZooKeeper zoo.tend(dog("scooby")) val petco: Keeper[Pet] = new DogSitter type mismatch; found : DogSitter required: Keeper[example.Pet] petco.tend(dog("ceasar")) 28

29 VARIANCE Positions Covariant Position method returns Contravariant Position method arguments Invariant Position - mutable vars Covariant parameters cannot appear in contravariant position Contravariant parameters cannot appear in covariant position Covariant or contravariant parameters cannot appear in invariant position o Scala and IntelliJ error messages misleading 29

30 VARIANCE The Problem with Contravariant Positions class Box[+Pet](p: Pet) { // won't compile Covariant in contravariant pos def swap(newp: Pet): Box[Pet] = new Box[Pet](newp) } val mypet = new Box[Cat](Cat( Morris )) // Seems okay so far mypet.swap(cat("cassie")) // Oops, we can't store a Dog in a Box[Cat] mypet.swap(dog("ceasar")) 30

31 VARIANCE The Problem with Covariant Positions class Sitter[-Pet](p: Pet) { // won't compile - contravariant in covariant pos def walk(): Pet =??? } val mysitter: Sitter[Cat] = new Sitter[Pet](Cat("Doraemon")) // seems okay val walkedpet: Pet = mysitter.walk() // if walk returns a Cat, everything is ok // if it returns a Dog, we have a problems // if it returns a Pet, we have a problem. val walked: Cat = mysitter.walk() 31

32 VARIANCE Function Inputs Animal Pet val p1: Pet val p2: Pet f(p1, p2) def f(a: Pet, b: Pet): Pet def f(a: Animal, b: Pet): Pet def f(a: Any, b: Pet): Pet def f(a: Any, b: Any): Pet Cat Dog def f(a: Cat, b: Dog): Pet Function2[-T1, -T2, R] 32

33 VARIANCE Function Outputs Animal Pet val p1: Pet val p2: Pet val r: Animal = f(p1, p2) def f(a: Pet, b: Pet): Animal def f(a: Pet, b: Pet): Pet def f(a: Pet, b: Pet): Cat Cat Dog def f(a: Pet, b: Pet): Any Function2[-T1, -T2, +R] 33

34 VARIANCE When to Use Covariance o Containers o Producers o Representing inputs Contravariance o Consumers o Processors or Visitors o Representing outputs Invariance o Distinct types o Markers or Labels o Influence inference 34

35 Constraints and Typeclasses 35

36 CONSTRAINTS AND TYPECLASSES Upper and Lower Bounds Constrain the valid types Upper bound parameter is same or subtype o def pet[p <: Pet](animal: P): Unit =??? Lower bound parameter is same or supertype o def pre[b >: A](x: B, xs: List[A]): List[B] =???

37 CONSTRAINTS AND TYPECLASSES Bounds and Variance abstract class List[+A] {... } case object Nil extends List[Nothing] {... } case class Cons[B] (elem: B, tail: List[B]) extends List[B] {... } 37

38 CONSTRAINTS AND TYPECLASSES Bounds and Variance abstract class List[+A] { } def prepend(elem: A): List[A] =??? case object Nil extends List[Nothing] {... } case class Cons[B] (elem: B, tail: List[B]) extends List[B] {... } 38

39 CONSTRAINTS AND TYPECLASSES Bounds and Variance abstract class List[+A] { } def prepend(elem: A): List[A] =??? covariant type A occurs in contravariant position in type A of value elem case object Nil extends List[Nothing] {... } case class Cons[B] (elem: B, tail: List[B]) extends List[B] {... } 39

40 CONSTRAINTS AND TYPECLASSES Bounds and Variance abstract class List[+A] { def prepend[b](elem: B): List[B] = new Cons(elem, this) } case object Nil extends List[Nothing] {... } case class Cons[B] (elem: B, tail: List[B]) extends List[B] {... } 40

41 CONSTRAINTS AND TYPECLASSES Bounds and Variance abstract class List[+A] { def prepend[b](elem: B): List[B] = new Cons(elem, this) } type mismatch; found: List[A] required: List[B] case object Nil extends List[Nothing] {... } case class Cons[B] (elem: B, tail: List[B]) extends List[B] {... } 41

42 CONSTRAINTS AND TYPECLASSES Bounds and Variance abstract class List[+A] { } def prepend[b >: A] (elem: B): List[B] =??? case object Nil extends List[Nothing] {... } case class Cons[B] (elem: B, tail: List[B]) extends List[B] {... } 42

43 CONSTRAINTS AND TYPECLASSES Change to a Wider Type scala> List(1, 2, 3, 4, 5) res0: List[Int] = List(1, 2, 3, 4, 5) scala> 0 :: res0 res1: List[Int] = List(0, 1, 2, 3, 4, 5) scala> 1.5 :: res0 res2: List[AnyVal] = List(1.5, 1, 2, 3, 4, 5) scala> res2(0) res3: AnyVal = 1.5 scala> res2(1) res4: AnyVal = 1 43

44 CONSTRAINTS AND TYPECLASSES View Bounds Deprecated from 2.11 [ A <% B ] Indicates A is convertable to B by implicit conversion Introduces evidence parameter o def view[aa <% A](x: AA): A =??? o def view$[aa](x: AA)(implicit ev1$: AA => A) =??? 44

45 CONSTRAINTS AND TYPECLASSES Context Bounds [ A : Ctx ] Indicates A has some context Ctx o There exists a Ctx[A] in implicit scope Introduces an evidence parameter o def ctxbound[x: M](x: X) =??? o def ctxbound[x](x: X)(implicit ev1$: M[X]) =??? Access the context with the implicitly keyword o val m = implicitly[m[x]] o m.somemethod() 45

46 CONSTRAINTS AND TYPECLASSES Typeclass Pattern External implementation of an interface o No need to extend directly o Possible without access to class source Introduce via a context bound Implement in terms of of other instances o Adder[Pair[Int]] defined in terms of Adder[Int] 46

47 CONSTRAINTS AND TYPECLASSES Typeclass Pattern Define an interface Implement for your class Introduce to implicit scope Pass to function as implicit parameter OR as type constraint Call methods from the interface 47

48 CONSTRAINTS AND TYPECLASSES Typeclass Example trait Adder[A] { def add(x: A, y: A): A } implicit val IntAdder = new Adder[Int] { override def add(x: Int, y: Int): Int = x + y } def addthings[t: Adder](x: T, y: T): T = { implicitly[adder[t]].add(x, y) } addthings(5, 7) 48

49 Inductive Typeclass Definition case class Pair[T](fst: T, snd: T) implicit def pairadder[t: Adder] = new Adder[Pair[T]] { override def add(x: Pair[T], y: Pair[T]): Pair[T] = { val ta = implicitly[adder[t]] Pair(ta.add(x.fst, y.fst), ta.add(x.snd, y.snd)) } } 49

50 DOTTY Dotty / Scala 3

51 DOTTY Dotty Changes Scala 3 is fundamentally the same language as Scala 2 Variance and type bounds still exist essentially the same o Current dotc slightly different error messages No existential types (but other constructs instead) Structural types different implementation

52 Takeaways Variance o Substitution o Arises naturally as a consequence of Liskov Substitution o Deeply entwined with subclassing in higher-kinded types Bounds o Interact with variance -> widening o Interact with implicits -> typeclasses 52

53 @CJPhelps github.com/chrisphelps/type-parameter-power-up