Type Driven Development — Валерий Попов (Yandex)

В докладе Валерий рассматривает строгую типизацию, которая может стать еще одним рубежом обороны надежного приложения от ошибок разработчика. На примерах будет показано, как дополнительная информация, переданная на этапе компиляции, поможет отловить ряд ошибок, не доводя систему до падения в runtime. Расскажет, что мобильный разработчик может почерпнуть из языков, которые ставят типы во главе процесса разработки.

Avito iOS Winter Edition
02/12/2017

Transcript

1. Type Driven Development Попов Валерий
2. TESTS
3. TESTS TESTS TESTS ESTS TEST TESTS TESTS TESTS ESTS TEST TESTS TESTS TESTS ESTS TEST TESTS TESTS TESTS ESTS TEST TESTS TESTS TESTS ESTS TEST TESTS TESTS TESTS ESTS TEST
4. TYPES
5. Practical › Type systems › Using types
 Agenda Theoretical › Dependent types in Swift › Type DD approach

6. Static | Dynamic Categories Strong | Weak Implicit | Explicit
7. C/C++ Objective-C Swift Java C# Haskell Clojure Python Ruby JavaScript STATIC DYNAMIC
8. Objective-C id Haskell.Dynamic STATIC DYNAMIC
9. STRONG WEAK Swift Java C# Haskell Clojure Python Ruby JavaScript
10. Clojure Scala PHP Python C/C++ Java Haskell Objective-C IMPLICIT EXPLICIT
11. Scala Haskell Swift IMPLICIT EXPLICIT
12. Types define code
13. Python: weak, dynamic 13 def binary_search(l, value): low = 0 high = len(l)-1 while low <= high: mid = (low+high) if l[mid] > value: high = mid-1 elif l[mid] < value: low = mid+1 else: return mid return -1
14. Python: weak, dynamic 14 def binary_search(list, value): … else: return mid return -1
15. Python: weak, dynamic 15 def binary_search(list, value): …
16. Swift: static, strong 16 func binarySearch<T: Comparable>(xs: [T], x: T) -> Int? { var recurse: ((Int, Int) -> Int?)! recurse = {(low, high) in switch (low + high) / 2 { case _ where high < low: return nil case let mid where xs[mid] > x: return recurse(low, mid - 1) case let mid where xs[mid] < x: return recurse(mid + 1, high) case let mid: return mid }} return recurse(0, xs.count - 1) }
17. Swift: static, strong 17 func binarySearch<T: Comparable> (xs: [T], x: T) -> Int? { … }
18. Swift: static, strong 18 func binarySearch<T: Comparable> (xs: [T], x: T) -> Int? { … }
19. USING TYPES
20. Money transfer 20 struct FailedTransaction { let isRejected: Bool let isCancelled: Bool let notEnoughMoney: Amount? }
21. 21 struct FailedTransaction { let isRejected: Bool let isCancelled: Bool let notEnoughMoney: Amount? } let transaction = FailedTransaction ( isRejected: true, isCancelled: true, notEnoughMoney: nil )
22. Product type 22 struct FailedTransaction { let isRejected: Bool let isCancelled: Bool let notEnoughMoney: Amount? }
23. Sum type 23 enum FailedTransaction { case rejected case cancelled case outOfMoney(Amount) }
24. 24 let failedTransaction: FailedTransaction failedTransaction = .rejected enum FailedTransaction { case rejected case cancelled case outOfMoney(Amount) }
25. Keep types simple
26. Message sending 26 struct Message { let text: String var isEncrypted: Bool }
27. 27 func send(message: Message) throws { if message.isEncrypted { print(message.text) } else { throw MessageError.unsecured } } struct Message { let text: String var isEncrypted: Bool }
28. 28 func send(message: Message) throws { if message.isEncrypted { print(message.text) } else { throw MessageError.unsecured } } let message = Message(text: "Hi!", isEncrypted: false) send(message: message)
29. Runtime exception :( 29 let message = Message(text: "Hi!", isEncrypted: false) send(message: message)
30. Compile time? 30 struct Message<T> { let text: String }
31. Compile time? 31 struct Message<T> { let text: String } enum Encrypted {} enum PlainText {}
32. 32 func send(message: Message<Encrypted>) { print(message.text) } struct Message<T> { let text: String } enum Encrypted {} enum PlainText {}
33. 33 func send(message: Message<Encrypted>) { print(message.text) } let message = Message<PlainText>(text: “Hi!”) send(message: message)
34. Compile time :) 34 let message = Message<PlainText>(text: “Hi!") send(message: message)
35. Phantom Types 35 let m1 = Message<PlainText>(text: “”) let m2 = Message<Encrypted>(text: “”)
36. Make invalid states unacceptable
37. ERROR HANDLING
38. Error codes 38 int foo() { if (failed) { return -1; } return 0; }
39. Completion 39 typedef void (^Compl)(NSData,NSError*) 
 - (void)performTask:(Compl)completion{ … completion(nil, error) }
40. 40 typedef void (^Compl)(NSData,NSError*) 
 - (void)performTask:(Compl)completion{ … completion(nil, nil) // ??? } typedef void (^Compl)(NSData,NSError*) 
 - (void)performTask:(Compl)completion{ … completion(data, error) // ??? }
41. Exceptions 41 void performTask(String[] args) throws FileNotFoundException { ... throw new FileNotFoundException() }
42. Unchecked exceptions 42 void task() throws RuntimeException { ... }
43. Result 43 enum Result<T> { case success(T) case failure(Error) }
44. 44 func contentsOfFile( path: String) -> Result<String> { return .success("") } func performTask() -> Result<Void> { return .failure(Err.some) } enum Result<T> { case success(T) case failure(Error) }
45. Errors have types
46. EVEN MORE 
 POWERFUL TYPES
47. Array sort 1 6 2 8 3 4 1 2 3 4 6 8
48. Idris 48 insSort : Vect n elem -> Vect n elem
49. Dependent types 49 insSort : Vect n elem -> Vect n elem FUNC NAME ARGUMENT TYPE DEPENDENT TYPE ARGUMENT NAME RETURN TYPE
50. DEPENDENT TYPES 
 IN SWIFT?
51. 1 ≠ 2 51 protocol Nat { init() } struct Zero: Nat {} protocol NonZero: Nat { associatedtype Predecessor: Nat }
52. 52 protocol NonZero: Nat { associatedtype Predecessor: Nat } struct Successor<N: Nat>: NonZero { typealias Predecessor = N } typealias One = Successor<Zero> typealias Two = Successor<One> typealias Three = Successor<Two> …
53. 53 protocol BinaryOperation { associatedtype A: Nat associatedtype B: Nat } struct Successor<N: Nat>: NonZero { typealias Predecessor = N }
54. 54 struct EQ {} extension BinaryOperation where A == B { var r: EQ { return EQ() } } struct NEQ {} extension BinaryOperation { var r: NEQ { return NEQ() } }
55. 55 struct Compare <L: Nat, R: Nat>: BinaryOperation { typealias A = L typealias B = R } Compare<One, One>().r //EQ Compare<One, Two>().r //NEQ
56. 56 //struct NEQ {} //extension BinaryOperation { // var r: NEQ { return NEQ() } //} Compare<One, Two>().r //Compile time error
57. Not type dependent
58. BEN-G/VALIDATED 58 typealias LoggedInUser = Validated<User, LoggedInValidator>
59. TYPE DRIVEN
60. TDD RED -> GREEN -> REFACTOR
61. TypeDD TYPE -> DEFINE-> REFINE
68. Type Holes in Swift 68 func typeHole<T> (_ description: String = "") -> T { fatalError("unfilled hole \(description)") }
69. › Types and type systems › Painless types › Swift type system is almost good › Type DD Summary
70. › Finite-state machine › Hindley-Milner algorithm › Curry-Howard isomorphism › Dependent types in Idris Even more
71. Попов Валерий Инженер-разработчик complexity@yandex-team.ru @complexityclass