Add Foldable and Traversable instanced for most common classes

katz/src/main/kotlin/katz/data/Cokleisli.kt

@@ -7,6 +7,9 @@ typealias CokleisiFun<F, A, B> = (HK<F, A>) -> B
 
 typealias CoreaderT<F, A, B> = Cokleisli<F, A, B>
 
+fun <F, A, B> CokleisiTKind<F, A, B>.ev(): Cokleisli<F, A, B> =
+        this as Cokleisli<F, A, B>
+
 data class Cokleisli<F, A, B>(val MM: Comonad<F>, val run: CokleisiFun<F, A, B>) : CokleisiTKind<F, A, B> {
     class F private constructor()
 
@@ -46,5 +49,3 @@ data class Cokleisli<F, A, B>(val MM: Comonad<F>, val run: CokleisiFun<F, A, B>)
                 Cokleisli(MF, { MF.extract(it) })
     }
 }
-
-fun <F, A, B> CokleisiTKind<F, A, B>.ev(): Cokleisli<F, A, B> = this as Cokleisli<F, A, B>

katz/src/main/kotlin/katz/data/Coproduct.kt

@@ -4,15 +4,15 @@ typealias CoproductF<F> = HK<Coproduct.F, F>
 typealias CoproductFG<F, G> = HK2<Coproduct.F, F, G>
 typealias CoproductKind<F, G, A> = HK3<Coproduct.F, F, G, A>
 
