I've got a use case where I iterate over a sequenc...

# announcements

[bbaldino]

I've got a use case where I iterate over a sequence of numbers to find the max, but I'd like to "quit early" if I find a value over a certain number and just return that as the max, is there a good way to do this? I could call .any { it > bigEnoughNum } first, but then if that returns false I have to iterate again to find the actual max, which doesn't seem efficient.

[nanodeath]

iterable.first { it > bigEnoughNum }?

[bbaldino]

Is that different from the any method? If it fails I'd still have to iterate over the whole list to find the max.

[nanodeath]

it returns the thing that was > bigEnoughNum

[nanodeath]

or throws if there is none...but you can use firstOrNull or find the same exact way

[bbaldino]

Ah, yes in my case I don't necessarily care about the specific value that's > bigEnoughNum

[ephemient]

it's an inline function, so (depending on the structure of your code)

iterable.maxByOrNull {
    if (it > bigEnoughNum) return
    it
}

will break early

[bbaldino]

Good call...I thought about just doing a return but I was just thinking the local return wouldn't do much...so I could move this to another method and do that.

[nanodeath]

or use first? I'm still unclear why that doesn't work

[Nir]

first doesn't work because if no numbers are larger than bigEnoughNum

[Nir]

you have to do a second pass

[Nir]

to get the max

[Nir]

hmm i was thinking maxByOrnull could be used without refactoring but it's surprisingly tricky for type inference reasons

[Nir]

either that or I'm making a silly mistake

[Nir]

val x = listOf(1,10,11)
    println(x.maxByOrNull { if (it > 8) return@maxByOrNull it else it })

[Nir]

I expected that to print 10, but it prints 11

[bbaldino]

Pretty sure return@maxByOrNull is the same as the normal return that happens there

[bbaldino]

So you'd need some other label, but I don't think that'd work with a sequence chain (don't think you can add a label there), so you'd have to do it in an enclosing method I think

[Nir]

println(run { x.maxByOrNull { if (it > 8) return@run it else it }!! })

[Nir]

that'll do it

[Nir]

It's not the same btw

[Nir]

actuall I'm wrong

[Nir]

It's the same 🙂

[Nir]

So yeah, the run thing is the same, though at that point it might be messy enough to turn into a one liner anyway

[bbaldino]

Yeah

[Nir]

fun <T: Comparable<T>> Iterable<T>.maxOrOver(threshold: T) = this.maxByOrNull { if (it > threshold) return it else it}!!

[ephemient]

more general could be

inline fun <T: Comparable<T>> Iterable<T>.firstOrMaxOrNull(
    crossinline predicate: (T) -> Boolean
): T? = maxByOrNull { if (predicate(it)) return it else it }

not sure how general it should be, though. seems pretty specialized

[streetsofboston]

What about using the takeWhile/takeUntil function?

[bbaldino]

Oh, using that to 'short circuit' the sequence?

[bbaldino]

That's a good idea...looks like that works

[ephemient]

constructs a new list… but if that's acceptable then go for whatever is the clearest code for you

[bbaldino]

Is that true in the sequence case?

[Nir]

prob not but to use it on a sequence you'd need to do asSequence first which is annoying

[Nir]

It would be really nice if kotlin supported some form of "or" constraints on generics

[Nir]

it's so common to write functions that would work with either iterables or sequences

[Nir]

AFAICS you have to implement them twice basically

[ephemient]

on JVM the compiler would either have to output multiple implementations or silently use reflection

[ephemient]

Scala has union types and its approach is the latter

[ephemient]

but also - iterable and sequence operations are significantly different in Kotlin

[ephemient]

iterable operations are inline (they're all immediate, so early return etc. work), sequence operations are out-of-line (they're all lazy, so early return is impossible)

[Nir]

Yes, I understand, but most likely when you implement the two it would defer down to other functions that had been implemented for both

[Nir]

in this example, maxByOrNull is already implemented in terms of both sequence or iterable

[Nir]

so you would write your function constrained to either sequence or iterable, with a single implementation which just calls maxByOrNull, which gets dispatched correctly based on which constraint is met

[Nir]

I've experienced this before; there's lots of useful functions you can write where the implementation for iterable and sequence is the same character by character, because your implementation is just calling down to things like map which are implemented for both (but with the differences you mentioned)

[Nir]

I guess one tricky thing is that you'd maybe want the iterable version to be inline but not the sequence. but if you can live with it not being inline 🤷