Ranges Reloaded

Evgeny Gerashchenko

In Kotlin M5 we have redesigned our ranges a little bit.

Range expressions are formed with rangeTo functions that have the operator form of .. which are complemented by in and !in. Range is defined for any comparable type (subclass of Comparable), but for number primitives it is optimized. Here are examples of using ranges:

if (i in 1..10) { // equivalent of 1 <= i && i <= 10
  println(i)
} 

if (x !in 1.0..3.0) println(x) 

if (str in "island".."isle") println(str)
// equivalent of "island" <= str && str <= "isle"

Numerical ranges have extra feature: they can be iterated over. Compiler takes care about converting this in simple analogue of Java’s indexed for-loop, without extra overhead. Examples:

for (i in 1..4) print(i) // prints "1234"  

for (i in 4..1) print(i) // prints nothing 

for (x in 1.0..2.0) print("$x ") // prints "1.0 2.0 "

What if you want to iterate over numbers in reversed order? It’s simple. You can use downTo() function defined in standard library:

for (i in 4 downTo 1) print(i) // prints "4321"

Is it possible to iterate over numbers with arbitrary step, not equal to 1? Sure, step() function will help you:

for (i in 1..4 step 2) print(i) // prints "13"  

for (i in 4 downTo 1 step 2) print(i) // prints "42"  

for (i in 1.0..2.0 step 0.3) print("$x ") // prints "1.0 1.3 1.6 1.9 "

How it works

There are two traits in the library: Range<T> and Progression<N>.

Range<T> denotes an interval in the mathematical sense, defined for comparable types. It has two endpoints: start and end, which are included in the range. Main operation is contains(), usually used in the form of in/!in operators.

Progression<N> denotes arithmetic progression, defined for number types. It has start, end and non-zero increment. Progression<N> is a subtype of Iterable<N>, so it can be used in for-loops and functions like map, filter, etc. First element is start, every next element equals previous plus increment. Iteration over Progression is equivalent to an indexed for-loop in Java/JavaScript:

// if increment > 0
for (int i = start; i <= end; i += increment) {
  // ...
}

// if increment < 0 
for (int i = start; i >= end; i += increment) {
  // ...
}

For numbers, the “..” operator creates an object which is both Range and Progression. Result of downTo() and step() functions is always a Progression.

Subscribe to Kotlin Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!