lyng/lynglib/stdlib/lyng/root.lyng

package lyng.stdlib

/*
Wrap a builder into a zero-argument thunk that computes once and caches the result.
The first call invokes builder() and stores the value; subsequent calls return the cached value.
*/
fun cached(builder) {
    var calculated = false
    var value = null
    {
        if( !calculated ) {
            value = builder()
            calculated = true
        }
        value
    }
}
/* Filter elements of this iterable using the provided predicate. */
fun Iterable.filter(predicate) {
    val list = this
    flow {
        for( item in list ) {
            if( predicate(item) ) {
                emit(item)
            }
        }
    }
}

/* Skip the first N elements of this iterable. */
fun Iterable.drop(n) {
    var cnt = 0
    filter { cnt++ >= n }
}

/* Return the first element or throw if the iterable is empty. */
fun Iterable.first() {
    val i = iterator()
    if( !i.hasNext() ) throw NoSuchElementException()
        i.next().also { i.cancelIteration() }
}

/*
Return the first element that matches the predicate or throws
NuSuchElementException
*/
fun Iterable.findFirst(predicate) {
    for( x in this ) {
        if( predicate(x) )
            break x
    }
    else throw NoSuchElementException()
}

/*
return the first element matching the predicate or null
*/
fun Iterable.findFirstOrNull(predicate) {
    for( x in this ) {
        if( predicate(x) )
            break x
    }
    else null
}


/* Return the last element or throw if the iterable is empty. */
fun Iterable.last() {
    var found = false
    var element = null
    for( i in this ) {
        element = i
        found = true
    }
    if( !found ) throw NoSuchElementException()
        element
}

/* Emit all but the last N elements of this iterable. */
fun Iterable.dropLast(n) {
    val list = this
    val buffer = RingBuffer(n)
    flow {
        for( item in list ) {
            if( buffer.size == n )
                emit( buffer.first() )
            buffer += item
        }
    }
}

/* Return the last N elements of this iterable as a buffer/list. */
fun Iterable.takeLast(n) {
    val buffer = RingBuffer(n)
    for( item in this ) buffer += item
    buffer
}

/* Join elements into a string with a separator (separator parameter) and optional transformer. */
fun Iterable.joinToString(separator=" ", transformer=null) {
    var result = null
    for( part in this ) {
        val transformed = transformer?(part)?.toString() ?: part.toString()
        if( result == null ) result = transformed
        else result += separator + transformed
    }
    result ?: ""
}

/* Return true if any element matches the predicate. */
fun Iterable.any(predicate): Bool {
    for( i in this ) {
        if( predicate(i) )
            break true
    } else false
}

/* Return true if all elements match the predicate. */
fun Iterable.all(predicate): Bool {
    !any { !predicate(it) }
}

/* Sum all elements; returns null for empty collections. */
fun Iterable.sum() {
    val i = iterator()
    if( i.hasNext() ) {
        var result = i.next()
        while( i.hasNext() ) result += i.next()
        result
    }
    else null
}

/* Sum mapped values of elements; returns null for empty collections. */
fun Iterable.sumOf(f) {
    val i = iterator()
    if( i.hasNext() ) {
        var result = f(i.next())
        while( i.hasNext() ) result += f(i.next())
        result
    }
    else null
}

/* Minimum value of the given function applied to elements of the collection. */
fun Iterable.minOf( lambda ) {
    val i = iterator()
    var minimum = lambda( i.next() )
    while( i.hasNext() ) {
        val x = lambda(i.next())
        if( x < minimum ) minimum = x
    }
    minimum
}

/* Maximum value of the given function applied to elements of the collection. */
fun Iterable.maxOf( lambda ) {
    val i = iterator()
    var maximum = lambda( i.next() )
    while( i.hasNext() ) {
        val x = lambda(i.next())
        if( x > maximum ) maximum = x
    }
    maximum
}

/* Return elements sorted by natural order. */
fun Iterable.sorted() {
    sortedWith { a, b -> a <=> b }
}

/* Return elements sorted by the key selector. */
fun Iterable.sortedBy(predicate) {
    sortedWith { a, b -> predicate(a) <=> predicate(b) }
}

/* Return a shuffled copy of the iterable as a list. */
fun Iterable.shuffled() {
    toList().apply { shuffle() }
}

/* Return string representation like [a,b,c]. */
fun List.toString() {
    "[" + joinToString(",") + "]"
}

/* Sort list in-place by key selector. */
fun List.sortBy(predicate) {
    sortWith { a, b -> predicate(a) <=> predicate(b) }
}

/* Sort list in-place by natural order. */
fun List.sort() {
    sortWith { a, b -> a <=> b }
}

/* Represents a single stack trace element. */
class StackTraceEntry(
        val sourceName: String,
        val line: Int,
        val column: Int,
        val sourceString: String
) {
    /* Formatted representation: source:line:column: text. */
    fun toString() {
        "%s:%d:%d: %s"(sourceName, line, column, sourceString.trim())
    }
}

/* Print this exception and its stack trace to standard output. */
fun Exception.printStackTrace() {
    println(this)
    var lastEntry = null
    for( entry in stackTrace() ) {
        if( lastEntry == null || lastEntry !is StackTraceEntry || lastEntry.line != entry.line )
            println("\tat "+entry.toString())
        lastEntry = entry
    }
}

/* Compile this string into a regular expression. */
fun String.re(): Regex { Regex(this) }