"Tipo de propiedad no es un subtipo de val abstracto anulado" en el campo henetworkingado múltiple

A veces, se declara un tipo para implementar 2 interfaces que tienen una propiedad abstracta con el mismo nombre, pero cuando muevo el argumento de tipo acotado a una superclass abstracta de nivel superior y la subclasifica en diferentes objects, la class reemplaza la propiedad abstracta en Ambas superinterfaces no comstackn al usar arguments de tipo para una subclass.

Las interfaces generadas y la class abstracta:

interface Actor : Type { val login: Stub<String> val posts: Config<String, BasePostsArgs> } interface SomeConflict : Type { val posts: Config<String, BasePostsArgs> } abstract class BasePostsArgs( args: ArgBuilder = ArgBuilder.create<String, BasePostsArgs>()) : ArgBuilder by args 

Un ejemplo del object generado que anula 2 properties de superinterfaz con el mismo nombre:

 object Organization : Type, SomeConflict, Actor { override val login: Stub<String> = stub() override val posts: Config<String, Organization.PostsArgs> = configStub(PostsArgs()) class PostsArgs(args: ArgBuilder = ArgBuilder.create<String, PostsArgs>()) : BasePostsArgs(args) { fun first(value: Int): PostsArgs = apply { addArg("size", value) } fun since(value: Date): PostsArgs = apply { addArg("since", value) } } } 

Y luego las interfaces para la API:

 interface Type { fun <T> stub(): Stub<T> = StubImpl<T, ArgBuilder>() fun <T, A : ArgBuilder> configStub(argBuilder: A): Config<T, A> = StubConfigImpl(argBuilder) } interface Config<T, A : ArgBuilder> { fun config(): A } interface ArgBuilder { fun addArg(name: String, value: Any): ArgBuilder fun <T> build(): Stub<T> companion object { fun <T, A: ArgBuilder> create(): ArgBuilder = InternalImplementation<T, A>() as A } } 

Para tener polymorphism para diferentes campos en los types que implementan una interfaz pero que requieren diferentes arguments, puedo declararlos así:

 class OrgPostsQuery( amount: Int = 100, from: Date = Date.from(Instant.now())) : Model<Organization> { val posts by super.model.config() .first(1000) .since(from) .build() } 

(Hay un set separado de interfaces para List<T> para un campo como posts en el ejemplo, pero lo dejé para abreviar)

¿Qué estoy haciendo incorrectamente? O esto no es posible?

Para poder anular un val genérico con subtypes de los arguments de tipo, necesita usar un out -projection .

Cambie la Config<String, BasePostsArgs> a Config<String, out BasePostsArgs> en ambas interfaces y la class abstracta. Entonces podrá usar un subtipo de BasePostArgs donde se esperaba BasePostArgs .

 interface Actor : Type { val posts: Config<String, out BasePostsArgs> } interface SomeConflict : Type { val posts: Config<String, out BasePostsArgs> } object Organization : Type, SomeConflict, Actor { override val posts: Config<String, Organization.PostsArgs> = configStub(PostsArgs()) /* ... */ } 

El error que recibe se debe al hecho de que, si algún tipo A es invariante en su parámetro de tipo, entonces A<T1> y A<T2> nunca son subtypes si T1 y T2 no son del mismo tipo (en su case, T1 := BasePostsArgs , T2 := Organization.PostsArgs ). Pero cuando utiliza una out proyección, A<T1> convierte en un subtipo de A<T2> cuando T1 es un subtipo de T2 . Y puede anular un val con un subtipo de la propiedad en el tipo base (pero eso no funciona para var s).