-fun <F, G, A> CoproductKind<F, G, A>.ev(): Coproduct<F, G, A> = this as Coproduct<F, G, A>
+fun <F, G, A> CoproductKind<F, G, A>.ev(): Coproduct<F, G, A> =
+        this as Coproduct<F, G, A>
 
 data class Coproduct<F, G, A>(val CF: Comonad<F>, val CG: Comonad<G>, val run: Either<HK<F, A>, HK<G, A>>) : CoproductKind<F, G, A> {
 
     class F private constructor()
 
-    fun <B> map(f: (A) -> B): Coproduct<F, G, B> {
-        return Coproduct(CF, CG, run.bimap(CF.lift(f), CG.lift(f)))
-    }
+    fun <B> map(f: (A) -> B): Coproduct<F, G, B> =
+            Coproduct(CF, CG, run.bimap(CF.lift(f), CG.lift(f)))
 
     fun <B> coflatMap(f: (Coproduct<F, G, A>) -> B): Coproduct<F, G, B> =
             Coproduct(CF, CG, run.bimap(
@@ -26,8 +26,21 @@ data class Coproduct<F, G, A>(val CF: Comonad<F>, val CG: Comonad<G>, val run: E
     fun <H> fold(f: FunctionK<F, H>, g: FunctionK<G, H>): HK<H, A> =
             run.fold({ f(it) }, { g(it) })
 
+    fun <B> foldL(b: B, f: (B, A) -> B, FF: Foldable<F>, FG: Foldable<G>): B =
+            run.fold({ FF.foldL(it, b, f) }, { FG.foldL(it, b, f) })
+
+    fun <B> foldR(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>, FF: Foldable<F>, FG: Foldable<G>): Eval<B> =
+            run.fold({ FF.foldR(it, lb, f) }, { FG.foldR(it, lb, f) })
+
+    fun <H, B> traverse(f: (A) -> HK<H, B>, GA: Applicative<H>, FT: Traverse<F>, GT: Traverse<G>): HK<H, Coproduct<F, G, B>> =
+        run.fold({
+            GA.map(FT.traverse(it, f, GA), { Coproduct(CF, CG, Either.Left(it)) })
+        }, {
+            GA.map(GT.traverse(it, f, GA), { Coproduct(CF, CG, Either.Right(it)) })
+        })
+
     companion object {
-        inline operator fun <reified F, reified G, A> invoke(run: Either<HK<F, A>, HK<G, A>>, CF: Comonad<F> = comonad<F>(), CG: Comonad<G> = comonad<G>()) =
+        inline operator fun <reified F, reified G, A> invoke(run: Either<HK<F, A>, HK<G, A>>, CF: Comonad<F> = comonad<F>(), CG: Comonad<G> = comonad<G>()): Coproduct<F, G, A> =
                 Coproduct(CF, CG, run)
     }
 

katz/src/main/kotlin/katz/data/Coreader.kt

@@ -1,13 +1,18 @@
 package katz
 
-fun <A, B> ((A) -> B).coreader(): CoreaderT<Id.F, A, B> = Coreader(this)
+fun <A, B> ((A) -> B).coreader(): CoreaderT<Id.F, A, B> =
+        Coreader(this)
 
-fun <A, B> CoreaderT<Id.F, A, B>.runId(d: A): B = this.run(Id(d))
+fun <A, B> CoreaderT<Id.F, A, B>.runId(d: A): B =
+        this.run(Id(d))
 
 object Coreader {
-    operator fun <A, B> invoke(run: (A) -> B): CoreaderT<Id.F, A, B> = Cokleisli({ a: IdKind<A> -> run(a.ev().value) })
+    operator fun <A, B> invoke(run: (A) -> B): CoreaderT<Id.F, A, B> =
+            Cokleisli({ a: IdKind<A> -> run(a.ev().value) })
 
-    fun <A, B> pure(x: B): CoreaderT<Id.F, A, B> = Cokleisli.pure<Id.F, A, B>(x)
+    fun <A, B> pure(x: B): CoreaderT<Id.F, A, B> =
+            Cokleisli.pure<Id.F, A, B>(x)
 
-    fun <B> ask(): CoreaderT<Id.F, B, B> = Cokleisli.ask<Id.F, B>()
+    fun <B> ask(): CoreaderT<Id.F, B, B> =
+            Cokleisli.ask<Id.F, B>()
 }

katz/src/main/kotlin/katz/data/Either.kt

@@ -3,6 +3,9 @@ package katz
 typealias EitherKind<A, B> = HK2<Either.F, A, B>
 typealias EitherF<L> = HK<Either.F, L>
 
+fun <A, B> EitherKind<A, B>.ev(): Either<A, B> =
+        this as Either<A, B>
+
 /**
  * Port of https://github.com/scala/scala/blob/v2.12.1/src/library/scala/util/Either.scala
  *

katz/src/main/kotlin/katz/data/EitherT.kt

@@ -3,6 +3,9 @@ package katz
 typealias EitherTKind<F, A, B> = HK3<EitherT.F, F, A, B>
 typealias EitherTF<F, L> = HK2<EitherT.F, F, L>
 
+fun <F, A, B> EitherTKind<F, A, B>.ev(): EitherT<F, A, B> =
+        this as EitherT<F, A, B>
+
 /**
  * [EitherT]`<F, A, B>` is a light wrapper on an `F<`[Either]`<A, B>>` with some
  * convenient methods for working with this nested structure.
@@ -15,15 +18,20 @@ data class EitherT<F, A, B>(val MF: Monad<F>, val value: HK<F, Either<A, B>>) :
 
     companion object {
 
-        inline operator fun <reified F, A, B> invoke(value: HK<F, Either<A, B>>, MF: Monad<F> = monad<F>()): EitherT<F, A, B> = EitherT(MF, value)
+        inline operator fun <reified F, A, B> invoke(value: HK<F, Either<A, B>>, MF: Monad<F> = monad<F>()): EitherT<F, A, B> =
+                EitherT(MF, value)
 
-        @JvmStatic inline fun <reified F, A, B> pure(b: B, MF: Monad<F> = monad<F>()): EitherT<F, A, B> = right(b, MF)
+        @JvmStatic inline fun <reified F, A, B> pure(b: B, MF: Monad<F> = monad<F>()): EitherT<F, A, B> =
+                right(b, MF)
 
-        @JvmStatic inline fun <reified F, A, B> right(b: B, MF: Monad<F> = monad<F>()): EitherT<F, A, B> = EitherT(MF, MF.pure(Either.Right(b)))
+        @JvmStatic inline fun <reified F, A, B> right(b: B, MF: Monad<F> = monad<F>()): EitherT<F, A, B> =
+                EitherT(MF, MF.pure(Either.Right(b)))
 
-        @JvmStatic inline fun <reified F, A, B> left(a: A, MF: Monad<F> = monad<F>()): EitherT<F, A, B> = EitherT(MF, MF.pure(Either.Left(a)))
+        @JvmStatic inline fun <reified F, A, B> left(a: A, MF: Monad<F> = monad<F>()): EitherT<F, A, B> =
+                EitherT(MF, MF.pure(Either.Left(a)))
 
-        @JvmStatic inline fun <reified F, A, B> fromEither(value: Either<A, B>, MF: Monad<F> = monad<F>()): EitherT<F, A, B> = EitherT(MF, MF.pure(value))
+        @JvmStatic inline fun <reified F, A, B> fromEither(value: Either<A, B>, MF: Monad<F> = monad<F>()): EitherT<F, A, B> =
+                EitherT(MF, MF.pure(value))
     }
 
     inline fun <C> fold(crossinline l: (A) -> C, crossinline r: (B) -> C): HK<F, C> =
@@ -59,4 +67,14 @@ data class EitherT<F, A, B>(val MF: Monad<F>, val value: HK<F, Either<A, B>>) :
     fun toOptionT(): OptionT<F, B> =
             OptionT(MF, MF.map(value, { it.toOption() }))
 
+    fun <C> foldL(b: C, f: (C, B) -> C, FF: Foldable<F>): C =
+            FF.compose(EitherTraverse<A>()).foldLC(value, b, f)
+
+    fun <C> foldR(lb: Eval<C>, f: (B, Eval<C>) -> Eval<C>, FF: Foldable<F>): Eval<C> =
+            FF.compose(EitherTraverse<A>()).foldRC(value, lb, f)
+
+    fun <G, C> traverse(f: (B) -> HK<G, C>, GA: Applicative<G>, FF: Traverse<F>, MF: Monad<F>): HK<G, HK<EitherTF<F, A>, C>> {
+        val fa = ComposedTraverse(FF, EitherTraverse<A>(), EitherMonad<A>()).traverseC(value, f, GA)
+        return GA.map(fa, { EitherT(MF, MF.map(it.lower(), { it.ev() })) })
+    }
 }

katz/src/main/kotlin/katz/data/Eval.kt

@@ -1,5 +1,8 @@
 package katz
 
+fun <A> HK<Eval.F, A>.ev(): Eval<A> =
+        this as Eval<A>
+
 /**
  * Eval is a monad which controls evaluation of a value or a computation that produces a value.
  *
@@ -205,5 +208,3 @@ sealed class Eval<out A> : HK<Eval.F, A> {
         @JvmStatic val One: Eval<Int> = Now(1)
     }
 }
-
-fun <A> HK<Eval.F, A>.ev(): Eval<A> = this as Eval<A>

katz/src/main/kotlin/katz/data/Id.kt

@@ -2,18 +2,21 @@ package katz
 
 typealias IdKind<A> = HK<Id.F, A>
 
+fun <A> IdKind<A>.ev(): Id<A> = this as Id<A>
+
+fun <A> IdKind<A>.value(): A =
+        this.ev().value
+
 data class Id<out A>(val value: A) : IdKind<A> {
 
     class F private constructor()
 
-    inline fun <B> map(f: (A) -> B): Id<B> = Id(f(value))
+    inline fun <B> map(f: (A) -> B): Id<B> =
+            Id(f(value))
 
-    inline fun <B> flatMap(f: (A) -> Id<B>): Id<B> = f(value)
+    inline fun <B> flatMap(f: (A) -> Id<B>): Id<B> =
+            f(value)
 
     companion object : IdBimonad, GlobalInstance<Bimonad<Id.F>>()
 
 }
-
-fun <A> IdKind<A>.ev(): Id<A> = this as Id<A>
-
-fun <A> IdKind<A>.value(): A = this.ev().value

katz/src/main/kotlin/katz/data/Ior.kt

@@ -2,10 +2,12 @@ package katz
 
 import katz.Either.Left
 import katz.Either.Right
-import katz.Option
 
 typealias IorKind<A, B> = HK2<Ior.F, A, B>
 
+fun <A, B> IorKind<A, B>.ev(): Ior<A, B> =
+        this as Ior<A, B>
+
 /**
  * Port of https://github.com/typelevel/cats/blob/v0.9.0/core/src/main/scala/cats/data/Ior.scala
  *
@@ -268,4 +270,4 @@ inline fun <A, B, D> Ior<A, B>.flatMap(SA: Semigroup<A>, crossinline f: (B) -> I
     }
 }
 
-inline fun <A, B> Ior<A, B>.getOrElse(crossinline default: () -> B): B = fold({ default() }, { it }, { _, b -> b })
+inline fun <A, B> Ior<A, B>.getOrElse(crossinline default: () -> B): B = fold({ default() }, { it }, { _, b -> b })

katz/src/main/kotlin/katz/data/Kleisli.kt

@@ -7,10 +7,14 @@ typealias KleisiFun<F, D, A> = (D) -> HK<F, A>
 
 typealias ReaderT<F, D, A> = Kleisli<F, D, A>
 
+fun <F, D, A> KleisiTKind<F, D, A>.ev(): Kleisli<F, D, A> =
+        this as Kleisli<F, D, A>
+
 class Kleisli<F, D, A>(val MF: Monad<F>, val run: KleisiFun<F, D, A>) : KleisiTKind<F, D, A> {
     class F private constructor()
 
-    fun <B> map(f: (A) -> B): Kleisli<F, D, B> = Kleisli(MF, { a -> MF.map(run(a), f) })
+    fun <B> map(f: (A) -> B): Kleisli<F, D, B> =
+            Kleisli(MF, { a -> MF.map(run(a), f) })
 
     fun <B> flatMap(f: (A) -> Kleisli<F, D, B>): Kleisli<F, D, B> =
             Kleisli(MF, { d ->
@@ -22,7 +26,8 @@ class Kleisli<F, D, A>(val MF: Monad<F>, val run: KleisiFun<F, D, A>) : KleisiTK
                 o.map({ b -> Tuple2(a, b) })
             })
 
-    fun <DD> local(f: (DD) -> D): Kleisli<F, DD, A> = Kleisli(MF, { dd -> run(f(dd)) })
+    fun <DD> local(f: (DD) -> D): Kleisli<F, DD, A> =
+            Kleisli(MF, { dd -> run(f(dd)) })
 
     fun <B> andThen(f: (A) -> HK<F, B>): Kleisli<F, D, B> =
             Kleisli(MF, { MF.flatMap(run(it), f) })
@@ -32,16 +37,17 @@ class Kleisli<F, D, A>(val MF: Monad<F>, val run: KleisiFun<F, D, A>) : KleisiTK
 
     companion object {
 
-        inline operator fun <reified F, D, A> invoke(noinline run: KleisiFun<F, D, A>, MF: Monad<F> = monad<F>()): Kleisli<F, D, A> = Kleisli(MF, run)
+        inline operator fun <reified F, D, A> invoke(noinline run: KleisiFun<F, D, A>, MF: Monad<F> = monad<F>()): Kleisli<F, D, A> =
+                Kleisli(MF, run)
 
-        @JvmStatic inline fun <reified F, D, A> pure(x: A, MF: Monad<F> = monad<F>()): Kleisli<F, D, A> = Kleisli(MF, { _ -> MF.pure(x) })
+        @JvmStatic inline fun <reified F, D, A> pure(x: A, MF: Monad<F> = monad<F>()): Kleisli<F, D, A> =
+                Kleisli(MF, { _ -> MF.pure(x) })
 
-        @JvmStatic inline fun <reified F, D> ask(MF: Monad<F> = monad<F>()): Kleisli<F, D, D> = Kleisli(MF, { MF.pure(it) })
+        @JvmStatic inline fun <reified F, D> ask(MF: Monad<F> = monad<F>()): Kleisli<F, D, D> =
+                Kleisli(MF, { MF.pure(it) })
     }
 
 }
 
 inline fun <reified F, D, A> Kleisli<F, D, Kleisli<F, D, A>>.flatten(): Kleisli<F, D, A> =
         flatMap({ it })
-
-fun <F, D, A> KleisiTKind<F, D, A>.ev(): Kleisli<F, D, A> = this as Kleisli<F, D, A>

katz/src/main/kotlin/katz/data/NonEmptyList.kt

@@ -2,6 +2,9 @@ package katz
 
 typealias NonEmptyListKind<A> = HK<NonEmptyList.F, A>
 
+fun <A> NonEmptyListKind<A>.ev(): NonEmptyList<A> =
+        this as NonEmptyList<A>
+
 /**
  * A List that can not be empty
  */
@@ -17,9 +20,8 @@ class NonEmptyList<out A> private constructor(
 
     val size: Int = all.size
 
-    fun contains(element: @UnsafeVariance A): Boolean {
-        return (head == element).or(tail.contains(element))
-    }
+    fun contains(element: @UnsafeVariance A): Boolean =
+            (head == element).or(tail.contains(element))
 
     fun containsAll(elements: Collection<@UnsafeVariance A>): Boolean =
             elements.all { contains(it) }
@@ -32,11 +34,14 @@ class NonEmptyList<out A> private constructor(
     fun <B> flatMap(f: (A) -> NonEmptyList<B>): NonEmptyList<B> =
             f(head) + tail.flatMap { f(it).all }
 
-    operator fun plus(l: NonEmptyList<@UnsafeVariance A>): NonEmptyList<A> = NonEmptyList(all + l.all)
+    operator fun plus(l: NonEmptyList<@UnsafeVariance A>): NonEmptyList<A> =
+            NonEmptyList(all + l.all)
 
-    operator fun plus(l: List<@UnsafeVariance A>): NonEmptyList<A> = NonEmptyList(all + l)
+    operator fun plus(l: List<@UnsafeVariance A>): NonEmptyList<A> =
+            NonEmptyList(all + l)
 
-    operator fun plus(a: @UnsafeVariance A): NonEmptyList<A> = NonEmptyList(all + a)
+    operator fun plus(a: @UnsafeVariance A): NonEmptyList<A> =
+            NonEmptyList(all + a)
 
     fun iterator(): Iterator<A> = all.iterator()
 

katz/src/main/kotlin/katz/data/Option.kt

@@ -2,6 +2,9 @@ package katz
 
 typealias OptionKind<A> = HK<Option.F, A>
 
+fun <A> OptionKind<A>.ev(): Option<A> =
+        this as Option<A>
+
 /**
  * Port of https://github.com/scala/scala/blob/v2.12.1/src/library/scala/Option.scala
  *
@@ -13,8 +16,11 @@ sealed class Option<out A> : OptionKind<A> {
     class F private constructor()
 
     companion object : OptionMonad, GlobalInstance<Monad<Option.F>>() {
-        @JvmStatic fun <A : Any> fromNullable(a: A?): Option<A> = if (a != null) Option.Some(a) else Option.None
-        operator fun <A> invoke(a: A): Option<A> = Option.Some(a)
+        @JvmStatic fun <A : Any> fromNullable(a: A?): Option<A> =
+                if (a != null) Option.Some(a) else Option.None
+
+        operator fun <A> invoke(a: A): Option<A> =
+                Option.Some(a)
     }
 
     /**