is there something in Arrow that would allow me to define a

Question

is there something in Arrow that would allow me to define a `doSomething lt T1 Tn Tn gt ` that would output `On` In other words if I provide 5 generics I want an `O5 lt T1 T2 T3 T4 T5 gt ` as output and if I define 1 generic I want `O1 lt T1 gt ` as output

Giorgos Makris · Answer

As far as i can see there is not something like that but this looks a lot like a tuple of n items What makes your `O` different from a tuple

janvladimirmostert · Answer

if my understanding of Tuple is correct O is a Tuple so that you can do ` a b c = doSomething lt Int String Boolean gt ` 99 is just for illustration purposes probably don t need more than 20 What mechanism would be able to translate function lt T1 T2 T3 gt to a tuple of 3 items

Giorgos Makris · Answer

this might not be the best solution but i have seen a few java libraries do it but essentially they generate all the code required for up to 20 22 items

janvladimirmostert · Answer

I m happy with such a solution too but fun submit lt T1 gt fun submit lt T1 T2 gt will complain that they are not correctly overloading unless you give them different number of params

janvladimirmostert · Answer

it would be even trickier when you have varargs for inputs fun submit lt T1 gt varargs inputs String O1 fun submit lt T1 T2 gt varargs inputs String O2

Giorgos Makris · Answer

what if you made those functions values instead and keep them in data classes or a hashmap

janvladimirmostert · Answer

something like val array = Array array 1 = vararags gt O1 array 2 = vararags gt O2 that actually looks interesting

Giorgos Makris · Answer

yeah it could be just like that slightly smiling face

janvladimirmostert · Answer

although I ll probably need to map it to val array = Array array 1 = submit1 array 2 = submit2

Giorgos Makris · Answer

not necessarily

janvladimirmostert · Answer

so how do we go from 5 generics to a number of 5 so that I can do such a lookup

Giorgos Makris · Answer

```mapof Pair O5 class o5 gt do submit stuff ```

Giorgos Makris · Answer

you could have sth like that to make the association

Giorgos Makris · Answer

and you might have to define an abstract `o` or interface for it to be able to have a common type for the map

janvladimirmostert · Answer

would this still work for the submit lt T1 T2 T3 gt to somehow output the number 3 so that I can do such a lookup

janvladimirmostert · Answer

unless I make `submit` itself a class mmm

Giorgos Makris · Answer

would it work for you if you made submit generic over `O`

Giorgos Makris · Answer

nah the implementation would be different

janvladimirmostert · Answer

you mean like submit lt O gt and then depending on whether I have val a = submit lt O gt or val a b = submit lt O gt it would automatically switch to O1 or O2

Giorgos Makris · Answer

yeah but it s really hard to imagine one implementation for everything unless it s something that suits you

janvladimirmostert · Answer

if I can define the output types in the destructuring that would work too a Int b String = submit

janvladimirmostert · Answer

I do need to access a list of those types inside the submit function though

Giorgos Makris · Answer

i m not really sure about the destructuring part confused

janvladimirmostert · Answer

I could alway just explicitly do submit lt O3 lt Int String Boolean gt gt and be done with it but I m trying to avoid having to explicitly define that

janvladimirmostert · Answer

something else I ve tried ```val result = submit i = T BLAH1 blah1 BLAH2 blah2 o = T BLAH1 BLAH1 BLAH2 want val a BLAH1 b BLAH1 c BLAH2 = result instead getting val a BLAH1 Companion b BLAH1 Companion c BLAH2 Companion = result```

janvladimirmostert · Answer

but `a` now contains `BLAH1 Companion` instead of `BLAH1`

janvladimirmostert · Answer

so if I can get rid of the Companion that ll work too

janvladimirmostert · Answer

that example already converts the T to T3 since it has 3 params and works great

Giorgos Makris · Answer

if you say so smile i am a bit lost

janvladimirmostert · Answer

BLAH1 is defined as class BLAH1 companion object if you pass a non instance of BLAH1 as param to the list it grabs the companion of Blah1

Giorgos Makris · Answer

ah i see

janvladimirmostert · Answer

if I put bogus values into the o = part ```val result = submit i = T BLAH1 blah1 BLAH2 blah2 o = T BLAH1 null BLAH1 null BLAH2 null ``` I get the correct output types but that means creating an unnecessary instance for each output type

janvladimirmostert · Answer

