clean up

src/main/kotlin/blitz/func/Combine.kt

@@ -0,0 +1,13 @@
+package blitz.func
+
+fun Sequence<Monad<Unit>>.combine(): Monad<Unit> =
+    Monad { this@combine.forEach { it.impure() } }
+
+fun Iterable<Monad<Unit>>.combineIter(): Monad<Unit> =
+    Monad { this@combineIter.forEach { it.impure() } }
+
+fun Monad<Sequence<Monad<Unit>>>.combine(): Monad<Unit> =
+    Monad { this@combine.impure().forEach { it.impure() } }
+
+fun Monad<Iterable<Monad<Unit>>>.combineIter(): Monad<Unit> =
+    Monad { this@combineIter.impure().forEach { it.impure() } }

src/main/kotlin/blitz/func/Map.kt

@@ -0,0 +1,7 @@
+package blitz.func
+
+fun <T, R> Monad<Iterable<T>>.mapIter(transform: (T) -> R): Monad<Iterable<R>> =
+    bind { it.map { x -> transform(x) } }
+
+fun <T, R> Monad<Sequence<T>>.map(transform: (T) -> R): Monad<Sequence<R>> =
+    bind { it.map { x -> transform(x) } }

src/main/kotlin/blitz/func/Monad.kt

@@ -0,0 +1,14 @@
+package blitz.func
+
+class Monad<O> internal constructor(
+    val impure: () -> O
+)
+
+fun <O> unit(v: O): Monad<O> =
+    Monad { v }
+
+fun unit(): Monad<Unit> =
+    Monad { }
+
+fun <I, O> Monad<I>.bind(op: (I) -> O): Monad<O> =
+    Monad { op(this@bind.impure()) }

src/main/kotlin/blitz/func/Reduce.kt

@@ -0,0 +1,14 @@
+package blitz.func
+
+fun <S, T : S> Monad<Sequence<T>>.reduce(operation: (acc: S, T) -> S): Monad<S> =
+    bind { it.reduce(operation) }
+
+fun <S, T : S> Monad<Iterable<T>>.reduceIter(operation: (acc: S, T) -> S): Monad<S> =
+    bind { it.reduce(operation) }
+
+fun <T> Monad<Sequence<T>>.reduce(each: (T) -> Unit): Monad<Unit> =
+    Monad { this@reduce.impure().forEach { each(it) } }
+
+
+fun <T> Monad<Iterable<T>>.reduceIter(each: (T) -> Unit): Monad<Unit> =
+    Monad { this@reduceIter.impure().forEach { each(it) } }

src/main/kotlin/blitz/func/Rewrap.kt

@@ -0,0 +1,16 @@
+package blitz.func
+
+fun <T> Iterable<Monad<T>>.rewrap(): Monad<Sequence<T>> =
+    Monad {
+        val iter = this@rewrap.iterator()
+        generateSequence {
+            if (iter.hasNext())iter.next().impure()
+            else null
+        }
+    }
+
+fun <T> Sequence<Monad<T>>.rewrap(): Monad<Sequence<T>> =
+    Monad {
+        val iter = this@rewrap.iterator()
+        sequence { if (iter.hasNext()) yield(iter.next().impure()) }
+    }

src/main/kotlin/blitz/func/Utils.kt

@@ -0,0 +1,10 @@
+package blitz.func
+
+import blitz.ByteBatchSequence
+import blitz.stringify
+
+fun <T> Monad<Sequence<Sequence<T>>>.flatten(): Monad<Sequence<T>> =
+    bind { it.flatten() }
+
+fun Monad<ByteBatchSequence>.stringify(batch: Int = 64): Monad<Sequence<String>> =
+    bind { it.stringify(batch) }

src/main/kotlin/blitz/func/io/Console.kt

@@ -0,0 +1,9 @@
+package blitz.func.io
+
+import blitz.func.*
+
+fun Monad<String>.print() =
+    bind { print(it) }
+
+fun readIn() =
+    Monad { generateSequence { readln() } }

src/main/kotlin/blitz/func/io/File.kt

@@ -0,0 +1,13 @@
+package blitz.func.io
+
+import blitz.func.Monad
+import blitz.func.bind
+import blitz.io.readerSequence
+import kotlinx.io.files.Path
+import kotlinx.io.files.SystemFileSystem
+
+fun Monad<String>.asPath() =
+    bind { Path(it) }
+
+fun Monad<Path>.read() =
+    bind { p -> { SystemFileSystem.source(p) }.readerSequence() }