Início / coding / Perguntas / 79129054
Accepted
duckSern1108
Asked: 2024-10-27 01:02:04 +0800 CST

O compilador não mostra o erro "o tipo de protocolo 'P' não pode estar em conformidade com 'P'"

  • 772
protocol Animal {
    func makeNoise()
    static var species: String { get }
}
struct Dog: Animal {
    func makeNoise() { print("Woof") }
    static var species: String = "Canus familiaris"
}
struct Cat: Animal {
    func makeNoise() { print("Meow") }
    static var species: String = "Felis catus"
}

var animal: Animal // `Animal` is used here as a type.
animal = Dog()
animal.makeNoise() // Prints "Woof".
animal = Cat()
animal.makeNoise() // Prints "Meow".

func declareAnimalSpecies<T: Animal>(_ animal: T) {
    animal.makeNoise()
    print("My species is known as (T.species)")
}

let dog = Dog()
declareAnimalSpecies(dog)
// Prints:
// "Woof"
// "My species is known as Canus familiaris"
declareAnimalSpecies(animal) // <- not show error here
// error: protocol type 'Animal' cannot conform to 'Animal'...`

Estou pegando um código de exemplo do swift git . Pelo que entendi, o animaltipo de 's é any Animalso quando ele é passado para function declareAnimalSpecies, o compilador inferirá que T é any Animale, por any Animal cannot conform to Animalisso, espero que ele mostre esse erro.

swift

1 respostas

  1. Best Answer

    Isso é permitido desde a implementação do SE-0352 . Isso nos permite "abrir caixas existenciais" ao chamar métodos genéricos. O SE-0375 nos permite fazer o mesmo com parâmetros opcionais.

    animalé uma "caixa" existencial que, em tempo de execução, contém um tipo concreto real que está em conformidade com Animaldentro de at. Em vez de olhar apenas para as restrições de tipo e dizer " any Animalnão está em conformidade com Animal", o compilador agora é capaz de ver que esta é uma caixa, e nela deve haver algum tipo concreto . Em tempo de execução, é garantido que há um Tque está em conformidade com sua restrição de tipo.

    Como contra-exemplo, considere

    func foo<T: Animal>(_ a: T, _ b: T) {}
func bar(_ a: any Animal, _ b: any Animal) {
    foo(a, b) // error
}

    Isso não é permitido porque as caixas existenciais apodem bconter diferentes tipos concretos em tempo de execução, portanto, não há necessariamente um único Ttipo que pode ser passado para foo.

    É importante notar que, do ponto de vista do sistema de tipos, any Animal ainda não está em conformidade com Animal. Se você tem

    struct Foo<T: Animal> {}

    você ainda não consegue escrever Foo<any Animal>. Não há caixas existenciais para abrir neste caso.

    • 1

relate perguntas