once again I can also probably just do ```val result = submit i = T BLAH1 blah1 BLAH2 blah2 o = T3 lt BLAH1 BLAH1 BLAH2 gt ``` and be done with it but I m trying to not specify that 3

Giorgos Makris · Answer

it s pretty late for me to offer anything better stuck out tongue

janvladimirmostert · Answer

` a b c = submit lt O3 lt T1 T2 T3 gt gt value1 value2 valuen ` is probably not that bad I ll just have to convince myself that explicitly specifying the number of outputs is awesome hahaha

janvladimirmostert · Answer

thanks for the input you gave me some things to think about and good night to you I need to get some Zzz too

Giorgos Makris · Answer

rest well if you need anything more feel free to dm me

janvladimirmostert · Answer

thanks Giorgos

janvladimirmostert · Answer

you too

janvladimirmostert · Answer

the only way I can think of doing this is via code generation so a compiler plugin that would convert O lt T1 T2 gt to O2 lt T1 T2 gt seems like the only way to do this for now I ll just use O2 directly until it becomes easy to write such Compiler plugins

Giorgos Makris · Answer

generating kotlin code with clojure sounds like a fun project stuck out tongue

Youssef Shoaib [MOD] · Answer

You could just define many overloads ```fun lt T1 gt doSomething O1 lt T1 gt fun lt T1 T2 gt doSomething O2 lt T1 T2 gt ``` You can easily generate this lol What I ve done in the past is written some Kotlin code that generates it and placed it at the bottom of that file

janvladimirmostert · Answer

you can only do the overloads if they have a different number of params not if they have varargs

Youssef Shoaib [MOD] · Answer

Oh right there is a way around this though You can do the overloads like this ```fun lt T1 gt doSomething vararg args Type O1 lt T1 gt fun lt T1 T2 gt doSomething vararg args Type unit1 Unit = Unit O2 lt T1 T2 gt fun lt T1 T2 T3 gt doSomething vararg args Type unit1 Unit = Unit unit2 Unit = Unit O3 lt T1 T2 T3 gt ``` Again really easy to code generate Overload resolution then works based on how many type arguments you specify

phldavies · Answer

how about using a single typemarker object rather than multiple units I would guess less impact on the stack that way ```sealed interface TypeMarker lt out T1 out T2 out T3 out T4 out T5 gt object IMPL TypeMarker lt Nothing Nothing Nothing Nothing Nothing gt fun lt T1 gt doSomething vararg args String typeMarker TypeMarker lt T1 Nothing Nothing Nothing Nothing gt = TypeMarker IMPL T1 = TODO fun lt T1 T2 gt doSomething vararg args String typeMarker TypeMarker lt T1 T2 Nothing Nothing Nothing gt = TypeMarker IMPL Pair lt T1 T2 gt = TODO fun lt T1 T2 T3 gt doSomething vararg args String typeMarker TypeMarker lt T1 T2 T3 Nothing Nothing gt = TypeMarker IMPL Triple lt T1 T2 T3 gt = TODO fun lt T1 T2 T3 T4 gt doSomething vararg args String typeMarker TypeMarker lt T1 T2 T3 T4 Nothing gt = TypeMarker IMPL Tuple4 lt T1 T2 T3 T4 gt = TODO fun lt T1 T2 T3 T4 T5 gt doSomething vararg args String typeMarker TypeMarker lt T1 T2 T3 T4 T5 gt = TypeMarker IMPL Tuple5 lt T1 T2 T3 T4 T5 gt = TODO fun main val a = doSomething lt String gt val b c = doSomething lt Int Long gt val d e f = doSomething lt Byte List lt String gt Set lt String gt gt ```

janvladimirmostert · Answer

wow This could actually work All I mmissing is that I need to be able to access the Companion of T1 inside the function ```inline fun lt reified Z1 gt doSomething vararg args String typeMarker TypeMarker lt Z1 Nothing Nothing Nothing Nothing gt = TypeMarker IMPL Z1 Z1 class Companion TODO ```

janvladimirmostert · Answer

so the types I m planning to return looks like this ``` JvmInline value class INT4 override val value ByteArray Encodable constructor value Int this value toString toByteArray constructor value String this value toByteArray companion object Decodable override val code = 23 ``` I need to be able to get the code of that Decodable somehow ```inline fun lt reified Z1 Decodable gt doSomething vararg args Encodable typeMarker TypeMarker lt Z1 Nothing Nothing Nothing Nothing gt = TypeMarker IMPL Z1 Z1 code lt lt I think this is the only missing piece TODO ``` so that I can do a lookup if it s code 23 I know I should grab 4 bytes in order to return INT4

