Which do you think reads more clearly/naturally? :...

# codereview

[Shawn]

Which do you think reads more clearly/naturally?
🅰️

val typeParameters: Array<Class<*>> by lazy {
  (fieldType.type as? ParameterizedType)
      ?.actualTypeArguments
      ?.map { it as Class<*> }
      ?.toTypedArray()
    ?: emptyArray()
}

🅱️

val typeParameters: Array<Class<*>> by lazy {
  when (val type = fieldType.type) {
    is ParameterizedType -> type.actualTypeArguments
        .map { it as Class<*> }
        .toTypedArray()
    else -> emptyArray()
  }
}

(fieldType.type is a property that has open or custom getter, so smart-casting can't be used with it)

[Shawn]

Bonus:

.map { it as Class<*> }

or

.map(Class::class::cast)

[Shawn]

.filterIsInstance<Class<*>>() might also work here, but could potentially cause a bug by quietly filtering out elements that aren't Class instances

[Joffrey]

Ideally, make this return a list, not an array, and avoid the extra .toTypedArray()

[Javier]

and you can us .orEmpty() with that

[Shawn]

@Joffrey ideally, yes, but nothing about this is "ideal" really. this array eventually gets passed to a method provided by an external library, and that method consumes an array rather than a list. I could keep the result of map and then force any user of said method to call .toTypedArray() when they use it, or I could call it once here and cache the results.