Kotlin Koans Operators Overloading

I wrote a separate project with the following code, and I feel that the program performs as I expected.

Why can't this write through the Kotlin Koans test?

import TimeInterval.*

data class MyDate(val year: Int, val month: Int, val dayOfMonth: Int)

// Supported intervals that might be added to dates:
enum class TimeInterval(var n: Int = 1) {
    DAY, WEEK, YEAR
}

operator fun TimeInterval.times(times: Int): TimeInterval {
    n *= times
    return this
}

operator fun MyDate.plus(timeInterval: TimeInterval): MyDate =
    addTimeIntervals(timeInterval, timeInterval.n)

This does not mean what you think it does:

enum class TimeInterval(var n: Int = 1) {
    DAY, WEEK, YEAR
}

This declares 3 enum constants - DAY, WEEK and YEAR. Each constant has its own n property, initially set to 1. You can think of this as:

data class TimeInterval private constructor(var n: Int = 1) {
    companion object {
        val DAY = TimeInterval()
        val WEEK = TimeInterval()
        val YEAR = TimeInterval()
    }
}

Crucially, there are only 3 instances of TimeInterval, period. You don't get a brand new instance every time you access DAY for example.

Therefore, when you do n *= times, you are changing the value of n for that instance of TimeInterval, and this change persists the next time you use that instance. e.g.

val fiveDays = DAY * 5 // this sets DAY.n to 1 * 5 = 5
val twoDays = DAY * 2 // this sets DAY.n to 5 * 2 = 10
// both of these will print 10!
println(fiveDays.n)
println(twoDays.n)

Therefore, using vars, or anything mutable in enum class' constructors can cause some very confusing behaviours, and is almost never what you want.

Of course, you don't notice this if you don't use any instance of TimeInterval more than once. But the tests on the Koan do use them more than once.

You should use something that composes a TimeInterval and a number. You can use a Pair<TimeInterval, Int>, or better, write a new class, as the hint in the Koan says.