Essential Scala. Six Core Concepts for Learning Scala Noel underscore

Transcription

1 Essential Scala Six Core Concepts for Learning Scala Noel underscore

2 Introduction

3 Overview

4

5 1. Expressions, types, & values 2. Objects and classes 3. Algebraic data types 4. Structural recursion 5. Sequencing computation 6. Type classes

6 1. Expressions, types, & values 2. Objects and classes 3. Algebraic data types 4. Structural recursion 5. Sequencing computation 6. Type classes

7 Motivation

8 There are simple patterns in effective use of Scala

9 Improve the teaching of Scala

10 Huge thanks to the PLT team people.html

11

12 Expressions, Types, and Values

13 Goal: model of evaluation

14 1 + 1 Expression

15 Int Type Expression

16 Int Type Expression 2 Value

17 Types exist at compiletime, values at run-time

18 Basic language features, syntax

19 Objects and Classes

20 Goal: familiarity with syntax

21 Objects and classes!

22 Case classes and pattern matching

23 Largely practicing syntax

24 Algebraic Data Types

25 Goal: translate data descriptions into code

26 Model data with logical ors and logical ands

27 A website visitor is: logged in; or anonymous

28 A logged in user has: an ID; and an address

29 Structure of the code follows the structure of the data

30 Two patterns: product types (and) sum types (or)

31 Product type: A has a B and C

32 final case class A(b: B, c: C) A has a B and C

33 final case class A(b: B, c: C) A has a B and C

34 final case class A(b: B, c: C) A has a B and C

35 final case class A(b: B, c: C) A has a B and C

36 Sum type: A is a B or C

37 sealed trait A final case class B() extends A final case class C() extends A A is a B or C

38 sealed trait A final case class B() extends A final case class C() extends A A is a B or C

39 sealed trait A final case class B() extends A final case class C() extends A A is a B or C

40 sealed trait A final case class B() extends A final case class C() extends A A is a B or C

41 Sum and product together make algebraic data types

42 Examples

43 A website visitor is: logged in; or anonymous

44 sealed trait Visitor final case class Anonymous() extends Visitor final case class User() extends Visitor

45 A logged in user has: an ID; and an address An anonymous has: an ID

46 sealed trait Visitor { id: Id } final case class Anonymous(id: Id) extends Visitor final case class User(id: Id, ) extends Visitor

47 A calculation is a success or failure

48 sealed trait Calculation final case class Success() extends Calculation final case class Failure() extends Calculation

49 A success has an value. A failure has an error message

50 sealed trait Calculation final case class Success(value: Int) extends Calculation final case class Failure(msg: String) extends Calculation

51 Summary Structure data with logical ands and ors These are called algebraic data types Code follows immediately from structure of the data

52 Structural Recursion

53 Goal: transform algebraic data types

54 sealed trait Calculation final case class Success(value: Int) extends Calculation final case class Failure(msg: String) extends Calculation

55 Implement on Calculation def add(value: Int): Calculation =???

56 Structure of the code follows structure of the data

57 Two (sub-)patterns: pattern matching and polymorphism

58 A is a B or C B has a D and E C has a F and G

59 sealed trait A final case class B(d: D, e: E) extends A final case class C(f: F, g: G) extends A

60 Pattern matching

61 sealed trait A { def dosomething: H = { this match { case B(d, e) => dob(d, e) case C(f, g) => doc(f, g) } } } final case class B(d: D, e: E) extends A final case class C(f: F, g: G) extends A

62 Polymorphism

63 sealed trait A { def dosomething: H } final case class B(d: D, e: E) extends A { def dosomething: H = dob(d, e) } final case class C(f: F, g: G) extends A { def dosomething: H = doc(f, g) }

64 Example

65 sealed trait Calculation final case class Success(value: Int) extends Calculation final case class Failure(msg: String) extends Calculation

66 Add an Int to a Calculation

67 sealed trait Calculation { def add(value: Int): Calculation =??? } final case class Success(value: Int) extends Calculation final case class Failure(msg: String) extends Calculation

68 sealed trait Calculation { def add(value: Int): Calculation = this match { case Success(v) =>??? case Failure(msg) =>??? } } final case class Success(value: Int) extends Calculation final case class Failure(msg: String) extends Calculation

