c

README.md

@@ -12,7 +12,7 @@ repositories {
 }
 
 dependencies {
-    implementation("me.alex_s168:blitz:0.22h2")
+    implementation("me.alex_s168:blitz:0.23")
 }
 ```
 

build.gradle.kts

@@ -5,7 +5,7 @@ plugins {
 }
 
 group = "me.alex_s168"
-version = "0.22h2"
+version = "0.23"
 
 repositories {
     mavenCentral()

src/main/kotlin/blitz/collections/ByteVec.kt

@@ -135,6 +135,9 @@ class ByteVec(private val initCap: Int = 0): Vec<Byte>, ByteBatchSequence {
         array[index] = value
     }
 
+    override fun idx(value: Byte): Int =
+        array.indexOf(value)
+
     companion object {
         fun from(bytes: ByteArray) =
             ByteVec(bytes.size).also {

src/main/kotlin/blitz/collections/CharVec.kt

@@ -135,6 +135,9 @@ class CharVec(private val initCap: Int = 0): Vec<Char>, BatchSequence<Char> {
         array[index] = value
     }
 
+    override fun idx(value: Char): Int =
+        array.indexOf(value)
+
     companion object {
         fun from(data: String) =
             CharVec(data.length).also {

src/main/kotlin/blitz/collections/IntVec.kt

@@ -132,6 +132,9 @@ class IntVec(private val initCap: Int = 0): Vec<Int>, BatchSequence<Int> {
         array[index] = value
     }
 
+    override fun idx(value: Int): Int =
+        array.indexOf(value)
+
     companion object {
         fun from(bytes: IntArray) =
             IntVec(bytes.size).also {

src/main/kotlin/blitz/collections/LightCache.kt

@@ -0,0 +1,51 @@
+package blitz.collections
+
+class LightCache<K: Any, V>(
+    private val keys: Vec<K>,
+    private val vals: Vec<V>,
+) {
+    private var lastKey: K? = null
+    private var lastVal: V? = null
+
+    @Suppress("UNCHECKED_CAST")
+    fun getOrPut(key: K, compute: (K) -> V): V {
+        if (key == lastKey)
+            return (lastVal as V)
+        val idx = keys.indexOf(key)
+        val v = if (idx >= 0) {
+            vals[idx]
+        } else {
+            val x = compute(key)
+            keys.pushBack(key)
+            vals.pushBack(x)
+            x
+        }
+        lastKey = key
+        lastVal = v
+        return v
+    }
+
+    internal fun getOrNullInternal(key: K): V? {
+        if (key == lastKey)
+            return lastVal
+        val idx = keys.indexOf(key)
+        return if (idx >= 0) {
+            lastKey = key
+            lastVal = vals[idx]
+            lastVal
+        } else {
+            null
+        }
+    }
+
+    companion object {
+        inline fun <reified K: Any, reified V> new(initCap: Int = 0): LightCache<K, V> =
+            LightCache(
+                SmartVec<K>(initCap),
+                SmartVec<V>(initCap),
+            )
+    }
+}
+
+fun <K: Any, V: Any> LightCache<K, V>.getOrNull(key: K): V? =
+    getOrNullInternal(key)

src/main/kotlin/blitz/collections/LongVec.kt

@@ -132,6 +132,9 @@ class LongVec(private val initCap: Int = 0): Vec<Long>, BatchSequence<Long> {
         array[index] = value
     }
 
+    override fun idx(value: Long): Int =
+        array.indexOf(value)
+
     companion object {
         fun from(bytes: LongArray) =
             LongVec(bytes.size).also {

src/main/kotlin/blitz/collections/RefVec.kt

@@ -101,6 +101,9 @@ class RefVec<T>(private val initCap: Int = 0): Vec<T> {
     inline fun <R> map(fn: (T) -> R): MutableList<R> =
         MutableList(size) { fn(this[it]) }
 
+    override fun idx(value: T): Int =
+        _array?.indexOf(value) ?: -1
+
     companion object {
         fun <T> from(data: Array<T>) =
             RefVec<T>(data.size).also {

src/main/kotlin/blitz/collections/SequenceOps.kt

@@ -42,3 +42,38 @@ fun <T> Sequence<T>.limit(len: Int): Sequence<T> =
 
 fun <A, B> IndexableSequence<A>.limitBy(other: Sequence<B>): IndexableSequence<A> =
     modifier { it.limitBy(other) }
+
+fun <T> Sequence<T>.hasLeast(n: Int): Boolean {
+    val i = iterator()
+    repeat(n) {
+        if (!i.hasNext())
+            return false
+        i.next()
+    }
+    return true
+}
+
+/** cache already computed values across iterations */
+fun <T> Sequence<T>.caching(): Sequence<T> =
+    object : Sequence<T> {
+        val cache = RefVec<T>()
+        val iter = this@caching.iterator()
+
+        override fun iterator() = object : Iterator<T> {
+            var idx = 0
+
+            override fun hasNext(): Boolean =
+                idx < cache.size || iter.hasNext()
+
+            override fun next(): T {
+                val v = if (idx < cache.size) {
+                    cache[idx]
+                } else {
+                    iter.next()
+                        .also(cache::pushBack)
+                }
+                idx ++
+                return v
+            }
+        }
+    }

src/main/kotlin/blitz/collections/ShortVec.kt

@@ -132,6 +132,9 @@ class ShortVec(private val initCap: Int = 0): Vec<Short>, BatchSequence<Short> {
         array[index] = value
     }
 
+    override fun idx(value: Short): Int =
+        array.indexOf(value)
+
     companion object {
         fun from(bytes: ShortArray) =
             ShortVec(bytes.size).also {

src/main/kotlin/blitz/collections/Vec.kt

@@ -37,4 +37,12 @@ interface Vec<T>: IndexableSequence<T> {
     operator fun set(index: Int, value: T)
 
     fun clear()
+
+    fun idx(value: T): Int {
+        for (i in 0 until size) {
+            if (this[i] == value)
+                return i
+        }
+        return -1
+    }
 }