A modern programming language that makes developers happier.

kotlinlang

Proposal: Generics new constraint
```
data class CPosition(var x: Int, var y: Int)

fun main(args: Array&lt;String&gt;)
{
    addComponent&lt;CPosition&gt;().apply {
        x = 5
        y = 5
    }
}


fun &lt;T : new&gt; addComponent(): T
{
    // create an instance of T
    val c = T()
    
    // do stuff with c
    
    return c
}
```

Can't you just pass the constructor as an argument?
```
fun &lt;T&gt; addComponent(createT: () -&gt; T): T {
    val c = createT()
    // ...
    return c
}

addComponent(::SomeClass)
```

What is the actual use case? For this example you could just pass an actual instance to `addComponent`.

the use case is actually to not have to care about creating an actual instance before :stuck_out_tongue:

Is it literally `addComponent&lt;CPosition&gt;()` vs `addComponent(CPosition())`?

no, so i can implement a type safe object pooling then, user should not care about allocating components

It’s a feature request, not a proposal. Proposal should at least give some idea about how it would be implemented, and how it interacts with other features.

Just to be sure, have you measured if object pooling really helps performance in your case?

When you need object pooling, it is indeed hard to achieve. But just `new` constraint doesn’t really help, because you’ll need to somehow return objects to the pool.

Even with such a feature, I would prefer Marius's solution using a higher order function. Makes it more flexible, and less magic. (What happens to constructor params?)

Yeah just use higher order functions. That's just more flexible, as you can also require constructors to have parameters

Make your type parameter reified and call constructor through reflection is what you want

That's another can of worms, no compile time safety any more.

Something similar can be achieved with the typeclasses proposal. With that you can add a typeclass parameter with a factory method. You'd still need to define the factory (typeclass implementation) somewhere, but the call site will look like what you wanted. 

~You could also achieve this with companion objects, similar to how Kotlin/Native does `memScope.allocArray&lt;T&gt;(block: T.() -&gt; Unit)`. Although you'd have to do this for every "component".~ It's sadly an intrinsic.

In Swift, I solved this by creating a `protocol InitializablyWithZeroArguments`, which only requires that it has n initializer that takes zero arguments. Then I just use protocol `extension`s to make lots of mine and stdlib types conform to it.

Unfortunately, Kotlin seems to have no interest in making `interface`s specify a constructor. Nor does Kotlin seem to want late-declared conformance to be a thing. :disappointed: