Types And Categories. Anat Gilboa

Transcription

1 Types And Categories Anat Gilboa 1

2 Background 2

3 The Plan 3

4 The Plan 4

5 The Plan 5

6 6

7 What to expect "Functional Swift" Closures Types & Categories 7

8 8

9 Swift Swift is a general-purpose programming language built using a modern approach to safety, performance, and software design patterns. Swift.org 9

10 Features Closures unified with function pointers Tuples and multiple return values Generics Fast and concise iteration over a range or collection Structs that support methods, extensions, and protocols Functional programming patterns, e.g., map and filter Powerful error handling built-in Advanced control flow with do, guard, defer, and repeat keywords 10

11 Features Functional programming patterns, e.g., map and filter Closures unified with function pointers 11

12 Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. 12

13 Functional Programming Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. paradigm. (n) A worldview underlying the theories and methodology of a particular scientific subject 13

14 Some Paradigms Procedural (imperative) programming - decomposing problems into a sequence of actions Object-oriented programming - decomposing problems into self-contained properties and methods to manipulate them Functional programming - decomposing problems into functions that accept and return immutable values Generic programming - general purpose algorithms that can be applied to arbitrary types 14

15 Higher-order A higher-order function is a function that does at least one of the following: - takes one or more functions as arguments - returns a function as its result Examples: - map, flatmap - filter - reduce 15

16 map let values: [Int] = [1, 2, 3, 4] let squaredvalues = values.map { $0 * $0 } print(squaredvalues) // [1, 4, 9, 16] 16

17 17

18 Closures a self-contained block of functionality that can be passed around and used in code. can capture and store references to any constants and variables from the context in which they are defined. 18

19 extension UIView { } open class func animate(withduration duration: TimeInterval, () -> Swift.Void, completion: ((Bool) -> Swift.Void)? = nil) // delay = 0.0, options = 0 19

