扩展

import std.collection.*

main() {

    let arr = [1, 2, 3, 4, 5] 
    arr.forEach { it => println(it) }
    arr.forEach { i, it => println("${i}: -> ${it}") }
    arr.map { it => it * 2 } |> println
    arr.filter { it => it % 2 == 0 } |> println
    arr.every { it => it % 2 == 0 } |> println
    arr.some { it => it % 2 == 0 } |> println
    arr.reduce(10) { prev, next => prev + next } |> println
    "Hello".toArray().forEach { it => println(Rune(it)) }
    times(5) { i => unless(i % 2 != 0) { println(i) } }
}

/**
 * 为Array类扩展一系列函数，以支持各种数组操作
 */
extend<T> Array<T> {
    /**
     * 遍历数组并执行给定的操作
     *
     * @param f 一个接受数组元素并返回Unit的操作函数
     */
    public func forEach(f: (T) -> Unit): Unit {
        for (i in 0..this.size) {
            f(this[i])
        }
    }

    /**
     * 遍历数组并执行给定的操作，操作函数接收元素的索引和值
     *
     * @param f 一个接受索引和数组元素并返回Unit的操作函数
     */
    public func forEach(f: (Int, T) -> Unit): Unit {
        for (i in 0..this.size) {
            f(i, this[i])
        }
    }

    /**
     * 映射数组中的每个元素到新数组
     *
     * @param f 一个接受数组元素并返回新值的映射函数
     * @return 一个新的数组，包含映射后的元素
     */
    public func map(f: (T) -> T): Array<T> {
        var list = ArrayList<T>()
        for (i in 0..this.size) {
            f(this[i]) |> list.add
        }
        list.toArray()
    }

    /**
     * 过滤数组中的元素，只保留满足条件的元素
     *
     * @param f 一个接受数组元素并返回Bool的过滤函数
     * @return 一个新的数组，包含满足过滤条件的元素
     */
    public func filter(f: (T) -> Bool): Array<T> {
        var list = ArrayList<T>()
        for (i in 0..this.size) {
            if (f(this[i])) {
                this[i] |> list.add
            }
        }
        list.toArray()
    }

    /**
     * 检查数组中的所有元素是否满足条件
     *
     * @param f 一个接受数组元素并返回Bool的检查函数
     * @return 如果所有元素都满足条件则返回true，否则返回false
     */
    public func every(f: (T) -> Bool): Bool {
        for (i in 0..this.size) {
            if (!f(this[i])) {
                return false
            }
        }
        true
    }

    /**
     * 检查数组中是否存在满足条件的元素
     *
     * @param f 一个接受数组元素并返回Bool的检查函数
     * @return 如果存在满足条件的元素则返回true，否则返回false
     */
    public func some(f: (T) -> Bool): Bool {
        for (i in 0..this.size) {
            if (f(this[i])) {
                return true
            }
        }
        false
    }

    /**
     * 对数组中的元素执行归约操作
     *
     * @param f 一个接受两个数组元素并返回一个元素的归约函数
     * @return 归约操作的结果
     */
    public func reduce(f: (T, T) -> T): T {
        var result = this[0]
        for (i in 1..this.size) {
            result = f(result, this[i])
        }
        result
    }

    /**
     * 对数组中的元素执行归约操作，初始值为给定的值
     *
     * @param v 归约操作的初始值
     * @param f 一个接受两个数组元素并返回一个元素的归约函数
     * @return 归约操作的结果
     */
    public func reduce(v: T, f: (T, T) -> T): T {
        var result = v
        for (i in 0..this.size) {
            result = f(result, this[i])
        }
        result
    }
}

func times(n: Int64, f: (Int64) -> Unit): Unit {
    for (i in 0..n) { f(i) }
}

func unless(p: Bool, f: () -> Unit): Unit {
    if (!p) { f() }
}