Início / coding / Perguntas / 79448574
Accepted
Roman
Asked: 2025-02-18 22:21:56 +0800 CST

Valor associado aninhado mais profundo (extraído recursivamente)

  • 772
import CasePaths

extension CasePathable where AllCasePaths: CasePathReflectable<Self> {
    func associatedValue<T: CasePathable>() -> T? where T.AllCasePaths: CasePathReflectable<T> {
        let caseKeyPath = Self.allCasePaths[self]
        return self[case: caseKeyPath] as? T
    }
}

Nota: estritamente falando, não é necessária familiaridade com a biblioteca swift-case-paths do PointFree que estou usando aqui. Fundamentalmente, minha pergunta diz respeito somente ao Swift em si.
Então, dada a função correta acima, o objetivo é aplicá-la recursivamente, para recuperar o valor aninhado mais profundo.
Mas como lidar com os tipos aqui? Porque cada valor associado pode ser um tipo diferente. O problema é que a associatedValue()função retorna um genérico T, que deve ser especificado. Mas para uma solução geral, não podemos saber cada um Tcom antecedência.

Darei um exemplo concreto para maior contexto:

@CasePathable
enum A {
    case a(B)
    case smthA
}

@CasePathable
enum B {
    case b(C)
    case smthB
}

@CasePathable
enum C {
    case c
    case smthC
}

let aValue: A = .a(.b(.c))
let bAssValue: B = aValue.associatedValue()! // .b(.c))
let cAssValue: C = bAssValue.associatedValue()! // .c
swift

1 respostas

  1. Best Answer

    Assumirei que cada caso de enumeração terá no máximo 1 valor associado.

    Como você não conhece os tipos intermediários, você precisa trabalhar com os tipos existenciais.

    any CasePathablenão é possível capturar a restrição de where AllCasePaths: CasePathReflectable<Self>, então você precisa introduzir um protocolo extra para representar esse tipo.

    protocol ReflectableCasePathable: CasePathable where AllCasePaths: CasePathReflectable<Self> {}

    Todas as suas enumerações devem estar em conformidade com ReflectableCasePathable.

    Você também precisa de uma versão associatedValueque retorne um any ReflectableCasePathable.

    extension ReflectableCasePathable {
    func associatedValueExistential() -> (any ReflectableCasePathable)? {
        let caseKeyPath = Self.allCasePaths[self]
        return self[case: caseKeyPath] as? (any ReflectableCasePathable)
    }
    
    // the generic version can reuse the existential version
    func associatedValue<T: ReflectableCasePathable>() -> T? {
        associatedValueExistential() as? T
    }
}

    Note que associatedValuenão precisa depender da AllCasePaths: CasePathReflectable<Self>restrição. Em vez disso, pode depender do CasePathIterableprotocolo, onde você pode encontrar o caminho do caso correto por iteração.

    extension CasePathIterable {
    func associatedValueExistential() -> (any CasePathIterable)? {
        for path in Self.allCasePaths {
            if let value = self[case: path],
                let iterableValue = value as? (any CasePathIterable) {
                return iterableValue
            }
        }
        return nil
    }
}

    Então você não precisa introduzir o novo protocolo, mas estou divagando.

    Em qualquer caso, você pode simplesmente chamar isso em um loop.

    func recursivelyUnwrap(_ start: any ReflectableCasePathable) -> any ReflectableCasePathable {
    var r = start
    while let x = r.associatedValueExistential() {
        r = x
    }
    return r
}

    let aValue: A = .a(.b(.c))
print(recursivelyUnwrap(aValue)) // prints "c"

    Considere também este design alternativo, que permite extrair o valor não associado à enumeração no nível "mais baixo".

    extension ReflectableCasePathable {
    func associatedValueExistential() -> Any {
        let caseKeyPath = Self.allCasePaths[self]
        return self[case: caseKeyPath]! // AFAIK this will never be nil because caseKeyPath = Self.allCasePaths[self]
    }
}

func recursivelyUnwrap(_ start: any ReflectableCasePathable) -> Any {
    var r = start
    while true {
        let associated = r.associatedValueExistential()
        if associated is Void { // this means the enum has no associated value
            return r
        }
        if let nextLevel = associated as? (any ReflectableCasePathable) {
            r = nextLevel
        } else {
            return associated
        }
    }
}

    Isso permite que você faça coisas como esta:

    let a: A = .a(.b(.smthC))
let b: A = .a(.b(.c("Hello"))) // suppose C.c has a string associated value
print(recursivelyUnwrap(a)) // C.smthC
print(recursivelyUnwrap(b)) // "Hello"
    • 1

relate perguntas