janvladimirmostert · Answer

this works ```fun lt T gt mapValue code Int value String T inline fun lt reified Z1 gt doSomething vararg args Any typeMarker TypeMarker lt Z1 Nothing Nothing Nothing Nothing gt = TypeMarker IMPL Z1 return when Z1 class java name INT4 class java name gt mapValue INT4 code 1234 INT8 class java name gt mapValue INT8 code 5678 else gt TODO add more types ``` with about 50 types that `when` is not a great solution ```val a INT4 = doSomething lt INT4 gt INT4 123 INT8 122312 ``` `a` now correctly contains INT4 123 Similarly for 2 outputs ```inline fun lt reified Z1 reified Z2 gt doSomething vararg args Any typeMarker TypeMarker lt Z1 Z2 Nothing Nothing Nothing gt = TypeMarker IMPL Pair lt Z1 Z2 gt val z1 = when Z1 class qualifiedName INT4 class qualifiedName gt INT4 INT4 code INT8 class qualifiedName gt INT8 INT8 code else gt TODO add more types as Z1 val z2 = when Z2 class qualifiedName INT4 class qualifiedName gt INT4 INT4 code INT8 class qualifiedName gt INT8 INT8 code else gt TODO add more types as Z2 return Pair z1 z2 ``` ```val b c = doSomething lt INT4 INT8 gt println b println c ``` Outputs INT4 23 INT8 20 tada now just to optimize that mapping inside doSomething without using reflection

phldavies · Answer

you should be fine to match on the class directly i e `when Z1 class INT4 class gt INT4 INT4 code `

phldavies · Answer

if you don t mind using full reflection you can probably also use `val code = Z1 class companionObjectInstance as Decodable code error not decodable type `

Giorgos Makris · Answer

< phldavies> if you don t mind me asking is the reflection api available in native kotlin

janvladimirmostert · Answer

is a `when` with 50 such types the fastest way to do this I was hoping there s a way to do Z1 code and then use an Array lookup val lookup = Array lookup 23 = INT4 it lookup 20 = INT8 it I guess I ll have to benchmark the difference in speed between a 100k lookups using reflection to get the code an do the map lookup VS just a giant switch case

phldavies · Answer

Not as I m aware I believe there s only full reflection in JVM

phldavies · Answer

You ll find a `when` just as fast as an array lookup by index possibly faster

janvladimirmostert · Answer

benchmarks I previously ran showed that the array lookup was faster than the giant switch case but I ll redo those to confirm thanks for all the help < phldavies> < Giorgos Makris> < Youssef Shoaib MOD > this has been a great learning experience btw that typeMarker solution is awesome such a clever way to abuse the varargs

Youssef Shoaib [MOD] · Answer

< phldavies> ironically enough TypeMarker is literally my pattern at least AFAIR I would call it TypeWrapper with the whole `sealed interface` and a nested `object IMPL` thing and I literally didn t think of that as a solution lol I agree that using TypeMarker is probably a good idea here Btw you can define multiple arities of TypeMarker as typealiases with a singular `object IMPL` and that ll save you from having to use a lot of `Nothing`s

janvladimirmostert · Answer

I saw that somewhere in a Kotlin snippet something like this ```sealed class TW5 lt out T1 out T2 out T3 out T4 out T5 gt PublishedApi internal object IMPL TW5 lt Nothing Nothing Nothing Nothing Nothing gt typealias TW4 lt T1 T2 T3 T4 gt = TW5 lt T1 T2 T3 T4 Nothing gt typealias TW3 lt T1 T2 T3 gt = TW4 lt T1 T2 T3 Nothing gt typealias TW2 lt T1 T2 gt = TW3 lt T1 T2 Nothing gt typealias TW1 lt T1 gt = TW2 lt T1 Nothing gt ```

Youssef Shoaib [MOD] · Answer

Yep indeed It most likely was one of my snippets probably exploring intersection types That should help cut down on the amount of arguments you need to define

janvladimirmostert · Answer

I still have it bookmarked it was this one <https rb gy sua1e6> and it was indeed for intersection types