69 sealed trait Calculation { def add(value: Int): Calculation = this match { case Success(v) => Success(v + value) case Failure(msg) => Failure(msg) } } final case class Success(value: Int) extends Calculation final case class Failure(msg: String) extends Calculation

70 Summary Processing algebraic data types immediately follows from the structure of the data Can choose between pattern matching and polymorphism Pattern matching (within the base trait) is usually preferred

71 Sequencing Computation

72 Goal: patterns for sequencing computations

73 Functional programming is about transforming values

74 That is all you can do without introducing sideeffects

75 A => B => C

76 This is sequencing computations

77 Three patterns: fold, map, and flatmap

78 Fold A => B

79 Abstraction over structural recursion

80 sealed trait A { def dosomething: H = { this match { case B(d, e) => dob(d, e) case C(f, g) => doc(f, g) } } } final case class B(d: D, e: E) extends A final case class C(f: F, g: G) extends A

81 sealed trait A { def dosomething: H = { this match { case B(d, e) => dob(d, e) case C(f, g) => doc(f, g) } } } final case class B(d: D, e: E) extends A final case class C(f: F, g: G) extends A

82 sealed trait A { def fold(dob: (D, E) => H, doc: (F, G) => H): H = { this match { case B(d, e) => dob(d, e) case C(f, g) => doc(f, g) } } } final case class B(d: D, e: E) extends A final case class C(f: F, g: G) extends A

83 Example

84 A Result is a Success or Failure

85 sealed trait Result final case class Success() extends Result final case class Failure() extends Result

86 Success contains a value of type A

87 sealed trait Result[A] final case class Success[A](value: A) extends Result[A] final case class Failure[A]() extends Result[A]

88 (This just an invariant Option)

89 Implement fold

90 Start with structural recursion pattern

91 sealed trait Result[A] { def fold[b]: B = this match { Success(v) =>??? Failure() =>??? } } final case class Success[A](value: A) extends Result[A] final case class Failure[A]() extends Result[A]

92 Abstract out arguments

93 sealed trait Result[A] { def fold[b](s: A => B, f: B): B = this match { Success(v) => s(v) Failure() => f } } final case class Success[A](value: A) extends Result[A] final case class Failure[A]() extends Result[A]

94 Fold is a generic transform for any algebraic data type

95 Fold is not always the best choice

96 Not all data is an algebraic data type

97 Sometimes other methods are easier to use

98 Result[A]

99 Get user from database (might not be a user)

100 Result[User] Convert user to JSON

101 Result[User] User => Json Result[Json]

102 Map map = F[A] A => B F[B]

103 Get user from database (might not be a user)

104 Result[User] Get order for user (might not be an order)

105 Result[User] User => Result[Order] Result[Order]

106 FlatMap flatmap = F[A] A => F[B] F[B]

107 Example

108 getorder(id: UserId): HttpResponse

109 UserId UserId => Result[User] User => Result[Order] Order => Json Result[Json] => HttpResponse

110 UserId UserId => Result[User] User => Result[Order] Order => Json Result[Json] => HttpResponse

111 UserId UserId => Result[User] User => Result[Order]??? Order => Json Result[Json] => HttpResponse

112 UserId UserId => Result[User] User => Result[Order] flatmap Order => Json Result[Json] => HttpResponse

113 UserId UserId => Result[User] User => Result[Order] Order => Json Result[Json] => HttpResponse

114 UserId??? UserId => Result[User] User => Result[Order] Order => Json Result[Json] => HttpResponse

115 UserId map UserId => Result[User] User => Result[Order] Order => Json Result[Json] => HttpResponse

116 UserId UserId => Result[User] User => Result[Order] Order => Json Result[Json] => HttpResponse

117 UserId??? UserId => Result[User] User => Result[Order] Order => Json Result[Json] => HttpResponse

118 UserId fold UserId => Result[User] User => Result[Order] Order => Json Result[Json] => HttpResponse

119 Summary Standard patterns for sequencing computations F[A] map (A => B) = F[B] F[A] flatmap (A => F[B]) = F[B] fold is general transformation for algebraic data types You can teach monads in an introductory course!

120 Type Classes

121 Ad-hoc polymorphism

122 Break free from your class oppressors!

123 Conclusions

124 Scala is simple

125 3 patterns are 90% of code

126 4 patterns are 99% of code

127 Program design in Scala is systematic

128 Be like keyboard cat!

129 underscore.io/training/ courses/essentialscala/