Can anybody explain this piece of code from one of...

# getting-started

[Egor]

Can anybody explain this piece of code from one of the example in the "_The in Keyword_" section from the book " Atomic Kotlin "?

fun main(args: Array<String>) {
  println("ab" in "aa".."az")
  println("ba" in "aa".."az")
}

/* Output:
true
false
*/

I can understand that you can validate the range between 'a'..'z'. I'm just not quite able to grasp the idea of validating 'aa'..'az'

[Shawn]

well, much like a..z would contain b, c, d, e..., aa..az would include ab, ac, ad, ae... and so on up to az

[Dominaezzz]

It is similar to "aa" <= "ab" && "ab" <= "az".

[Dominaezzz]

What he said.

[Egor]

Thx. Now makes sense.

[andym]

I really like this example (stolen from a Jetbrains presentation):

Kotlin falls flatly in the range between between Java and Scala

"kotlin" in "java".."scala"

[Egor]

@andym Thx. very much for the example. It actually got me more confused (but in a good way)
So I've tried to figure out how could this be working behind the scenes, by creating my own function: stringIsIn()
This is how I understand this works. Let me know if I'm wrong.

fun main() {
  var a = "akkotlin"
  var b = "akjava"
  var c = "akscala"
  println(stringIsIn(a,b,c))
}

fun stringIsIn(a: String, b: String, c: String): Boolean {
  for (i in 0..a.lastIndex)
    if (i <= b.lastIndex && i <= c.lastIndex)
      if ((b[i] != c[i] && a[i] == b[i]) || a[i] != b[i] && b[i] != c[i] || a[i] == b[i] && b[i] == c[i])
        return a[i] >= b[i] && a[i] <= c[i]
  return false
}

[Alan Evans]

It's just sorting order.
`String`s are `Comparable`:

fun stringIsIn(a: String, b: String, c: String): Boolean {
        return a.compareTo(b) >= 0 && a.compareTo(c) <= 0
    }

Which the IDE tells you can be:

fun stringIsIn(a: String, b: String, c: String): Boolean {
        return a >= b && a <= c
    }

Which the IDE tells you can be:

fun stringIsIn(a: String, b: String, c: String): Boolean {
        return a in b..c
    }

Which can generically be:

fun <T:Comparable<T>> tIsIn(a: T, b: T, c: T): Boolean {
        return a.compareTo(b) >= 0 && a.compareTo(c) <= 0
    }

Which is also:

fun <T:Comparable<T>> tIsIn(a: T, b: T, c: T): Boolean {
        return a in b..c
    }