I'm not sure how boxing works sometimes with inline classes, or rather why it works that way. Here'...

# getting-started

[Johann Pardanaud]

I'm not sure how boxing works sometimes with inline classes, or rather why it works that way.

Here's a simple example:

@JvmInline
value class Wrapper(val value: CharSequence) : CharSequence by value

Here, since the inline class and its underlying value both implement the CharSequence interface, I could write either:

val wrappedValue: CharSequence = Wrapper("foo")
// OR
val wrappedValue: CharSequence = "foo"

But, in the first case, the value seems to be boxed:

@NotNull
   private static final CharSequence wrappedValue = Wrapper.box-impl(Wrapper.constructor-impl((CharSequence)"foo"));

There is probably a reason, but I don't get it. 🤔

[Johann Pardanaud]

Also, in a general manner, it seems like using inline classes inside collections is bad idea?

[Johann Pardanaud]

I wanted to use inline classes to clarify some types returned by my library. Instead of having:

fun someFun(): Set<List<String>>

I would like to provide something a bit more readable:

fun someFun(): Set<ExplicitType>

Since I need the collections, should I go with a type alias instead of an inline class?

[ephemient]

how do you imagine it would work if it weren't boxed?

[Johann Pardanaud]

In my first message, the inline class and the underlying value implement the same interface, so I imagine they are interchangeable?

And about collections, or generics in a general manner, honestly I don't know, I'm out of my league there. 😅 But I'm not searching for an explanation, just for an answer to my question "it seems like using inline classes inside collections is a bad idea?"

[ephemient]

they are not interchangeable, wrappedValue is Wrapped evaluates differently

[ephemient]

it's not necessarily a bad idea, but it is in line with everything else. primitives are also boxed when used through a generic or reference type

[Johann Pardanaud]

Ah! You’re right, thank you 😅

[Johann Pardanaud]

So, since using inline classes seems to bring a lot of performance issues in my use case (generics). What is recommended? Using a standard class? A typealias? (are those even publicly available when a library uses them internally?)

[Joffrey]

Basically every time a value class is used as another type (generics, superclass, superinterface, etc.) it is boxed

[ephemient]

you can't have a superclass of a value class (beyond Any which is special) but yes

[Stephan Schröder]

so always use the WrappedType and most of the time at runtime it will just be the basic type without overhead 😂

[Johann Pardanaud]

Couldn't this be an issue? Since boxing/unboxing could happen multiple times for the same value.

For example, the following code:

fun main() {
    val list = listOf(Wrapper("foo"))
    val second = list.first()
    val third = listOf(second)
}

Generates:

List list = CollectionsKt.listOf(Wrapper.box-impl(Wrapper.constructor-impl("foo")));
      String second = ((Wrapper)CollectionsKt.first(list)).unbox-impl();
      List third = CollectionsKt.listOf(Wrapper.box-impl(second));

You can see it boxes, unboxes, and boxes again.

[Johann Pardanaud]

but maybe this is premature optimization 🤔