is there a way to accomplish this without finding some class

Question

is there a way to accomplish this without finding some class from which both inherit

Shawn · Answer

overloading and delegation to a private method that holds common logic is probably the general solution

Hullaballoonatic · Answer

could you perhaps give me an example delegation is something i m not super comfortable with and i m not sure what we d be overloading here

Hullaballoonatic · Answer

a specific example of what i d like to accomplish ``` class SynchedPairs lt K V gt val a = ArrayList lt Pair lt K V gt gt val b = ArrayList lt Pair lt V K gt gt operator fun get key K V = a key operator fun get key V K = b key ```

Hullaballoonatic · Answer

but that doesn t work because they share signatures

Hullaballoonatic · Answer

so i tried doing it inline with reified types but that means the return type will be Any meaning it would require explicit typing when you call the function eliminating much of the convenience i want to create here

Hullaballoonatic · Answer

make sense

Shawn · Answer

Well my recommendation would work with concrete types generics make things a bit more complex

Hullaballoonatic · Answer

yeah it s just I like using generics as much as possible because it s good refactoring practice and I think it makes things more readable

Shawn · Answer

in your case I don t really know what you d really be able to do aside from define non operator functions like `getK` and `getV`

Hullaballoonatic · Answer

yeah and that s really unfortunate

Shawn · Answer

maybe ` JvmName` would help here but that s maybe a bit of a stretch

Hullaballoonatic · Answer

shame kotlin doesn t smartcast the output of inline functions

Hullaballoonatic · Answer

to the precise type that the function returns in this case

Hullaballoonatic · Answer

or does it

Shawn · Answer

I don t think inlining should change the behavior of smartcasting

Hullaballoonatic · Answer

yeah i get you but do you agree it would be nice to accomplish what i m trying to

Shawn · Answer

buuuut I just tried out the ` JvmName` solution and it doesn t give me compile errors

Shawn · Answer

``` class Test lt K V gt val a = mutableMapOf lt K V gt val b = mutableMapOf lt V K gt JvmName getK operator fun get key K V = a key JvmName getV operator fun get key V K = b key ```

Hullaballoonatic · Answer

how does this help me

Hullaballoonatic · Answer

or rather

Shawn · Answer

From Kotlin you ll be able to define your operator `get`s and use them without having to call specific methods

Hullaballoonatic · Answer

would i still call it as a standard get operator

Shawn · Answer

yep

Shawn · Answer

you d just need to use those `getX` methods from Java

Hullaballoonatic · Answer

I m kind of baffled the solution was like this

Hullaballoonatic · Answer

ah i get it

Shawn · Answer

The problem with even inlined methods is that the method still needs to be generated and named at compile time before it gets inlined into a method body

Shawn · Answer

so those methods still need to be distinct to the JVM

Hullaballoonatic · Answer

I feel like i ll be using this annotation quite a bit

Hullaballoonatic · Answer

i really should probably use more of them but i don t fully understand what they are i think from context they are directions to the compiler

Hullaballoonatic · Answer

the only other one i ve used in kotlin was ` JvmStatic`

Hullaballoonatic · Answer

because well obviously

Shawn · Answer

Some annotations are other annotations are directives or metadata for other frameworks like Guice which handles dependency injection

Hullaballoonatic · Answer

yeah in angular they are like constructor arguments

Shawn · Answer

the ` Jvm ` ones are provided by the language to ease JVM interop problems

Shawn · Answer

for your particular case I feel like you re more just brushing up against the limits of the Kotlin type system and generics on the JVM

Hullaballoonatic · Answer

Is JB trying to bake it into the kotlin compiler to deprecate those annotations

Shawn · Answer

I mean the annotations are supposed to be used judiciously to ease the occasional conflict

Shawn · Answer

afaik JB probably isn t planning on prioritizing more of the math ey type system features

Hullaballoonatic · Answer

hmm

Shawn · Answer

TypeScript and Elm and F are all tackling that kind of thing and it likely just appeals to their userbases more than Kotlin s

Hullaballoonatic · Answer

TypeScript is the only other language that really competes as my favorite to write in There are times however i really just wish I had pointers and pass by value reference

Hullaballoonatic · Answer

i wish i liked writing in cpp more

Shawn · Answer

Personally speaking I m pretty glad I don t have to manage things like pointers and move copy semantics

Hullaballoonatic · Answer

i prefer that i don t have also just like with garbage collection but it would be nice to have the option somehow

Pavlo Liapota · Answer

Interesting which method will be called in example with ` JvmName` if `K` and `V` will be the same type slightly smiling face

Hullaballoonatic · Answer

hmmm that s a good point

Shawn · Answer

Pretty sure the class will just be unusable at that point

Hullaballoonatic · Answer

i could certainly make it unusable

Shawn · Answer

you ll just get an overload resolution ambiguity error at compile time

Hullaballoonatic · Answer

```class BidirectionalMap lt K V gt val a = mutableMapOf lt K V gt val b = mutableMapOf lt V K gt operator fun get key K V = a key JvmName getB operator fun get key V K = b key operator fun set key K value V a key = value b value = key JvmName setB operator fun set key V value K b key = value a value = key operator fun contains key K Boolean = a containsKey key JvmName containsB operator fun contains key V Boolean = b containsKey key ``` we ll see how this works

Hullaballoonatic · Answer

if it does i can expand it to have sort and other shit