# Ranges

Range expressions are formed with `rangeTo`

functions that have the operator form `..`

which is complemented by *in* and *!in*.
Range is defined for any comparable type, but for integral primitive types it has an optimized implementation. Here are some examples of using ranges:

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

Integral type ranges (`IntRange`

, `LongRange`

, `CharRange`

) have an extra feature: they can be iterated over.
The compiler takes care of converting this analogously to Java's indexed *for*-loop, without extra overhead:

```
fun main(args: Array<String>) {
//sampleStart
for (i in 1..4) print(i)
for (i in 4..1) print(i)
//sampleEnd
}
```

What if you want to iterate over numbers in reverse order? It's simple. You can use the `downTo()`

function defined in the standard library:

```
fun main(args: Array<String>) {
//sampleStart
for (i in 4 downTo 1) print(i)
//sampleEnd
}
```

Is it possible to iterate over numbers with arbitrary step, not equal to 1? Sure, the `step()`

function will help you:

```
fun main(args: Array<String>) {
//sampleStart
for (i in 1..4 step 2) print(i)
for (i in 4 downTo 1 step 2) print(i)
//sampleEnd
}
```

To create a range which does not include its end element, you can use the `until`

function:

```
fun main(args: Array<String>) {
//sampleStart
for (i in 1 until 10) {
// i in [1, 10), 10 is excluded
println(i)
}
//sampleEnd
}
```

## How it works

Ranges implement a common interface in the library: `ClosedRange<T>`

.

`ClosedRange<T>`

denotes a closed interval in the mathematical sense, defined for comparable types.
It has two endpoints: `start`

and `endInclusive`

, which are included in the range.
The main operation is `contains`

, usually used in the form of *in*/*!in* operators.

Integral type progressions (`IntProgression`

, `LongProgression`

, `CharProgression`

) denote an arithmetic progression.
Progressions are defined by the `first`

element, the `last`

element and a non-zero `step`

.
The first element is `first`

, subsequent elements are the previous element plus `step`

. The `last`

element is always hit by iteration unless the progression is empty.

A progression is a subtype of `Iterable<N>`

, where `N`

is `Int`

, `Long`

or `Char`

respectively, so it can be used in *for*-loops and functions like `map`

, `filter`

, etc.
Iteration over `Progression`

is equivalent to an indexed *for*-loop in Java/JavaScript:

```
for (int i = first; i != last; i += step) {
// ...
}
```

For integral types, the `..`

operator creates an object which implements both `ClosedRange<T>`

and `*Progression`

.
For example, `IntRange`

implements `ClosedRange<Int>`

and extends `IntProgression`

, thus all operations defined for `IntProgression`

are available for `IntRange`

as well.
The result of the `downTo()`

and `step()`

functions is always a `*Progression`

.

Progressions are constructed with the `fromClosedRange`

function defined in their companion objects:

```
IntProgression.fromClosedRange(start, end, step)
```

The `last`

element of the progression is calculated to find maximum value not greater than the `end`

value for positive `step`

or minimum value not less than the `end`

value for negative `step`

such that `(last - first) % step == 0`

.

## Utility functions

`rangeTo()`

The `rangeTo()`

operators on integral types simply call the constructors of `*Range`

classes, e.g.:

```
class Int {
//...
operator fun rangeTo(other: Long): LongRange = LongRange(this, other)
//...
operator fun rangeTo(other: Int): IntRange = IntRange(this, other)
//...
}
```

Floating point numbers (`Double`

, `Float`

) do not define their `rangeTo`

operator, and the one provided by the standard library for generic `Comparable`

types is used instead:

```
public operator fun <T: Comparable<T>> T.rangeTo(that: T): ClosedRange<T>
```

The range returned by this function cannot be used for iteration.

`downTo()`

The `downTo()`

extension function is defined for any pair of integral types, here are two examples:

```
fun Long.downTo(other: Int): LongProgression {
return LongProgression.fromClosedRange(this, other.toLong(), -1L)
}
fun Byte.downTo(other: Int): IntProgression {
return IntProgression.fromClosedRange(this.toInt(), other, -1)
}
```

`reversed()`

The `reversed()`

extension functions are defined for each `*Progression`

classes, and all of them return reversed progressions:

```
fun IntProgression.reversed(): IntProgression {
return IntProgression.fromClosedRange(last, first, -step)
}
```

`step()`

`step()`

extension functions are defined for `*Progression`

classes,
all of them return progressions with modified `step`

values (function parameter).
The step value is required to be always positive, therefore this function never changes the direction of iteration:

```
fun IntProgression.step(step: Int): IntProgression {
if (step <= 0) throw IllegalArgumentException("Step must be positive, was: $step")
return IntProgression.fromClosedRange(first, last, if (this.step > 0) step else -step)
}
fun CharProgression.step(step: Int): CharProgression {
if (step <= 0) throw IllegalArgumentException("Step must be positive, was: $step")
return CharProgression.fromClosedRange(first, last, if (this.step > 0) step else -step)
}
```

Note that the `last`

value of the returned progression may become different from the `last`

value of the original progression in order to preserve the invariant `(last - first) % step == 0`

. Here is an example:

```
(1..12 step 2).last == 11 // progression with values [1, 3, 5, 7, 9, 11]
(1..12 step 3).last == 10 // progression with values [1, 4, 7, 10]
(1..12 step 4).last == 9 // progression with values [1, 5, 9]
```