A modern programming language that makes developers happier.

kotlinlang

```fun &lt;T&gt; identity(t: T): T = t

fun &lt;T, E&gt; Iterable&lt;T&gt;.allSameValue(f : (T) -&gt; E = ::identity) : E? { /* ... */ }```
I'm getting `Required: T, Found E` for the default value on the parameter. why? what's wrong with `E = T`?

When `T = E`, everything is OK. But compiler says, "What if `E != T`? Then `::identity` function does not fit the type `(T) -&gt; E`."

And the code that breaks your concept may look like this:
```fun main() {
    listOf(1, 2, 3).allSameValue&lt;Int, String&gt;()
}```

image.png

e.g. if you don’t use a callable reference but instead a lambda to call `identity` you have to make an explicit unsafe cast

the caller can instantiate this with any `E` and then `::identity` doesn't agree with the requirement of returning `E`

You could bound generics so that `T` must be a subtype of `E` :
`fun <T : E, E> Iterable<T>.allSameValue(f: (T) -> E = ::identity): E?`
With such signature `identity` function would always fit into generics bound, and mapping function could be used with its result matching supertypes of T.

Example:
```val l = listOf(123)
val x: Number? = l.allSameValue { it.toDouble() }```

<@U03K481DSJF> yep but that makes the function less general. I figured out I can just add another overload of `allSameValue`:
`fun &lt;T&gt; Iterable&lt;T&gt;.allSameValue(): T? = allSameValue { it }`

Sure, but using signature with `T : E` and not not passing any arguments would achieve basically the same, since from the default value of of `f` being `identity` function, `E` would just be inferred as `T`, since `indentity` takes and returns same generic type:
```val l = listOf(1, 2, 3)
val x = l.allSameValue() // inferred as Int?
val z = l.allSameValue<_, Number>() // inferred as Number? because of explicit generics type declaration```