KeyPaths em Swift e seus benefícios

Apr 21 2023

KeyPath é uma maneira de se referir a uma propriedade ou subpropriedade específica de um tipo, como uma estrutura ou classe. É como um atalho ou uma referência a um determinado valor ou propriedade dentro de uma estrutura de dados maior.

KeyPath é uma maneira de se referir a uma propriedade ou subpropriedade específica de um tipo, como uma estrutura ou classe. É como um atalho ou uma referência a um determinado valor ou propriedade dentro de uma estrutura de dados maior.

Em termos mais simples, os keypaths no Swift são como placas de sinalização que apontam para uma informação específica dentro de uma coleção maior de dados. Eles facilitam o acesso e a modificação de partes específicas desses dados sem a necessidade de pesquisar em toda a coleção.

Por exemplo, digamos que você tenha uma struct chamada Personcom propriedades como name, agee address.

struct Address {
    let streetAddress: String
    let city: String
}

struct Person {
    let name: String
    var age: Int
    let address: Address
}

var person = Person(
               name: "John",
               age: 24,
               address: Address(
                 streetAddress: "2, qwerty",
                 city: "CA"
               )
             )

let nameKeyPath = \Person.name
let name = person[keyPath: nameKeyPath]
print(name) // John

let streetAddressKeyPath = \Person.address.streetAddress
print(person[keyPath: streetAddressKeyPath]) // 2, qwerty

Existem dois tipos de caminhos-chave: caminhos-chave graváveis e somente leitura.

KeyPath somente leitura:

2. KeyPath gravável:

Um caminho-chave gravável não apenas permite acessar uma propriedade ou subpropriedade de um tipo, mas também modificar seu valor. Em termos mais simples, quando nos referimos a um tipo mutável, ele se torna um caminho de chave somente leitura. Se acessarmos uma propriedade var, então é um caminho-chave gravável.

let readOnlyKeyPath = \Person.name
print(type(of: readOnlyKeyPath)) // KeyPath<Person, String>

var writableKeyPath = \Person.age
print(type(of: writableKeyPath)) // WritableKeyPath<Person, Int>
person[keyPath: writableKeyPath] = 28 // 28

class Person {
    var age = 0
}

let referenceWritableKeyPath = \Person.age
print(type(of: referenceWritableKeyPath)) // ReferenceWritableKeyPath<Person3, Int>

Usos:

Existem muitos outros usos de keypaths no Swift, e exploraremos alguns exemplos.

Nos métodos de coleta do Swift

No Swift, keypaths podem ser passados como argumentos para métodos como .mape .filter. O compilador converterá o keypath em um encerramento, permitindo fácil acesso e manipulação de elementos em uma coleção. Por exemplo, para extrair nomes de pessoas de um array de Personobjetos, pode-se utilizar o .mapmétodo e passar um keypath que faça referência à namepropriedade do Persontipo, conforme imagem abaixo:

struct Person {
    let name: String
    var age: Int
}

let people = [
    Person(name: "Alice", age: 25),
    Person(name: "Bob", age: 30),
    Person(name: "Charlie", age: 35)
]

let names = people.map(\.name)
print(names) // prints ["Alice", "Bob", "Charlie"]

Usar keypaths dessa maneira pode tornar seu código mais conciso e legível, pois permite acessar e manipular propriedades específicas de objetos sem precisar escrever um fechamento separado.

Criando um DSL (idioma específico do domínio):

Os KeyPaths no Swift permitem a criação de linguagens específicas de domínio (DSLs), minilinguagens para resolver problemas específicos dentro de um domínio . Usando KeyPaths, podemos criar uma sintaxe de tipo seguro para construir predicados que filtram coleções com base em critérios específicos.

Por exemplo, ao filtrar uma matriz de objetos Person, os KeyPaths podem ajudar a criar uma DSL que expressa critérios baseados em idade de maneira legível e segura. Por exemplo:

func > <T, V: Comparable>(lhs: KeyPath<T, V>, rhs: V) -> (T) -> Bool {
    return { $0[keyPath: lhs] > rhs }
}

let olderThan30 = people.filter(\.age > 30)

print(olderThan30) // prints "[Person(name: "Bob", age: 30), Person(name: "Charlie", age: 35)]"

Resumo:

Keypaths em Swift permitem fácil acesso e modificação de valores específicos dentro de estruturas de dados complexas, melhorando a expressividade do código e a segurança do tipo