Cómo representar múltiples types (types de unión) al apuntar a JavaScript

Lo que me gustaría hacer es usar un tipo genérico que puede ser uno de los otros tres types.

Aquí hay un ejemplo con una function:

fun <T> get(key: String) : T where T: String, T: Number, T: Boolean {} 

El código anterior no funciona, entonces ¿cómo debo hacer esto?

Para KotlinJS puede usar ts2kt para traducir sus definiciones de TypeScript a Kotlin. Sí admite Tipos de unión pero quizás no todos los casos son perfectos. Hay testings para unionTypes en ts2kt que arrojan luz sobre cómo se manejan ahora y puede hacer algo similar para cualquier cosa que esté creando a mano al apuntar a la plataforma de JavaScript.

Se menciona el trabajo adicional en los comentarios del número 41 para agregar un mejor soporte de Tipo de Unión . Por último, hay al less un hilo de discusión sobre el tema que indica:

En JS y TS, en la mayoría de los casos, los types de unión se usan como alternativa a la sobrecarga, por lo que en el futuro cercano, vamos a utilizar la sobrecarga cuando sea posible. Además, pensamos en proporcionar la forma adicional de especificar types de unión para declaraciones nativas.

Hay otra pregunta de Desbordamiento de stack que habla de esto y ofrece algunas opciones actuales: Kotlin y las uniones discriminadas (types de sum) que tienen respuestas que son válidas en todas las plataforms de destino de Kotlin.

Específicamente para el objective JavaScript, puede considerar usar el tipo dynamic . Veo al less un caso de testing en ts2kt que está usando este tipo. Este ejemplo comienza con este código TypeScript:

 declare class Foo type Key = Key2 | number; type Key2 = string | Foo; declare var fooKey: Key; declare function barKey(a: Key|number); declare function barList(a: List<Key>); declare function barArray(a: Key[]); interface Parent { (...children: Key[]): Foo; } 

Y genera este Kotlin usando dynamic como un tipo de devolución en lugar del tipo de unión; y en otros casos, sobrecargar la firma del método para manejar el tipo de unión ( algunos comentarios añadidos por mí ):

 external open class Foo // using dynamic in place of union type external var fooKey: dynamic /* String | Foo | Number */ = definedExternally // using method overloading in place of union type external fun barKey(a: String): Unit = definedExternally external fun barKey(a: Foo): Unit = definedExternally external fun barKey(a: Number): Unit = definedExternally // using dynamic in place of union type external fun barList(a: List<dynamic /* String | Foo | Number */>): Unit = definedExternally external fun barArray(a: Array<dynamic /* String | Foo | Number */>): Unit = definedExternally external interface Parent { // using method overloading in place of union type @nativeInvoke fun invoke(vararg children: String): Foo @nativeInvoke fun invoke(vararg children: Foo): Foo @nativeInvoke fun invoke(vararg children: Number): Foo } 

Pero, de nuevo, debe revisar todos los casos de testing ts2kt para types de unión para ver otras ideas, incluso para el event handling undefined .

Esto no funciona porque T no se puede representar como un tipo que se encuentra en la intersección de String , Number y Boolean .

Si desea restringir su tipo a una list de types pnetworkingefinidos, las classs selladas son una gran solución.

 sealed class MyData { class Bool(val data: Boolean) : MyData() class String(val data: String) : MyData() class Number(val data: Number) : MyData() } fun get(key: String): MyData = TODO() 

¿Cómo sabría el comstackdor qué tipo se devuelve en este caso? T podría presumiblemente ser cualquier cosa, por lo que no serían forma de definir algo así.

Podría definir tres methods específicos de tipo:

 fun getString(key: String): String = ... fun getBoolean(key: String): Boolean= ... fun getInt(key: String): Int = ... 

(O un método de envoltura, como casi se sugirió)