Can someone explain to me why the `reduce` signatu...

# announcements

[Kerem Aslan]

Can someone explain to me why the reduce signature is like:

inline fun <S, T : S> Array<out T>.reduce(
    operation: (acc: S, T) -> S
): S

While the fold signature is like:

inline fun <T, R> Array<out T>.fold(
    initial: R,
    operation: (acc: R, T) -> R
): R

Shouldn't reduce be able to take two independent types instead? Something like

inline fun <S, T> Array<out T>.reduce(
    operation: (acc: S, T) -> S
): S

For context, I am trying to use reduce with a long accumulator and a domain object I am using. Something like:

myCollection.reduce { acc, myObject ->
    acc + myObject.myField
}

That doesn't work but this does:

myCollection.fold(0) { acc, myObject ->
    acc + myObject.myField
}

This is counterintuitive and confusing.

[Vampire]

In case you could do

myCollection.reduce { acc, myObject ->
    acc + myObject.myField
}

what would you expect the operation to be called with the first time?

[Kerem Aslan]

No value? So basically the value of the first myField

[Vampire]

And how should reduce know that?

[Kerem Aslan]

Hmm, good point. Maybe via acc: T? , where it returns myField and otherwise applies the lambda?

[Vampire]

I'm not sure how you mean that, but fold is exactly what you want. Not sure why you are not happy with it. Just tried to show you why three signature of reduce is like it is. :-)