20 class MyView: UIView { let label = UILabel() //... func update(title: NSAttributedString, color: UIColor, animated: Bool) { UIView.transition(with: self, duration: animated? 0.5 : 0, options:.transitioncrossdissolve, animations: { self.label.attributedtext = title self.backgroundcolor = color }, completion: { completed in if completed == true { print("we finished the animation!") } }) } } 20

21 Promise A Promise is a way to represent a value that will exist (or will fail with an error) at some point in the future. Similar to how an Optional represents a value that may or may not exist. let userspromise = fetchusers() // Promise<[User]> userspromise.then({ users in self.users = users }) 21

22 Promise struct User { let age: Int let givenname: String } func fetchusers() -> Promise<[User]> { // get a list of users return Promise(value: users) } fetchusers().then { users -> [User] in return users.filter { $0.givenName == "Lucy" } }.catch { error in displayerror(error) } 22

23 Promise fetchusers().then { users -> [User] in return users.filter { $0.givenName == "Lucy" } }.then { lucys -> Promise<[User]> in guard let firstlucy = lucys.first else { return Promise(error: LucyError()) } return fetchfollowers(for: firstlucy) }.then { [weak self] followers in guard followers.count > 0 else { return } self?.dosomething(with: followers) }.catch { error in displayerror(error) } 23

24 !?.then { users ->??? in //??? }.then { lucys ->??? in //??? } 24

25 Type " 25

26 Type Systems Comprised of a collection of rules that assign a property (type) to various constructs in a computer program, such as variables, expressions, functions or modules 26

27 So What? 27

28 28

29 A monad is just a monoid in the category of endofunctors, what's the problem? James Iry, Brief, Incomplete and Mostly Wrong History of Programming Languages 29

30 "All told, a monad in X is just a monoid in the category of endofunctors of X, with product [operation] replaced by composition of endofunctors and unit set by the identity endofunctor." Saunders MacLane, Categories for the Working Mathematician 30

31 Category A category consists of: - a collection of objects - a collection of morphisms - every morphism has a source and object 31

32 Composition 101 func incr(_ x: Int) -> Int { return x + 1 } func square(_ x: Int) -> Int { return x * x } square(incr(2)) // 9 32

33 Composition 101 f(x) = x 2 g(x) = x + 1 (f g)(x) = f(g(x)) = (x + 1) 2 (f g)(2) = f(g(2)) = (2 + 1) 2 = 9 33

34 Category Laws 34

35 Recap category: objects and arrows associativity: f : a b, g : b c and h : c d, h (g f) = (h g) f identity: 1x : x x 35

36 Category example: Set big small 36

37 A monad is a monoid is the category of endofunctors category monoid 37

38 Monoid A set M equipped with a binary operation μ: M M M and a special element 1 M such that 1 and x y=μ(x,y) satisfy the usual axioms of associativity: * (x y) z=x (y z) and the left and right unit laws: * 1 x = x = x 1 38

39 Recap category monoid: a set associativity: f : a b, g : b c and h : c d, h (g f) = (h g) f identity: 1x : x x 39

40 A monad is a monoid is the category of endofunctors category monoid monoidal category 40

41 Monoidal Category A monoidal category is a category equipped with some notion of tensor product (bifunctor): 41

42 Product Set of pairs (Cartesian product) typealias A = String typealias B = Int struct Product<A,B> { let a: A let b: B } let projectiona: (Product<A,B>) -> A = { $0.a } let projectionb: (Product<A,B>) -> B = { $0.b } let prod = Product(a: "Hello", b: 3) projectiona(prod) // "Hello" projectionb(prod) // 3 42

43 Product 43

44 Coproduct typealias A = String typealias B = Int enum Coproduct<A,B> { case a(a) case b(b) } let injecta: (A) -> Coproduct<A,B> = {.a($0) } let injectb: (B) -> Coproduct<A,B> = {.b($0) } let left = "left" let right = 3 injecta(left) // a("left") injectb(right) // b(3) 44

45 Coproduct 45

46 Either enum Either<String, Int> { case Left(String) case Right(Int) } let possibleinjectiona: Either<String,Int> =.Left("Hello") let possibleinjectionb: Either<String,Int> =.Right(3) 46

47 Optional enum Optional<T> { case None case Some(T) } 47

48 Result enum Result<T> { case Value(value: T) case Error(error: Error) } 48

49 Bifunctor : C C C 49

50 Monoidal Category category monoid monoidal category: Objects and arrows Product associativity identity Coproduct associativity identity 50

51 A monad is a monoid is the category of endofunctors category monoid monoidal category functor 51

52 Functor Structure-preserving mapping between categories Objects to objects Arrows to arrows 52

53 Functor A simple intuition is that a Functor represents a container of some sort, along with the ability to apply a function uniformly to every element in the container. For example, a list is a container of elements, and we can apply a function to every element of a list, using map. 53

54 Functor enum Result<T> { case Value(value: T) case Error(error: Error) } extension Result { func map<u>(f: (T) -> U) -> Result<U> { switch self { case let.value(value): return Result<U>.Value(value: f(value)) case let.error(error): return Result<U>.Error(error: error) } } } 54

55 55

56 56

57 A monad is just a monoid in the category of endofunctors category monoid monoidal category functor 57

58 Endofunctors An endofunctor is a functor from one category back to the same category 58

59 59

60 60

61 Example func map<u>(f: (T) -> U) -> Result<U> 61

62 Example func map(f: (Data) -> Result<String>) -> Result<Result<String>> 62

63 Example func map(f: (Data) -> Result<String>) -> Result<Result<String>> extension Result { static func flatten<t>(result: Result<Result<T>>) -> Result<T> { switch result { case let.value(innerresult): return innerresult case let.error(error): return Result<T>.Error(error: error) } } } 63

64 A monad is just a monoid in the category of endofunctors 64

65 If you can define flatmap for a type, the type is often called a monad. Chris Eidhof 65

66 Result extension Result { func flatmap<u>(f: T -> Result<U>) -> Result<U> { return Result.flatten(map(f)) } } 66

67 A monad is just a monoid in the category of endofunctors category monoid monoidal category functor endofunctor 67

68 HOW! THIS! ALL! CONNECTS! 68

69 69

70 Programming Languages, Dr. Westley Weimer 70

71 Types 71

72 Types A set of values A set of valid operations on those values 72

73 Type Checking Statically Dynamically Untyped 73

74 Hole-driven (or compiler-driven) development with types seeing the compiler not as an enemy you have to fight, but as a tool that guides you almost magically to a solution for your problem, one step at a time, using types..then { users ->??? in //??? }.then { lucys ->??? in //??? } Ole Begemann 74

75 Embracing the Type System Hole-driven development is a fantastic technique for modeling data structures and data transformations 75

76 Take aways No need to fear the definition of a "monad" We use monads all the time Swift has monads built in, but extending your type to be a monad is simple There's lots more category theory out there Closures and maps allow us to embrace our type system 76

77 Thanks! 77

78 Helpful Resources nlab Category Theory for Programmers Proof in Functions Grokking Lazy Sequences & Collections Functional Swift Conference Talks - Beyond Type Safety - A Type System From Scratch 78

79 Helpful Resources Point-Free Swift Talk Monads are Burritos #1 Monads are Burritos #2 Monad Tutorial Fallacy The Swift Type System Under the Hood Implementing Swift Generics Leveraging Swift's Type System 79