data class Point(val x: Int, val y: Int) {
 operator fun plus(other: Point) = Point(x + other.x, y + other.y)
 operator fun plus(value: Int) = "toString: ${Point(x + value, y + value)}"
}

fun main(args: Array) {
 val p1 = Point(1, 2)
 val p2 = Point(3, 4)
 println(p1 + p2)
 println(p1 + 3)
}

/*
Point(x=4, y=6)
toString: Point(x=4, y=5)
*/

// 第一个文件：
package package0
operator fun Point.times(value: Int) = Point(x * value, y * value)
// 第二个文件：
package package1
operator fun Point.times(value: Int) = Unit // Do nothing.
// 使用第一个扩展操作符：
import package0.times
val newPoint = Point(1, 2) * 3

data class Size(var width: Int = 0, var height: Int = 0) {
 operator fun plus(other: Size): Size {
 return Size(width + other.width, height + other.height)
 }
 operator fun plusAssign(other: Size) {
 width += other.width
 height += other.height
 }
}

fun main(args: Array) {
// var s1 = Size(1, 2) // 如果这么写，执行 += 时会报错.
 val s1 = Size(1, 2)
 val s2 = Size(3, 4)
 s1 += s2
}

fun main(args: Array) {
 val list = arrayListOf(1, 2)
 list += 3 // 添加元素到自身集合, 没有新的对象被创建, 调用的是 add 方法.
 val newList = list + 4 // 创建一个新的 ArrayList, 添加自身元素和新元素并返回新的 ArrayList.
}

println("hello" in arrayListOf("hello", ", ", "world"))
/*
true
*/

/**
 * A range of values of type `Int`.
 */
public class IntRange(start: Int, endInclusive: Int) : IntProgression(start, endInclusive, 1), ClosedRange {
 override val start: Int get() = first
 override val endInclusive: Int get() = last
 override fun contains(value: Int): Boolean = first <= value && value <= last
 override fun isEmpty(): Boolean = first > last
 override fun equals(other: Any?): Boolean =
 other is IntRange && (isEmpty() && other.isEmpty() ||
 first == other.first && last == other.last)
 override fun hashCode(): Int =
 if (isEmpty()) -1 else (31 * first + last)
 override fun toString(): String = "$first..$last"
 companion object {
 /** An empty range of values of type Int. */
 public val EMPTY: IntRange = IntRange(1, 0)
 }
}

for (index in 1..10) {
 // 遍历 1 到 10, 包括 1 和 10.
}

/**
 * Creates a range from this [Comparable] value to the specified [that] value.
 *
 * This value needs to be smaller than [that] value, otherwise the returned range will be empty.
 * @sample samples.ranges.Ranges.rangeFromComparable
 */
public operator fun > T.rangeTo(that: T): ClosedRange = ComparableRange(this, that)

fun main(args: Array) {
 val c1 = Calendar.getInstance() // 代表今天.
 val c2 = Calendar.getInstance() 
 c2.add(Calendar.DATE, 10) // 代表 10 天后.
 val c3 = Calendar.getInstance()
 c3.add(Calendar.DATE, 3) // 代表 3 天后.
 val c4 = Calendar.getInstance()
 c4.add(Calendar.DATE, 13) // 代表 13 天后.
 
 // 判断某日期是否在某两个日期范围内.
 println(c3 in c1..c2)
 println(c4 in c1..c2)
}
/*
true
false
*/

data class Point(val x: Int, val y: Int)
operator fun Point.unaryMinus() = Point(-x, -y)
val point = Point(10, 20)
println(-point)
/*
Point(x=-10, y=-20)
*/

@Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
operator fun  SharedPreferences.get(key: String, defValue: T) = when (defValue) {
 is String -> getString(key, defValue)
 is Int -> getInt(key, defValue)
 is Long -> getLong(key, defValue)
 is Float -> getFloat(key, defValue)
 is Boolean -> getBoolean(key, defValue)
 else -> throw RuntimeException()
} as T

@SuppressLint("CommitPrefEdits")
operator fun  SharedPreferences.set(key: String, value: T) = with(edit()) {
 when (value) {
 is String -> putString(key, value)
 is Int -> putInt(key, value)
 is Long -> putLong(key, value)
 is Float -> putFloat(key, value)
 is Boolean -> putBoolean(key, value)
 else -> throw RuntimeException()
 }.apply()
}

fun main(args: Array) {
 val version = sp["key_version", 47] // 读 sp.
 sp["key_version"] = 48 // 写 sp.
}

data class Movie(val name: String, val score: Int, val date: Date, val other: Any = Any()) : Comparable {
 override fun compareTo(other: Movie): Int {
  return compareValuesBy(this, other, Movie::score, Movie::date, Movie::name) // 如果将 Movie::other 也用作比较会报错, 因为 other 不是 Comparable 类型的。
 }
}

fun main(args: Array) {
 val df = SimpleDateFormat("yyyy-MM-dd", Locale.getDefault())
 val movie0 = Movie("马戏之王", 8, df.parse("2018-01-31"))
 val movie1 = Movie("神秘巨星", 7, df.parse("2018-01-01"))
 val movie2 = Movie("移动迷宫", 7, df.parse("2018-01-02"))
 println(movie0 < movie1)
 println(movie1 < movie2)
}
/*
false
true
*/

/**
 * Compares two values using the specified functions [selectors] to calculate the result of the comparison.
 * The functions are called sequentially, receive the given values [a] and [b] and return [Comparable]
 * objects. As soon as the [Comparable] instances returned by a function for [a] and [b] values do not
 * compare as equal, the result of that comparison is returned.
 *
 * @sample samples.comparisons.Comparisons.compareValuesByWithSelectors
 */
public fun  compareValuesBy(a: T, b: T, vararg selectors: (T) -> Comparable<*>?): Int {
 require(selectors.size > 0)
 return compareValuesByImpl(a, b, selectors)
}

private fun  compareValuesByImpl(a: T, b: T, selectors: ArrayComparable<*>?>): Int {
 for (fn in selectors) {
  val v1 = fn(a)
  val v2 = fn(b)
  val diff = compareValues(v1, v2)
  if (diff != 0) return diff
 }
 return 0
}

class Delegate {
  operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
    //...
  }
  operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
    //...
  }
}