Still, I personally don't find the range syntax more readable than times or even *, and ranges actually can be slightly error-prone. For example, the innocent looking for(i in 0..n-1) might loop Int.MAX_VALUE times (instead of being silently ignored) if n happens to be Int.MIN_VALUE. Needless to say, for(i in 1..n) can be less useful in the 0-indexed Java world, as you may have to subtract 1 manually from each value. And using a while loop is usually too verbose if you just want to repeat an action n times.

This "library" might seem like a joke, but - to be honest - I personally find it a decent alternative to numeric ranges, which is both easy to read and pretty useful for all kinds of debugging and testing stuff when all you want is to set up a simple loop as quickly as possible. And I didn't want to ship it with a complete complex utility library. Sue me.

Equivalents

var i = 0
while(i < n) {
  // Do something.
  i++
}

Too verbose. Next.

var i = -1
while(++i < n) {
  // Do something.
}

Not even trying.

for(i in 0..n-1) {
  // Do something.
}

"Crashes" on Int.MIN_VALUE - other than that, this seems to be a sensible way to set it up.

for(i in 1..n) {
  val index = i - 1
  // Do something.
}

Awkward if you need iteration indexes to start with 0.

for(i in 0 until n) {
  // Do something.
}

Verbose. Ish.

(0..n-1).forEach { i ->
  // Do something.
}

(0 until n).forEach { i ->
  // Do something.
}

This might be my personal favorite, but it still seems more verbose than necessary.

inline operator fun IntRange.invoke(action: (Int) -> Unit) {
  for (i in this) action(i)
}

// Given the operator extension, you can do this:
(0..n-1) { i ->
  // Do something. 
}

I pity maintainers of your code if you do this, but I have got to admit it looks unsettlingly tempting.

repeat(n) { i ->
  // Do something.
}

...Um, wait, is this library actually necessary?

How do I include this beauty in my project?

Easily - its already on Maven Central.

Maven

<dependency>
  <groupId>com.github.czyzbygroupId>
  <artifactId>kotlin-timesartifactId>
  <version>1.0version>
dependency>

Gradle

compile 'com.github.czyzby:kotlin-times:1.0'

compile group: 'com.github.czyzby', name: 'kotlin-times', version: '1.0'

Working with the sources

Since this library consists of a single Kotlin file, you can just copy the extension methods to your application and modify them however you like. You can also clone this repository and use Gradle to set up this project, if you really want to.

The code is dedicated to public domain, so feel free to do anything. Just so you know.

Variations

If you're feeling brave, try refactoring times to something like x for this awkwardly short syntax without overloaded operators: 8 x { println("Will work just fine.") }. Life is a sandbox.

The future

Our experts are currently working on extension methods for other numeric types. Hopefully, if the project is not aborted by then, the official 2.0 version will be released in 2042.

Contribution

If you do not think that kotlin-times is perfect in every way for some reason, you can create an issue or open a pull request. Thanks in advance.