does anyone know if

b in a..c

has the same performance as

a <= b && b <= c

?

I think it gets optimized into the same bytecode

thank you

yes, https://github.com/JetBrains/kotlin/blob/master/compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/InIntegralContinuousRangeExpressionGenerator.kt

oh i see, i would assume it also works for Chars right?

'0'..'9'

https://github.com/JetBrains/kotlin/blob/master/compiler/frontend/src/org/jetbrains/kotlin/types/RangeUtil.kt#L47 yes, char is included in what gets intrinsified

thanks a lot 👍

Now that one was easy to optimize. How about

c in ('a'..'z') + ('A'..'Z') + ('0'..'9')

?

no, that results in a

List<Char>

and

.contains

oh i see. so it's better if you do

c in 'a'..'z' || c in 'A'..'Z'

i suppose?

I'm honestly not sure, and I think this starts to get into preoptimization territory -- for 99% of applications it doesn't matter. In any case, I think you could use

Char.isLetter()

(and pass in a Locale if that really matters to you).

How do we pass in a Locale?

isLetter

has an optional Locale parameter, just pass it in

It doesn't seem to be documented: https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/is-letter.html

Maybe it's in Java's

Character

? idk

If such optimization really matters I would at least encapsulate it in an inline extension