generic - tuple swift

¿Por qué Swift requiere la anulación del inicializador designado de la superclase genérica?

Question

De acuerdo con la documentación de Apple, Swift no necesita reemplazar el inicializador. En un ejemplo de código siguiente, Bar hereda el inicializador de Foo :

class Foo {
  let value: Int
  init(value: Int = 5) {
    self.value = value
  }
}

class Bar: Foo {
}

Tan pronto como agreguemos algo genérico en Foo , como la class Foo<T> { Xcode nos proporciona un error El Initializer does not override a designated initializer from its superclass . ¿Hay alguna documentación o discusión de evolución rápida que explique por qué está sucediendo?

Actualizar. Parece que el genérico no es una causa importante para anular el requisito. Aquí hay una opción sobre cómo definir una clase con genérico que no requiera la anulación del inicializador designado:

protocol FooProtocol {
    associatedtype T
}

class Foo<U>: FooProtocol {
    typealias T = U

    let value: Int
    init(value: Int, otherValue: T) {
        self.value = value
        self.otherValue = otherValue
    }
}

class Bar: Foo<Int> {
}

Sin embargo, hay otra observación interesante de comportamiento. Definición de inicializador como el siguiente requisito de anulación de causa:

init(value: Int = 5) {
    self.value = value
}

Lo curioso es que agregar un parámetro más como seguimiento en dicho inicializador designado causa que este requisito de anulación desaparezca:

init(value: Int = 5, otherValue: T) {
    self.value = value
}

Actualización 2 . No puedo encontrar una explicación lógica para este comportamiento, en este punto lo reporté como un error del compilador - https://bugs.swift.org/browse/SR-1375

Answer 1

De hecho, llené un informe de error para heredar de la clase genérica:

Volvió en noviembre del año pasado y aún no recibió una respuesta, así que ¯_ (ツ) _ / ¯

Answer 2

Es claramente un error. Además, aunque el error se produce subclasificando un genérico, su causa próxima es el valor predeterminado. Esto compila muy bien:

class Foo<T> {
    let value: Int
    init(value: Int) {
        self.value = value
    }
}

class Bar: Foo<String> {
}

Pero esto no:

class Foo<T> {
    let value: Int
    init(value: Int = 5) {
        self.value = value
    }
}

class Bar: Foo<String> {
}

Ese tipo de distinción arbitraria sin diferencia es una indicación segura de que este es un error del compilador.