Certainly a long shot but are there any discussions about introducing types that are completely erased (not just generics) in Kotlin? A bit like the typescript type system. At built time, all the type checking would happen. At run time the objects could be some

Map

-like type I guess and property accesses would be cast to the build-time type (and assert if wrong). Does that make any sense?

Out of curiosity, what would be the benefit of that?

I'm generating models for GraphQL queries and it can become quite complex to the point that it generates a lot of code that takes lots of time to compile and load

generates a lot of code that takes lots of time to compile

Wouldn't a build time type checker have the same issue? Or does the type checking take a negligible amount of time?

Yea I guess compile time would be in the same ballpark I guess. But not having to emit .class files and what not, I'm hoping it can be a bit faster

Maybe generating value classes might help with the runtime issue? That would probably be a pretty big change to the library/code-gen, though. Alternatively, maybe you don’t need to do everything strictly through the GraphQL library? It’s kinda gross, but GraphQL is ultimately just a layer over REST, so you could just send a POST request with the GraphQL query in the body, and the result will just be normal JSON that could be deserialized to

JsonElement

with #serialization (or other similar types from other serialization libs)

Maybe generating value classes might help with the runtime issue?

Maybe! Will check this!

send a POST request with the GraphQL query in the body, and the result will just be normal JSON that could be deserialized to

JsonElement

That works of course but the developer experience is nothing similar to having in-IDE autocomplete, inline documentation, deprecations, etc...

Yeah, it’s just a fault with GraphQL in general. It’s supposed to be a language-neutral tool, but like most things web-related, really only works well with JS.

You can feel it's designed for the web first but the Kotlin experience is really good too. The type system maps nicely and not having to write a serializer and having autocomplete + schema from your API right in your IDE is pretty great

Casey, is your suggestion something like

value class Response(private val data: Map<String, Any>) {
    val foo: Foo
        get() = Foo(data["foo"] as Map<String, Any>)
    val optional: String?
        get() = data["optional"] as String?
}

etc.?

Yeah, that’s the basic idea that came to mind when Martin suggested having classes backed by a map-like object

Scala does have structural types (that aren't real classes), but the implementation is pretty hairy and I don't think it would fly in Kotlin

Thanks for the pointer. 'structural types' sounds exactly like what I was looking for

well, it is better in Scala 3, it can be implemented without reflection https://docs.scala-lang.org/scala3/reference/changed-features/structural-types-spec.html

You can even do

object MapDelegate {
    operator fun <R> getValue(map: Map<String, Any>, prop: KProperty<*>): R = map[prop.name] as R
}
@JvmInline value class Response(private val data: Map<String, Any>): Map<String, Any> by data 

val Response.foo: Foo? by MapDelegate

where MapDelegate can be used as a delegate for any object that is a

Map<String, Any>

. Sadly value classes don't allow doing

by underlyingValue

for some reason, and so I had to define them as extension properties. Only issue is that sadly the name of the property is accessed through the

KProperty

object, which requires an object to exist per property.

We plan to do this with the further work on the contracts. The prototype we’ve developed allows declaring types like this:

typealias PositiveInt = Int requires { it > 0 }

The additional requirement is completely erased at run-time but is checked at compile-time, so this code will not compile:

val x: Int = getSomeInt()
val y: PositiveInt = x // cannot assign PositiveInt to Int

But this code will compile:

val x: Int = getSomeInt()
require(x > 0)
val y: PositiveInt = x // OK

You can imagine using it with other types like Strings to represent domain-specific restricted string subsets, maps, etc.

Oooohh interesting 👀 . Is there a KEEP/Youtrack were I can follow progress?

KT-51417 Restricted types