vaadin/vaadin-on-kotlin

A differnt motivation -- it seriously pains me (becuase its 'SO CLOSE' ) that to implement certian types of APIs -- at minimum any class structure that uses an interface or abstract class --
that one has to manually re-implement the exact same code over and over -- 'boilerplate' -- the sort of thing Kotlin strives to avoid -- yet doesnt quite ...
interface A {
val b : String
}

now if I want to every have an "A" I MUST re-implement every member one by one.
class aA : A {
override val b : String /// ARRRG -- DOUBLE ARG because I now need an initializer too !!!!
}

EVEN IF all I am doing is using a data binding library like Jackson
val aaa : A = objectMapper.readValue<aA>( file)

IF one has a very flat or simple set of classes its not bad -- data classes are great --
data class A( val b: String )

that even works with no initializer with jackson ( val a = objectMapper.read<A>(file) )

But the second one needs variants or extensions ( particularly if in seperately compiled projects -- like a api impl + interface)
as soon as you need any kind of class derivation the problem explodes --
Even the wonderful class delegation -- REQUIRES BOTH an interface and a concrete class just to delegate yet a third class ...
class X(a : A ) : A by a // Beautiful !!! EXCEPT

you need now at minimum 2 classes fully and redundantly implemented, often more.
interface A { ... blah }
class aA : A { override every member AND at least 1 constructor AND provide all initializers }
then usuually
class bA: A { otherwise why are you using derivation ? unless you have atleast 1 variant }

So now the beautiful 1 liner 'poster child' for all thats wonderful about Kotlin --
is totally shattered into a mess and tossed on the floor (metaphorically )
That is just so philosophically painful I cannot help but try to find a remedy -- something OTHER then 'spring' which brings too much its own pain :)

So .. as a 'fascinating puzzle' -- I can now write code like this ( not quite perfect yet -- but satisfying even if I dont actually do it :)

interface A { any number of members defined ONCE }

....

 val a : A = configure { 
        from( systemDefaults )
       from( userProvidedConfigFile )
      with(  optionalyProvidedMapOrObjectToFillInMissingBits )

}

done.
or with the proper 'conventions' (i.e. vast amount of code ELSEWHERE :)
val a = configure<A>{ with( appDefaults ) }
editableForm<A>( a ) {
title("Awesome Dynamicaly generated Form from Only an Inteface" )
}

.