Rediscovering The Swift Compiler Through Closures

Keynote of the lecture given at iOS TLV Meetup on November 30 2016 by Aviel Gross

Swift compiler tries to create a world in which “If we understand what this is, then the compiler understands it too”. Type inference, type constraints, and method overloading are only some of the great things that help us write better and safer code, while helping the Swift compiler understand what we meant. In this talk we will hack through some of those functionalities and make Swift know what we meant before we even know it ourselves.

@avielgr

Transcript

1. Rediscovering The Swift Compiler Through Closures
9. VS !
10. Closures are self-contained blocks of functionality that can be passed around and used in your code. - Closure Chapter / The Swift Programming Language / Apple
11. Self-contained: complete, or having all that is needed, in itself. - Google Dictionary
12. Closure
13. [weak foo] [unowned bar]
14. Weak reference Strong when runs
16. Program to an interface, not an implementation - Mom Solution A
17. Solution A
18. Solution A Our ‘weak(…)’ must: • Belong to ‘NotificationCenter’ • ✊ Take our object • % Return a weak ref’ed object
19. Solution A ‘WithProxy’ should: • Keep ‘val’ type - generic • Pass our ‘val’ safely (weakly) • Have a proxy of ‘addObserver’
20. Solution A
21. New: Solution A WithProxy is tied to NotificationCenter!
22. Solution B
23. Solution B That’s Nice But….. • A-lot of code! • ✌ We made 2 special extensions • + We made a brand new class! • Who is holding ‘WithProxy’?! We can do better…
24. Solution C NotificationCenter Note our object Note rethinking our API
25. Solution C Note Our Magic Function
26. Solution C
27. Solution C method overloading is the ability to create multiple methods of the same name with different implementations. Calls […] will run […] appropriate to the context of the call, […performing] different tasks depending on context - Wikipedia
28. Solution C Method Overloading: • ”Same name” • . “Multiple methods” • 1 call - differentiates by context
29. Solution C
30. Solution C
31. Solution D
32. Solution E
33. Solution E
34. Solution E
35. Solution E
36. Solution E
37. Solution E Distinguish between single-tuple and multiple-argument function types SE-0110: Authors: Vladimir S., Austin Zheng
38. Solution E Remove implicit tuple splat behavior from function applications SE-0029: Chris Lattner
39. Solution E
40. Solution E Solution A Solution B Solution C Solution D • Type Inference • Generics • Method Overloading • Closures
41. * @olebegemann on twitter *
42. Let’s do some math!
43. 5 ❗
48. 5 +=
49. 5 +=
50. 5 +=
52. Thank You! @avielgr avielgr@gmail.com