A modern programming language that makes developers happier.

kotlinlang

This:
```
constructor(
    title: String,
    portions: Int,
    sections: List&lt;ClassA&gt;,
    sourceUrl: String? = null
  )
```
and this:
```
constructor(
    title: String,
    portions: Int,
    ingredients: List&lt;ClassB&gt;,
    sourceUrl: String? = null
  )
```

Apperently have the same JVM signature, why is that? Can’t it see that `ClassA` and `ClassB` are two different classes in the list? I did not know that two lists with different content looked the same to the bytecode

It’s because of type erasure (<https://docs.oracle.com/javase/tutorial/java/generics/erasure.html>)

I see, smarter people than me probably had a good reason hehe :slightly_smiling_face:

“Type erasure ensures that no new classes are created for parameterized types; consequently, generics incur no runtime overhead.” I see :slightly_smiling_face:

Actually the main reason is backward compatibility of Java with generics with previous versions without Generics (before Java 5)

Aww, I was hoping it would be a good reason :disappointed:

This approach is not always bad actually, there are some advantages, zero cost of generics is one of them

Yeah of course, its there for a reason. It just sucks when things in the future have to be worse than they could be because of backwards compatibility. But thats just reality :slightly_smiling_face: Sometimes I wish the jvm infrastructure would just drop everything pre java6 and get rid of a lot of junk

it’s good theoretically, bad in practice. Drop to Java 6 will not help, generics are erased even on Java 10, you need completely new, non backward compatiblechange

Yeah its not worth it just because of nicer signature of course :slightly_smiling_face:

For functions (not constructors) you can use `@JvmName` in Kotlin to work around this. 
Then you could use a "fake constructor", i.e. `operator fun invoke` in `companion object` and voila :slightly_smiling_face:

Example:
```
class Foo {
    companion object {
        operator fun invoke(a: List&lt;String&gt;): Foo = TODO()
        @JvmName("createFromIntList")
        operator fun invoke(b: List&lt;Int&gt;): Foo = TODO()
    }
}
```