Evolucionando con Swift

Evolucionando con Swift

En la primera charla, @marcosgriselli nos va a contar acerca de algunas features nuevas de Swift 4.1 y 4.2. Analizaremos cómo estos cambios nos llevarán a escribir código más seguro y expresivo, y cómo podemos aplicarlo en el día a día de nuestras apps. También, repasaremos alguna proposal de Swift Evolution ya aceptada y veremos cómo esto impactará a futuro en nuestro código.

3943f9537852e0d264d52da15805e1d5?s=128

Marcos Griselli

August 16, 2018
Tweet

Transcript

  1. Evolucionando con Swift Como escribir código más expresivo y seguro

    utilizando las nuevas funcionalidades del lenguaje. Marcos Griselli iOS Developer @ Toptal Marcos Griselli - SwiftBA 1
  2. Evolución Marcos Griselli - SwiftBA 2

  3. Swift 1.2 » flatMap » @noescape » Set » Multiple

    if-let Marcos Griselli - SwiftBA 3
  4. Swift 2 » try/catch » guard » defer » API

    availability Marcos Griselli - SwiftBA 4
  5. Swift 2.1 » String interpolation "String \(value)" Swift 2.2 Primer

    release desde que es open source » C style deprecations (++, --, loops) » var parameters deprecation Marcos Griselli - SwiftBA 5
  6. Swift 3 » Better Translation of Objective-C APIs Into Swift

    » Apply API Guidelines to the Standard Library » ~100 proposals Marcos Griselli - SwiftBA 6
  7. Swift 3.1 » Concrete Constrained Extensions » Nested Generics Marcos

    Griselli - SwiftBA 7
  8. Swift 4 » Codable » String revision (SE-0163) » Multi-line

    string literals » Improve keypaths and Dictionary Marcos Griselli - SwiftBA 8
  9. Swift 4.1 » Synthesized Equatable and Hashable (SE-0185) » Conditional

    conformances (SE-0143) » Key decoding strategy for Codable » Recursive constraints on associated types » Introduce Sequence.compactMap(_:) Marcos Griselli - SwiftBA 9
  10. Hashable & Equatable Marcos Griselli - SwiftBA 10

  11. Swift 4.0 struct User: Decodable { let id: String let

    name: String let email: String let registerDate: Date let talks: [Talk] } Marcos Griselli - SwiftBA 11
  12. // MARK: - Hashable extension User: Hashable { var hashValue:

    Int { return combineHashes([id.hashValue, name.hashValue, email.hashValue, registerDate.hashValue, talks.hashValue]) } } Marcos Griselli - SwiftBA 12
  13. // MARK: - Equatable extension User: Equatable { static func

    == (lhs: User, rhs: User) -> Bool { return lhs.id == rhs.id && lhs.name == rhs.name && lhs.email == rhs.email && lhs.registerDate == rhs.registerDate && lhs.talks == rhs.talks } } Marcos Griselli - SwiftBA 13
  14. Hashable & Equatable en Swift 4.0 » Implementación duplicada »

    Propenso a errores al modificar nuestras estructuras » Complejo de agregar en ciertos casos (enum con associated values) Marcos Griselli - SwiftBA 14
  15. SE-0185 Synthesized Equatable and Hashable Marcos Griselli - SwiftBA 15

  16. Swift 4.1 struct User: Decodable, Hashable, Equatable { let id:

    String let name: String let registerDate: Date let talks: [Talk] } » Eliminar boilerplate y errores del programador. » Conformar a Hashable o Equatable de manera simple. Marcos Griselli - SwiftBA 16
  17. SE-0143 Conditional conformances Marcos Griselli - SwiftBA 17

  18. “The ability for types that store other types to conform

    to a protocol” https://swift.org/blog/conditional- conformance/ Marcos Griselli - SwiftBA 18
  19. Esto puede verse reflejado en Arrays u Opcionales extension Array:

    Equatable where Element: Equatable { // implementation of == for Array } extension Optional: Equatable where Wrapped: Equatable { // implementation of == for Optional } /// [Int?] let a = [Int("1"), Int("2")] let b = [Int("1"), Int("2")] a == b // Swift 4.0 ❌ a == b // Swift 4.1 ✅ Marcos Griselli - SwiftBA 19
  20. Como podemos utilizarlo? Marcos Griselli - SwiftBA 20

  21. struct SomeWrapper<Wrapped> { let wrapped: Wrapped } protocol HasIdentity {

    static func ===(lhs: Self, rhs: Self) -> Bool } extension SomeWrapper: Equatable where Wrapped: Equatable { static func ==(lhs: SomeWrapper<Wrapped>, rhs: SomeWrapper<Wrapped>) -> Bool { return lhs.wrapped == rhs.wrapped } } // error: SomeWrapper already stated conformance to Equatable extension SomeWrapper: Equatable where Wrapped: HasIdentity { static func ==(lhs: SomeWrapper<Wrapped>, rhs: SomeWrapper<Wrapped>) -> Bool { return lhs.wrapped === rhs.wrapped } } Marcos Griselli - SwiftBA 21
  22. » Podemos crear wrappers alrededor de cualquier tipo y aún

    conformar a los protocolos que necesitemos. » Con ayuda de Phantom Types podemos generar tipos que sean únicos aunque el tipo que contengan sea el mismo. Marcos Griselli - SwiftBA 22
  23. Tagged by PointFree struct Tagged<Tag, RawValue> { var rawValue: RawValue

    } Marcos Griselli - SwiftBA 23
  24. Conditional conformances // MARK: - Equatable extension Tagged where RawValue:

    Equatable { static func == (lhs: Tagged, rhs: Tagged) -> Bool { return lhs.rawValue == rhs.rawValue } } // MARK: - Decodable extension Tagged: Decodable where RawValue: Decodable { init(from decoder: Decoder) throws { self.init(rawValue: try decoder.singleValueContainer() .decode(RawValue.self)) } } Marcos Griselli - SwiftBA 24
  25. Xcode! Marcos Griselli - SwiftBA 25

  26. Swift 4.2 » Enhanced Hashable » Dynamic Member Lookup (SE-0195)

    » Case Iterable (SE-0194) » Random API » Warnings and Errors (SE-0196) Marcos Griselli - SwiftBA 26