A modern programming language that makes developers happier.

kotlinlang

Is there a way to set lower bounds on generic function params in Kotlin? Or ensure that one type param is _NOT_ equal to another type param (or does not extend the other) at compile time?
Imaginary syntax could be
```fun &lt;A, B&gt; myFunction(a: A, b: B) where A !: B {
   ...
}```

I don't think there is a way to ensure type parameters are different. But what is your use case for this?

I’m using Java’s `Proxy.newProxyInstance()` method which requires the interface you’re proxying to be passed in. I also need to pass in a variable which implements that interface. Unfortunately at the call site, it’s easy to accidentally pass in the concrete class for both generic params as the compiler will infer it (if you don’t explicitly write them) and there will be no compile time errors.

A simplified version looks like this
```inline fun &lt;reified Concrete, reified Interface&gt; makeProxy(concrete: Concrete) where Concrete : Interface {
   ...
   return newProxyInstance(  
       apiClass = Interface::class.java.classLoader,
       arrayOf(Interface::class.java),
       MyCustomProxyClass(concrete as Interface),
   ) as Interface
}```
And the call site looks like
```fun doStuff(): MyInterface {
    makeProxy(MyConcreteClass()) // &lt;--- In some places the compiler reads this as makeProxy&lt;MyConcreteClass, MyConcreteClass&gt;(MyConcreteClass())
}```

what about making the interface class an explicit argument of `makeProxy` ?

Yeah so you can explicitly put it in, but I want to ensure safety at the call site so other devs don’t accidentally make this mistake. It’s a large project where this method is called in 100s of spots

What I mean is, make the `makeProxy` function take 2 parameters:

```fun &lt;I, I : C&gt; makeProxy(concrete: C, target: KClass&lt;I&gt;): I {
   ...
   return newProxyInstance(  
       apiClass = target.java.classLoader,
       arrayOf(target.java),
       MyCustomProxyClass(concrete),
   ) as I
}```
So the call site will be forced to provide both arguments, and cannot rely solely on type inference:

```fun doStuff(): MyInterface {
    makeProxy(MyConcreteClass(), MyInterface::class)
}```

Ah yeah, I actually have that function and the `inline` version calls it. The problem is that’s not as pretty or nice to use :joy: Ideally the callsite just looks like
```MyConcreteClass().makeProxy()```
(the class is actually the receiver param in my code)
This requires the encapsulating function to specify `MyInterface` as the return type ofc

I’ve actually already found a workaround, but the question about type lower bounds and checking non-equal types still interests me

Checking non-equal types is not possible I believe. But regarding lower bounds I don't see how that would help here :thinking_face:

Maybe lower bound is the incorrect terminology. It would be cool having a compile time check that either
1. A generic type param does _not_ extend from `X` or any of its subclasses, or
2. A generic type param is an `interface` and not a `class`
Applying either of those restrictions could help