A modern programming language that makes developers happier.

kotlinlang

Is it possible to write `justAddThem1` such that it takes any numeric type?
`justAddThem2` and `justAddThem3` won't compile.
```
fun justAddThem1(x: Int, y: Int) = x + y

fun justAddThem2(x: Number, y: Number) = x + y

fun &lt;T : Number&gt; justAddThem3(x: T, y: T) = x + y
```

use ad-hoc polymorphism <http://beust.com/weblog/2016/06/20/ad-hoc-polymorphism-in-kotlin/>

e.g. `fun &lt;T: Number&gt; justAddThem(x: T, y: T, f: (T, T) -&gt; T) = f(x, y)`

Thanks <@U0D06TWMA>. Didn't know that was the term for it :smile:

<@UBH3R7084> thats how <@U0B8ZP13Q> calls it :grimacing:

Hopefully it's not just me calling it that :slightly_smiling_face:

I actually know Haskell, and am familiar with the terms ad-hoc polymorphism and the other side of the coin, parametric polymorphism.
Parametric polymorphism is when you're dealing with a type that could be absolutely anything under the sun. So, if I were to attempt to apply the term to Kotlin, I'd imagine something like this:

```
fun &lt;T&gt; f(x: T) { /* ... */ }
```
Function `f` is parametrically polymorphic.
Ad-hoc polymorphism in Haskell would be when there is a typeclass constraint on the type variable. Haskell typeclasses are similar to OOP interfaces. So, in Kotlin, I'd imagine something like this:
```
fun &lt;T: Comparable&gt; f(x: T) { /* ... */ }
```

`T` is constrained in the sense that it's no longer anything under the sun, it's anything that is comparable.

<@UBPEE4WMV> I wouldn't call type boundaries ad hoc polymorphism, they are a different concept. Ad hoc polymorphism is more concerned with adjusting types to make them conform to an interface they do not initially conform with.

Well, I'm only familiar with how the terms apply to Haskell.

In any case, this
```
fun &lt;T: Number&gt; justAddThem(x: T, y: T, f: (T, T) -&gt; T) = f(x, y)
```
really doesn't add the numbers, does it? Looks like it just takes two numbers and a function, and applies the function to the two numbers.

Yes, I guess it's a more universal "add", in a monoidal sense. "Combine" would be another term

I think it's just function application...? `f` could do anything.

It could, for example, just perform a side effect, perhaps:
```
fun f(x: Int, y: Int) { println("$x / $y") }
```

I guess my point is, maybe one's intent is to use `justAddThem` to "add" or "combine" in some sense, but there are no guarantees from the type system or otherwise that enforce that.

<@U5NNZPRPS> thats a typesafe way to do it, you could also do it the following way e.g.
```
fun &lt;T: Number&gt; justAddThem(x: T, y: T): T {
    return when {
        x is Int &amp;&amp; y is Int -&gt; x + y
        x is Double &amp;&amp; y is Double -&gt; x + y
        [...]
        else -&gt; throw Exception()
    } as T
}
```

OK, I can see that. Though personally I'm not a big fan of all the boilerplate.
I wonder if it would work without the `&amp;&amp; y is Int` if `x` and `y` are both `T`.