diff --git a/arrow-core-data/src/main/kotlin/arrow/core/Iterable.kt b/arrow-core-data/src/main/kotlin/arrow/core/Iterable.kt
new file mode 100644
index 000000000..00ee7d28a
--- /dev/null
+++ b/arrow-core-data/src/main/kotlin/arrow/core/Iterable.kt
@@ -0,0 +1,781 @@
+@file:Suppress("unused", "FunctionName")
+
+package arrow.core
+
+import arrow.typeclasses.Eq
+import arrow.typeclasses.Monoid
+import arrow.typeclasses.Semigroup
+import arrow.typeclasses.Show
+import kotlin.collections.foldRight as _foldRight
+
+inline fun <A, B> Iterable<A>.foldRight(initial: B, operation: (A, acc: B) -> B): B =
+  when (this) {
+    is List -> _foldRight(initial, operation)
+    else -> reversed().fold(initial) { acc, a -> operation(a, acc) }
+  }
+
+fun <A, B> Iterable<A>.ap(ff: Iterable<(A) -> B>): List<B> =
+  flatMap { a -> ff.map { f -> f(a) } }
+
+inline fun <E, A, B> Iterable<A>.traverseEither(f: (A) -> Either<E, B>): Either<E, List<B>> =
+  foldRight<A, Either<E, List<B>>>(emptyList<B>().right()) { a, acc ->
+    f(a).ap(acc.map { bs -> { b: B -> listOf(b) + bs } })
+  }
+
+inline fun <E, A, B> Iterable<A>.flatTraverseEither(f: (A) -> Either<E, Iterable<B>>): Either<E, List<B>> =
+  foldRight<A, Either<E, List<B>>>(emptyList<B>().right()) { a, acc ->
+    f(a).ap(acc.map { bs -> { b: Iterable<B> -> b + bs } })
+  }
+
+inline fun <E, A> Iterable<A>.traverseEither_(f: (A) -> Either<E, *>): Either<E, Unit> {
+  val void = { _: Unit -> { _: Any? -> Unit } }
+  return foldRight<A, Either<E, Unit>>(Unit.right()) { a, acc ->
+    f(a).ap(acc.map(void))
+  }
+}
+
+fun <E, A> Iterable<Either<E, A>>.sequenceEither(): Either<E, List<A>> =
+  traverseEither(::identity)
+
+fun <E, A> Iterable<Either<E, Iterable<A>>>.flatSequenceEither(): Either<E, List<A>> =
+  flatTraverseEither(::identity)
+
+fun <E> Iterable<Either<E, *>>.sequenceEither_(): Either<E, Unit> =
+  traverseEither_(::identity)
+
+inline fun <E, A, B> Iterable<A>.traverseValidated(semigroup: Semigroup<E>, f: (A) -> Validated<E, B>): Validated<E, List<B>> =
+  foldRight<A, Validated<E, List<B>>>(emptyList<B>().valid()) { a, acc ->
+    f(a).ap(semigroup, acc.map { bs -> { b: B -> listOf(b) + bs } })
+  }
+
+inline fun <E, A, B> Iterable<A>.flatTraverseValidated(semigroup: Semigroup<E>, f: (A) -> Validated<E, Iterable<B>>): Validated<E, List<B>> =
+  foldRight<A, Validated<E, List<B>>>(emptyList<B>().valid()) { a, acc ->
+    f(a).ap(semigroup, acc.map { bs -> { b: Iterable<B> -> b + bs } })
+  }
+
+inline fun <E, A> Iterable<A>.traverseValidated_(semigroup: Semigroup<E>, f: (A) -> Validated<E, *>): Validated<E, Unit> =
+  foldRight<A, Validated<E, Unit>>(Unit.valid()) { a, acc ->
+    f(a).ap(semigroup, acc.map { { Unit } })
+  }
+
+fun <E, A> Iterable<Validated<E, A>>.sequenceValidated(semigroup: Semigroup<E>): Validated<E, List<A>> =
+  traverseValidated(semigroup, ::identity)
+
+fun <E, A> Iterable<Validated<E, Iterable<A>>>.flatSequenceValidated(semigroup: Semigroup<E>): Validated<E, List<A>> =
+  flatTraverseValidated(semigroup, ::identity)
+
+fun <E> Iterable<Validated<E, *>>.sequenceValidated_(semigroup: Semigroup<E>): Validated<E, Unit> =
+  traverseValidated_(semigroup, ::identity)
+
+inline fun <A, B, Z> Iterable<A>.map2(fb: Iterable<B>, f: (Tuple2<A, B>) -> Z): List<Z> =
+  flatMap { a ->
+    fb.map { b ->
+      f(Tuple2(a, b))
+    }
+  }
+
+fun <A, B> Iterable<A>.mapConst(b: B): List<B> =
+  map { b }
+
+fun <A> Iterable<A>.void(): List<Unit> =
+  mapConst(Unit)
+
+fun <A, B> List<A>.foldRight(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Eval<B> {
+  fun loop(fa_p: List<A>): Eval<B> = when {
+    fa_p.isEmpty() -> lb
+    else -> f(fa_p.first(), Eval.defer { loop(fa_p.drop(1)) })
+  }
+
+  return Eval.defer { loop(this) }
+}
+
+fun <A, B> Iterable<A>.reduceOrNull(initial: (A) -> B, operation: (acc: B, A) -> B): B? {
+  val iterator = this.iterator()
+  if (!iterator.hasNext()) return null
+  var accumulator: B = initial(iterator.next())
+  while (iterator.hasNext()) {
+    accumulator = operation(accumulator, iterator.next())
+  }
+  return accumulator
+}
+
+inline fun <A, B> List<A>.reduceRightEvalOrNull(
+  initial: (A) -> B,
+  operation: (A, acc: Eval<B>) -> Eval<B>
+): Eval<B?> {
+  val iterator = listIterator(size)
+  if (!iterator.hasPrevious()) return Eval.now(null)
+  var accumulator: Eval<B> = Eval.now(initial(iterator.previous()))
+  while (iterator.hasPrevious()) {
+    accumulator = operation(iterator.previous(), accumulator)
+  }
+  return accumulator
+}
+
+inline fun <A, B> List<A>.reduceRightNull(
+  initial: (A) -> B,
+  operation: (A, acc: B) -> B
+): B? {
+  val iterator = listIterator(size)
+  if (!iterator.hasPrevious()) return null
+  var accumulator: B = initial(iterator.previous())
+  while (iterator.hasPrevious()) {
+    accumulator = operation(iterator.previous(), accumulator)
+  }
+  return accumulator
+}
+
+/**
+ * Returns a [List<Tuple2<A?, B?>>] containing the zipped values of the two lists with null for padding.
+ *
+ * Example:
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * //sampleStart
+ * val padRight = listOf(1, 2).padZip(listOf("a"))        // Result: [Tuple2(1, "a"), Tuple2(2, null)]
+ * val padLeft = listOf(1).padZip(listOf("a", "b"))       // Result: [Tuple2(1, "a"), Tuple2(null, "b")]
+ * val noPadding = listOf(1, 2).padZip(listOf("a", "b"))  // Result: [Tuple2(1, "a"), Tuple2(2, "b")]
+ * //sampleEnd
+ *
+ * fun main() {
+ *   println("padRight = $padRight")
+ *   println("padLeft = $padLeft")
+ *   println("noPadding = $noPadding")
+ * }
+ * ```
+ */
+fun <A, B> Iterable<A>.padZip(other: Iterable<B>): List<Tuple2<A?, B?>> =
+  align(other) { ior ->
+    ior.fold(
+      { it toT null },
+      { null toT it },
+      { a, b -> a toT b }
+    )
+  }
+
+/**
+ * Returns a [ListK<C>] containing the result of applying some transformation `(A?, B?) -> C`
+ * on a zip.
+ *
+ * Example:
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * //sampleStart
+ * val padZipRight = listOf(1, 2).padZip(listOf("a")) { l, r -> l toT r }     // Result: [Tuple2(1, "a"), Tuple2(2, null)]
+ * val padZipLeft = listOf(1).padZip(listOf("a", "b")) { l, r -> l toT r }    // Result: [Tuple2(1, "a"), Tuple2(null, "b")]
+ * val noPadding = listOf(1, 2).padZip(listOf("a", "b")) { l, r -> l toT r }  // Result: [Tuple2(1, "a"), Tuple2(2, "b")]
+ * //sampleEnd
+ *
+ * fun main() {
+ *   println("padZipRight = $padZipRight")
+ *   println("padZipLeft = $padZipLeft")
+ *   println("noPadding = $noPadding")
+ * }
+ * ```
+ */
+inline fun <A, B, C> Iterable<A>.padZip(other: Iterable<B>, fa: (A?, B?) -> C): List<C> =
+  padZip(other).map { fa(it.a, it.b) }
+
+/**
+ * Returns a [List<C>] containing the result of applying some transformation `(A?, B) -> C`
+ * on a zip, excluding all cases where the right value is null.
+ *
+ * Example:
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * //sampleStart
+ * val left = listOf(1, 2).leftPadZip(listOf("a")) { l, r -> l toT r }      // Result: [Tuple2(1, "a")]
+ * val right = listOf(1).leftPadZip(listOf("a", "b")) { l, r -> l toT r }   // Result: [Tuple2(1, "a"), Tuple2(null, "b")]
+ * val both = listOf(1, 2).leftPadZip(listOf("a", "b")) { l, r -> l toT r } // Result: [Tuple2(1, "a"), Tuple2(2, "b")]
+ * //sampleEnd
+ *
+ * fun main() {
+ *   println("left = $left")
+ *   println("right = $right")
+ *   println("both = $both")
+ * }
+ * ```
+ */
+inline fun <A, B, C> Iterable<A>.leftPadZip(other: Iterable<B>, fab: (A?, B) -> C): List<C> =
+  padZip(other) { a: A?, b: B? -> b?.let { fab(a, it) } }.mapNotNull(::identity)
+
+/**
+ * Returns a [List<Tuple2<A?, B>>] containing the zipped values of the two listKs
+ * with null for padding on the left.
+ *
+ * Example:
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * //sampleStart
+ * val padRight = listOf(1, 2).leftPadZip(listOf("a"))        // Result: [Tuple2(1, "a")]
+ * val padLeft = listOf(1).leftPadZip(listOf("a", "b"))       // Result: [Tuple2(1, "a"), Tuple2(null, "b")]
+ * val noPadding = listOf(1, 2).leftPadZip(listOf("a", "b"))  // Result: [Tuple2(1, "a"), Tuple2(2, "b")]
+ * //sampleEnd
+ *
+ * fun main() {
+ *   println("left = $left")
+ *   println("right = $right")
+ *   println("both = $both")
+ * }
+ * ```
+ */
+fun <A, B> Iterable<A>.leftPadZip(other: Iterable<B>): List<Tuple2<A?, B>> =
+  this.leftPadZip(other) { a, b -> a toT b }
+
+/**
+ * Returns a [List<C>] containing the result of applying some transformation `(A, B?) -> C`
+ * on a zip, excluding all cases where the left value is null.
+ *
+ * Example:
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * //sampleStart
+ * val left = listOf(1, 2).rightPadZip(listOf("a")) { l, r -> l toT r }      // Result: [Tuple2(1, "a"), Tuple2(null, "b")]
+ * val right = listOf(1).rightPadZip(listOf("a", "b")) { l, r -> l toT r }   // Result: [Tuple2(1, "a")]
+ * val both = listOf(1, 2).rightPadZip(listOf("a", "b")) { l, r -> l toT r } // Result: [Tuple2(1, "a"), Tuple2(2, "b")]
+ * //sampleEnd
+ *
+ * fun main() {
+ *   println("left = $left")
+ *   println("right = $right")
+ *   println("both = $both")
+ * }
+ * ```
+ */
+inline fun <A, B, C> Iterable<A>.rightPadZip(other: Iterable<B>, fa: (A, B?) -> C): List<C> =
+  other.leftPadZip(this) { a, b -> fa(b, a) }
+
+/**
+ * Returns a [List<Tuple2<A, B?>>] containing the zipped values of the two listKs
+ * with null for padding on the right.
+ *
+ * Example:
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * //sampleStart
+ * val padRight = listOf(1, 2).rightPadZip(listOf("a"))        // Result: [Tuple2(1, "a"), Tuple2(2, null)]
+ * val padLeft = listOf(1).rightPadZip(listOf("a", "b"))       // Result: [Tuple2(1, "a")]
+ * val noPadding = listOf(1, 2).rightPadZip(listOf("a", "b"))  // Result: [Tuple2(1, "a"), Tuple2(2, "b")]
+ * //sampleEnd
+ *
+ * fun main() {
+ *   println("left = $left")
+ *   println("right = $right")
+ *   println("both = $both")
+ * }
+ * ```
+ */
+fun <A, B> Iterable<A>.rightPadZip(other: Iterable<B>): List<Tuple2<A, B?>> =
+  this.rightPadZip(other) { a, b -> a toT b }
+
+fun <A> Iterable<A>.show(SA: Show<A>): String = "[" +
+  joinToString(", ") { SA.run { it.show() } } + "]"
+
+@Suppress("UNCHECKED_CAST")
+private tailrec fun <A, B> go(
+  buf: MutableList<B>,
+  f: (A) -> Iterable<Either<A, B>>,
+  v: List<Either<A, B>>
+) {
+  if (v.isNotEmpty()) {
+    when (val head: Either<A, B> = v.first()) {
+      is Either.Right -> {
+        buf += head.b
+        go(buf, f, v.drop(1))
+      }
+      is Either.Left -> go(buf, f, (f(head.a) + v.drop(1)))
+    }
+  }
+}
+
+fun <A, B> tailRecMIterable(a: A, f: (A) -> Iterable<Either<A, B>>): List<B> {
+  val buf = mutableListOf<B>()
+  go(buf, f, f(a).toList())
+  return ListK(buf)
+}
+
+/**
+ * Combines two structures by taking the union of their shapes and combining the elements with the given function.
+ *
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * fun main(args: Array<String>) {
+ *   //sampleStart
+ *   val result =
+ *    listOf("A", "B").align(listOf(1, 2, 3)) {
+ *      "$it"
+ *    }
+ *   //sampleEnd
+ *   println(result)
+ * }
+ * ```
+ */
+inline fun <A, B, C> Iterable<A>.align(b: Iterable<B>, fa: (Ior<A, B>) -> C): List<C> =
+  this.align(b).map(fa)
+
+/**
+ * Combines two structures by taking the union of their shapes and using Ior to hold the elements.
+ *
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * fun main(args: Array<String>) {
+ *   //sampleStart
+ *   val result =
+ *     listOf("A", "B").align(listOf(1, 2, 3))
+ *   //sampleEnd
+ *   println(result)
+ * }
+ * ```
+ */
+fun <A, B> Iterable<A>.align(b: Iterable<B>): List<Ior<A, B>> =
+  alignRec(this, b)
+
+@Suppress("NAME_SHADOWING")
+private fun <X, Y> alignRec(ls: Iterable<X>, rs: Iterable<Y>): List<Ior<X, Y>> {
+  val ls = if (ls is List) ls else ls.toList()
+  val rs = if (rs is List) rs else rs.toList()
+  return when {
+    ls.isEmpty() -> rs.map { it.rightIor() }
+    rs.isEmpty() -> ls.map { it.leftIor() }
+    else -> listOf(Ior.Both(ls.first(), rs.first())) + alignRec(ls.drop(1), rs.drop(1))
+  }
+}
+
+/**
+ * aligns two structures and combine them with the given [Semigroup.combine]
+ */
+fun <A> Iterable<A>.salign(
+  SG: Semigroup<A>,
+  other: Iterable<A>
+): Iterable<A> = SG.run {
+  align(other) {
+    it.fold(::identity, ::identity) { a, b ->
+      a.combine(b)
+    }
+  }
+}
+
+/**
+ * unzips the structure holding the resulting elements in an `Tuple2`
+ *
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * fun main(args: Array<String>) {
+ *   //sampleStart
+ *   val result =
+ *      listOf("A" toT 1, "B" toT 2).k().unzip()
+ *   //sampleEnd
+ *   println(result)
+ * }
+ * ```
+ */
+fun <A, B> Iterable<Tuple2<A, B>>.unzip(): Tuple2<List<A>, List<B>> =
+  fold(emptyList<A>() toT emptyList()) { (l, r), x ->
+    l + x.a toT r + x.b
+  }
+
+/**
+ * after applying the given function unzip the resulting structure into its elements.
+ *
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * fun main(args: Array<String>) {
+ *   //sampleStart
+ *   val result =
+ *    listOf("A:1", "B:2", "C:3").k().unzip { e ->
+ *      e.split(":").let {
+ *        it.first() toT it.last()
+ *      }
+ *    }
+ *   //sampleEnd
+ *   println(result)
+ * }
+ * ```
+ */
+inline fun <A, B, C> Iterable<C>.unzip(fc: (C) -> Tuple2<A, B>): Tuple2<List<A>, List<B>> =
+  map(fc).unzip()
+
+/**
+ * splits a union into its component parts.
+ *
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * fun main(args: Array<String>) {
+ *   //sampleStart
+ *   val result =
+ *    listOf(("A" toT 1).bothIor(), ("B" toT 2).bothIor(), "C".leftIor())
+ *      .unalign()
+ *   //sampleEnd
+ *   println(result)
+ * }
+ * ```
+ */
+fun <A, B> Iterable<Ior<A, B>>.unalign(): Tuple2<List<A>, List<B>> =
+  fold(emptyList<A>() toT emptyList()) { (l, r), x ->
+    x.fold(
+      { l + it toT r },
+      { l toT r + it },
+      { a, b -> l + a toT r + b }
+    )
+  }
+
+/**
+ * after applying the given function, splits the resulting union shaped structure into its components parts
+ *
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * fun main(args: Array<String>) {
+ *   //sampleStart
+ *   val result =
+ *      listOf(1, 2, 3).unalign {
+ *        it.leftIor()
+ *      }
+ *   //sampleEnd
+ *   println(result)
+ * }
+ * ```
+ */
+inline fun <A, B, C> Iterable<C>.unalign(fa: (C) -> Ior<A, B>): Tuple2<List<A>, List<B>> =
+  map(fa).unalign()
+
+fun <A, B> Iterable<A>.product(fb: Iterable<B>): List<Tuple2<A, B>> =
+  fb.ap(map { a: A -> { b: B -> Tuple2(a, b) } })
+
+fun <A> Iterable<A>.combineAll(MA: Monoid<A>): A = MA.run {
+  this@combineAll.fold(empty()) { acc, a ->
+    acc.combine(a)
+  }
+}
+
+/**
+ * attempt to split the computation, giving access to the first result.
+ *
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * fun main(args: Array<String>) {
+ *   //sampleStart
+ *   val result =
+ *    listOf("A", "B", "C").split()
+ *   //sampleEnd
+ *   println(result)
+ * }
+ */
+fun <A> Iterable<A>.split(): Tuple2<List<A>, A>? =
+  firstOrNull()?.let { first ->
+    Tuple2(tail(), first)
+  }
+
+fun <A> Iterable<A>.tail(): List<A> =
+  drop(1)
+
+/**
+ * interleave both computations in a fair way.
+ *
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * fun main(args: Array<String>) {
+ *   //sampleStart
+ *   val tags = List(10) { "#" }
+ *   val result =
+ *    tags.interleave(listOf("A", "B", "C"))
+ *   //sampleEnd
+ *   println(result)
+ * }
+ */
+fun <A> Iterable<A>.interleave(other: Iterable<A>): List<A> =
+  this.split()?.let { (fa, a) ->
+    listOf(a) + other.interleave(fa)
+  } ?: other.toList()
+
+/**
+ * Fair conjunction. Similarly to interleave
+ *
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * fun main(args: Array<String>) {
+ *   //sampleStart
+ *   val result =
+ *    listOf(1,2,3).unweave { i -> listOf("$i, ${i + 1}") }
+ *   //sampleEnd
+ *   println(result)
+ * }
+ */
+fun <A, B> Iterable<A>.unweave(ffa: (A) -> Iterable<B>): List<B> =
+  split()?.let { (fa, a) ->
+    ffa(a).interleave(fa.unweave(ffa))
+  } ?: emptyList()
+
+/**
+ * Logical conditional. The equivalent of Prolog's soft-cut.
+ * If its first argument succeeds at all, then the results will be
+ * fed into the success branch. Otherwise, the failure branch is taken.
+ *
+ * ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ * fun main(args: Array<String>) {
+ *   //sampleStart
+ *   val result =
+ *    listOf(1,2,3).ifThen(listOf("empty")) { i ->
+ *      listOf("$i, ${i + 1}")
+ *    }
+ *   //sampleEnd
+ *   println(result)
+ * }
+ */
+inline fun <A, B> Iterable<A>.ifThen(fb: Iterable<B>, ffa: (A) -> Iterable<B>): Iterable<B> =
+  split()?.let { (fa, a) ->
+    ffa(a) + fa.flatMap(ffa)
+  } ?: fb.toList()
+
+fun <A, B> Iterable<Either<A, B>>.uniteEither(): List<B> =
+  flatMap { either ->
+    either.fold({ emptyList() }, { b -> listOf(b) })
+  }
+
+fun <A, B> Iterable<Validated<A, B>>.uniteValidated(): List<B> =
+  flatMap { validated ->
+    validated.fold({ emptyList() }, { b -> listOf(b) })
+  }
+
+/**
+ * Separate the inner [Either] values into the [Either.Left] and [Either.Right].
+ *
+ * @receiver Iterable of Validated
+ * @return a tuple containing List with [Either.Left] and another List with its [Either.Right] values.
+ */
+fun <A, B> Iterable<Either<A, B>>.separateEither(): Tuple2<List<A>, List<B>> {
+  val asep = flatMap { gab -> gab.fold({ listOf(it) }, { emptyList() }) }
+  val bsep = flatMap { gab -> gab.fold({ emptyList() }, { listOf(it) }) }
+  return Tuple2(asep, bsep)
+}
+
+/**
+ * Separate the inner [Validated] values into the [Validated.Invalid] and [Validated.Valid].
+ *
+ * @receiver Iterable of Validated
+ * @return a tuple containing List with [Validated.Invalid] and another List with its [Validated.Valid] values.
+ */
+fun <A, B> Iterable<Validated<A, B>>.separateValidated(): Tuple2<List<A>, List<B>> {
+  val asep = flatMap { gab -> gab.fold({ listOf(it) }, { emptyList() }) }
+  val bsep = flatMap { gab -> gab.fold({ emptyList() }, { listOf(it) }) }
+  return Tuple2(asep, bsep)
+}
+
+fun <A> Iterable<Iterable<A>>.flatten(): List<A> =
+  flatMap(::identity)
+
+inline fun <B> Iterable<Boolean>.ifM(ifFalse: () -> Iterable<B>, ifTrue: () -> Iterable<B>): List<B> =
+  flatMap { bool ->
+    if (bool) ifTrue() else ifFalse()
+  }
+
+fun <A, B> Iterable<Either<A, B>>.selectM(f: Iterable<(A) -> B>): List<B> =
+  flatMap { it.fold({ a -> f.map { ff -> ff(a) } }, { b -> listOf(b) }) }
+
+/**
+ *  Applies [f] to an [A] inside [Iterable] and returns the [List] structure with a tuple of the [A] value and the
+ *  computed [B] value as result of applying [f]
+ *
+ *  ```kotlin:ank:playground
+ * import arrow.core.*
+ *
+ *  fun main(args: Array<String>) {
+ *   val result =
+ *   //sampleStart
+ *   listOf("Hello").fproduct { "$it World" }
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ */
+inline fun <A, B> Iterable<A>.fproduct(f: (A) -> B): List<Tuple2<A, B>> =
+  map { a -> Tuple2(a, f(a)) }
+
+/**
+ *  Pairs [B] with [A] returning a List<Tuple2<B, A>>
+ *
+ *  ```kotlin:ank:playground
+ *  import arrow.core.*
+ *
+ *  fun main(args: Array<String>) {
+ *   val result =
+ *   //sampleStart
+ *   listOf("Hello", "Hello2").tupleLeft("World")
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ */
+fun <A, B> Iterable<A>.tupleLeft(b: B): List<Tuple2<B, A>> =
+  map { a -> Tuple2(b, a) }
+
+/**
+ *  Pairs [A] with [B] returning a List<Tuple2<A, B>>
+ *
+ *  ```kotlin:ank:playground
+ *  import arrow.core.*
+ *
+ *  fun main(args: Array<String>) {
+ *   val result =
+ *   //sampleStart
+ *   listOf("Hello").tupleRight("World")
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ */
+fun <A, B> Iterable<A>.tupleRight(b: B): List<Tuple2<A, B>> =
+  map { a -> Tuple2(a, b) }
+
+/**
+ *  Given [A] is a sub type of [B], re-type this value from Iterable<A> to Iterable<B>
+ *
+ *  Kind<F, A> -> Kind<F, B>
+ *
+ *  ```kotlin:ank:playground
+ *  import arrow.core.*
+ *
+ *  fun main(args: Array<String>) {
+ *   //sampleStart
+ *   val result: Iterable<CharSequence> =
+ *     listOf("Hello World").widen()
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ */
+fun <B, A : B> Iterable<A>.widen(): Iterable<B> =
+  this
+
+fun <B, A : B> List<A>.widen(): List<B> =
+  this
+
+fun <A> Iterable<A>.fold(MA: Monoid<A>): A = MA.run {
+  this@fold.fold(empty()) { acc, a ->
+    acc.combine(a)
+  }
+}
+
+fun <A, B> Iterable<A>.foldMap(MB: Monoid<B>, f: (A) -> B): B = MB.run {
+  this@foldMap.fold(empty()) { acc, a ->
+    acc.combine(f(a))
+  }
+}
+
+fun <A> listEq(EQA: Eq<A>): Eq<List<A>> =
+  ListEq(EQA)
+
+private class ListEq<A>(private val EQA: Eq<A>) : Eq<List<A>> {
+  override fun List<A>.eqv(b: List<A>): Boolean =
+    eqv(EQA, b)
+}
+
+fun <A> Iterable<A>.eqv(EQA: Eq<A>, other: Iterable<A>): Boolean = EQA.run {
+  if (this is Collection<*> && other is Collection && this.size != other.size) false
+  else {
+    zip(other) { a, b -> a.eqv(b) }
+      .fold(true) { acc, bool -> acc && bool }
+  }
+}
+
+fun <A> Iterable<A>.neqv(EQA: Eq<A>, other: Iterable<A>): Boolean =
+  !eqv(EQA, other)
+
+fun <A, B> Iterable<A>.crosswalk(f: (A) -> Iterable<B>): List<List<B>> =
+  fold(emptyList()) { bs, a ->
+    f(a).align(bs) { ior ->
+      ior.fold(
+        { listOf(it) },
+        ::identity,
+        { l, r -> listOf(l) + r }
+      )
+    }
+  }
+
+fun <A, K, V> Iterable<A>.crosswalkMap(f: (A) -> Map<K, V>): Map<K, List<V>> =
+  fold(emptyMap()) { bs, a ->
+    f(a).align(bs) { ior ->
+      ior.fold(
+        { listOf(it) },
+        ::identity,
+        { l, r -> listOf(l) + r }
+      )
+    }
+  }
+
+fun <A, B> Iterable<A>.crosswalkNull(f: (A) -> B?): List<B>? =
+  fold<A, List<B>?>(emptyList()) { bs, a ->
+    Ior.fromNullables(f(a), bs)?.fold(
+      { listOf(it) },
+      ::identity,
+      { l, r -> listOf(l) + r }
+    )
+  }
+
+@PublishedApi
+internal val unit: List<Unit> =
+  listOf(Unit)
+
+@JvmName("product3")
+fun <A, B, C> Iterable<Tuple2<A, B>>.product(other: Iterable<C>): List<Tuple3<A, B, C>> =
+  map2(other) { (ab, c) -> Tuple3(ab.a, ab.b, c) }
+
+@JvmName("product4")
+fun <A, B, C, D> Iterable<Tuple3<A, B, C>>.product(other: Iterable<D>): List<Tuple4<A, B, C, D>> =
+  map2(other) { (abc, d) -> Tuple4(abc.a, abc.b, abc.c, d) }
+
+@JvmName("product5")
+fun <A, B, C, D, EE> Iterable<Tuple4<A, B, C, D>>.product(other: Iterable<EE>): List<Tuple5<A, B, C, D, EE>> =
+  map2(other) { (abcd, e) -> Tuple5(abcd.a, abcd.b, abcd.c, abcd.d, e) }
+
+@JvmName("product6")
+fun <A, B, C, D, EE, F> Iterable<Tuple5<A, B, C, D, EE>>.product(other: Iterable<F>): List<Tuple6<A, B, C, D, EE, F>> =
+  map2(other) { (abcde, f) -> Tuple6(abcde.a, abcde.b, abcde.c, abcde.d, abcde.e, f) }
+
+@JvmName("product7")
+fun <A, B, C, D, EE, F, G> Iterable<Tuple6<A, B, C, D, EE, F>>.product(
+  other: Iterable<G>
+): List<Tuple7<A, B, C, D, EE, F, G>> =
+  map2(other) { (abcdef, g) -> Tuple7(abcdef.a, abcdef.b, abcdef.c, abcdef.d, abcdef.e, abcdef.f, g) }
+
+@JvmName("product8")
+fun <A, B, C, D, EE, F, G, H> Iterable<Tuple7<A, B, C, D, EE, F, G>>.product(
+  other: Iterable<H>
+): List<Tuple8<A, B, C, D, EE, F, G, H>> =
+  map2(other) { (abcdefg, h) -> Tuple8(abcdefg.a, abcdefg.b, abcdefg.c, abcdefg.d, abcdefg.e, abcdefg.f, abcdefg.g, h) }
+
+@JvmName("product9")
+fun <A, B, C, D, EE, F, G, H, I> Iterable<Tuple8<A, B, C, D, EE, F, G, H>>.product(
+  other: Iterable<I>
+): List<Tuple9<A, B, C, D, EE, F, G, H, I>> =
+  map2(other) { (abcdefgh, i) -> Tuple9(abcdefgh.a, abcdefgh.b, abcdefgh.c, abcdefgh.d, abcdefgh.e, abcdefgh.f, abcdefgh.g, abcdefgh.h, i) }
+
+@JvmName("product10")
+fun <A, B, C, D, EE, F, G, H, I, J> Iterable<Tuple9<A, B, C, D, EE, F, G, H, I>>.product(
+  other: Iterable<J>
+): List<Tuple10<A, B, C, D, EE, F, G, H, I, J>> =
+  map2(other) { (abcdefghi, j) -> Tuple10(abcdefghi.a, abcdefghi.b, abcdefghi.c, abcdefghi.d, abcdefghi.e, abcdefghi.f, abcdefghi.g, abcdefghi.h, abcdefghi.i, j) }
+
+fun <A> Iterable<A>.replicate(n: Int): List<List<A>> =
+  if (n <= 0) emptyList()
+  else toList().let { l -> List(n) { l } }
+
+fun <A> Iterable<A>.replicate(n: Int, MA: Monoid<A>): List<A> =
+  if (n <= 0) listOf(MA.empty())
+  else ListK.mapN(this@replicate, replicate(n - 1, MA)) { a, xs -> MA.run { a + xs } }
diff --git a/arrow-core-data/src/main/kotlin/arrow/core/List.kt b/arrow-core-data/src/main/kotlin/arrow/core/List.kt
new file mode 100644
index 000000000..d3ecbe8a4
--- /dev/null
+++ b/arrow-core-data/src/main/kotlin/arrow/core/List.kt
@@ -0,0 +1,119 @@
+package arrow.core
+
+import arrow.typeclasses.Hash
+import arrow.typeclasses.Monoid
+import arrow.typeclasses.Order
+import arrow.typeclasses.Show
+import arrow.typeclasses.defaultSalt
+import arrow.typeclasses.hashWithSalt
+
+fun <A> listHash(HA: Hash<A>): Hash<List<A>> =
+  ListHash(HA)
+
+private class ListHash<A>(private val HA: Hash<A>) : Hash<List<A>> {
+  override fun List<A>.hash(): Int = hash(HA)
+  override fun List<A>.hashWithSalt(salt: Int): Int = hashWithSalt(HA, salt)
+}
+
+fun <A> List<A>.hash(HA: Hash<A>): Int =
+  hashWithSalt(HA, defaultSalt)
+
+fun <A> List<A>.hashWithSalt(HA: Hash<A>, salt: Int): Int = HA.run {
+  fold(salt) { hash, x -> x.hashWithSalt(hash) }.hashWithSalt(size)
+}
+
+fun <A> List<A>.compare(OA: Order<A>, b: List<A>): Ordering = OA.run {
+  align(b) { ior -> ior.fold({ GT }, { LT }, { a1, a2 -> a1.compare(a2) }) }
+    .fold(Ordering.monoid())
+}
+
+/**
+ * Check if [this@lt] is `lower than` [b]
+ *
+ * @receiver object to compare with [b]
+ * @param b object to compare with [this@lt]
+ * @returns true if [this@lt] is `lower than` [b] and false otherwise
+ */
+fun <A> List<A>.lt(OA: Order<A>, b: List<A>): Boolean =
+  compare(OA, b) == LT
+
+/**
+ * Check if [this@lte] is `lower than or equal to` [b]
+ *
+ * @receiver object to compare with [b]
+ * @param b object to compare with [this@lte]
+ * @returns true if [this@lte] is `lower than or equal to` [b] and false otherwise
+ */
+fun <A> List<A>.lte(OA: Order<A>, b: List<A>): Boolean =
+  compare(OA, b) != GT
+
+/**
+ * Check if [this@gt] is `greater than` [b]
+ *
+ * @receiver object to compare with [b]
+ * @param b object to compare with [this@gt]
+ * @returns true if [this@gt] is `greater than` [b] and false otherwise
+ */
+fun <A> List<A>.gt(OA: Order<A>, b: List<A>): Boolean =
+  compare(OA, b) == GT
+
+/**
+ * Check if [this@gte] is `greater than or equal to` [b]
+ *
+ * @receiver object to compare with [b]
+ * @param b object to compare with [this@gte]
+ * @returns true if [this@gte] is `greater than or equal to` [b] and false otherwise
+ */
+fun <A> List<A>.gte(OA: Order<A>, b: List<A>): Boolean =
+  compare(OA, b) != LT
+
+/**
+ * Determines the maximum of [this@max] and [b] in terms of order.
+ *
+ * @receiver object to compare with [b]
+ * @param b object to compare with [this@max]
+ * @returns the maximum [this@max] if it is greater than [b] or [b] otherwise
+ */
+fun <A> List<A>.max(OA: Order<A>, b: List<A>): List<A> =
+  if (gt(OA, b)) this else b
+
+/**
+ * Determines the minimum of [this@min] and [b] in terms of order.
+ *
+ * @receiver object to compare with [b]
+ * @param b object to compare with [this@min]
+ * @returns the minimum [this@min] if it is less than [b] or [b] otherwise
+ */
+fun <A> List<A>.min(OA: Order<A>, b: List<A>): List<A> =
+  if (lt(OA, b)) this else b
+
+/**
+ * Sorts [this@sort] and [b] in terms of order.
+ *
+ * @receiver object to compare with [b]
+ * @param b object to compare with [this@sort]
+ * @returns a sorted [Tuple2] of [this@sort] and [b].
+ */
+fun <A> List<A>.sort(OA: Order<A>, b: List<A>): Tuple2<List<A>, List<A>> =
+  if (gte(OA, b)) Tuple2(this, b) else Tuple2(b, this)
+
+fun <A> listOrder(OA: Order<A>): Order<List<A>> =
+  ListOrder(OA)
+
+private class ListOrder<A>(private val OA: Order<A>) : Order<List<A>> {
+  override fun List<A>.compare(b: List<A>): Ordering = compare(OA, b)
+}
+
+fun <A> listMonoid(): Monoid<List<A>> =
+  ListMonoid as Monoid<List<A>>
+
+object ListMonoid : Monoid<List<Any?>> {
+  override fun empty(): List<Any?> = emptyList()
+  override fun List<Any?>.combine(b: List<Any?>): List<Any?> = this + b
+}
+
+fun <A> listShow(SA: Show<A>): Show<List<A>> =
+  object : Show<List<A>> {
+    override fun List<A>.show(): String =
+      show(SA)
+  }
diff --git a/arrow-core-data/src/main/kotlin/arrow/core/ListK.kt b/arrow-core-data/src/main/kotlin/arrow/core/ListK.kt
index 9a9383857..959757972 100644
--- a/arrow-core-data/src/main/kotlin/arrow/core/ListK.kt
+++ b/arrow-core-data/src/main/kotlin/arrow/core/ListK.kt
@@ -472,6 +472,233 @@ data class ListK<out A>(private val list: List<A>) : ListKOf<A>, List<A> by list
       rs.isEmpty() -> ls.map { it.leftIor() }
       else -> listOf(Ior.Both(ls.first(), rs.first())) + alignRec(ls.drop(1), rs.drop(1))
     }
+
+    inline fun <B, C, D> mapN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      map: (B, C) -> D
+    ): List<D> =
+      mapN(b, c, unit, unit, unit, unit, unit, unit, unit, unit) { b, c, _, _, _, _, _, _, _, _ -> map(b, c) }
+
+    inline fun <B, C, D, E> mapN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      map: (B, C, D) -> E
+    ): List<E> =
+      mapN(b, c, d, unit, unit, unit, unit, unit, unit, unit) { b, c, d, _, _, _, _, _, _, _ -> map(b, c, d) }
+
+    inline fun <B, C, D, E, F> mapN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      map: (B, C, D, E) -> F
+    ): List<F> =
+      mapN(b, c, d, e, unit, unit, unit, unit, unit, unit) { b, c, d, e, _, _, _, _, _, _ -> map(b, c, d, e) }
+
+    inline fun <B, C, D, E, F, G> mapN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>,
+      map: (B, C, D, E, F) -> G
+    ): List<G> =
+      mapN(b, c, d, e, f, unit, unit, unit, unit, unit) { b, c, d, e, f, _, _, _, _, _ -> map(b, c, d, e, f) }
+
+    inline fun <B, C, D, E, F, G, H> mapN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>,
+      g: Iterable<G>,
+      map: (B, C, D, E, F, G) -> H
+    ): List<H> =
+      mapN(b, c, d, e, f, g, unit, unit, unit, unit) { b, c, d, e, f, g, _, _, _, _ -> map(b, c, d, e, f, g) }
+
+    inline fun <B, C, D, E, F, G, H, I> mapN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>,
+      g: Iterable<G>,
+      h: Iterable<H>,
+      map: (B, C, D, E, F, G, H) -> I
+    ): List<I> =
+      mapN(b, c, d, e, f, g, h, unit, unit, unit) { b, c, d, e, f, g, h, _, _, _ -> map(b, c, d, e, f, g, h) }
+
+    inline fun <B, C, D, E, F, G, H, I, J> mapN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>,
+      g: Iterable<G>,
+      h: Iterable<H>,
+      i: Iterable<I>,
+      map: (B, C, D, E, F, G, H, I) -> J
+    ): List<J> =
+      mapN(b, c, d, e, f, g, h, i, unit, unit) { b, c, d, e, f, g, h, i, _, _ -> map(b, c, d, e, f, g, h, i) }
+
+    inline fun <B, C, D, E, F, G, H, I, J, K> mapN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>,
+      g: Iterable<G>,
+      h: Iterable<H>,
+      i: Iterable<I>,
+      j: Iterable<J>,
+      map: (B, C, D, E, F, G, H, I, J) -> K
+    ): List<K> =
+      mapN(b, c, d, e, f, g, h, i, j, unit) { b, c, d, e, f, g, h, i, j, _ -> map(b, c, d, e, f, g, h, i, j) }
+
+    inline fun <B, C, D, E, F, G, H, I, J, K, L> mapN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>,
+      g: Iterable<G>,
+      h: Iterable<H>,
+      i: Iterable<I>,
+      j: Iterable<J>,
+      k: Iterable<K>,
+      map: (B, C, D, E, F, G, H, I, J, K) -> L
+    ): List<L> =
+      b.flatMap { bb ->
+        c.flatMap { cc ->
+          d.flatMap { dd ->
+            e.flatMap { ee ->
+              f.flatMap { ff ->
+                g.flatMap { gg ->
+                  h.flatMap { hh ->
+                    i.flatMap { ii ->
+                      j.flatMap { jj ->
+                        k.map { kk ->
+                          map(bb, cc, dd, ee, ff, gg, hh, ii, jj, kk)
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+    fun <B, C> tupledN(
+      b: Iterable<B>,
+      c: Iterable<C>
+    ): List<Tuple2<B, C>> =
+      mapN(b, c) { b, c ->
+        Tuple2(b, c)
+      }
+
+    fun <B, C, D> tupledN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>
+    ): List<Tuple3<B, C, D>> =
+      mapN(b, c, d) { b, c, d ->
+        Tuple3(b, c, d)
+      }
+
+    fun <B, C, D, E> tupledN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>
+    ): List<Tuple4<B, C, D, E>> =
+      mapN(b, c, d, e) { b, c, d, e ->
+        Tuple4(b, c, d, e)
+      }
+
+    fun <B, C, D, E, F> tupledN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>
+    ): List<Tuple5<B, C, D, E, F>> =
+      mapN(b, c, d, e, f) { b, c, d, e, f ->
+        Tuple5(b, c, d, e, f)
+      }
+
+    fun <B, C, D, E, F, G> tupledN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>,
+      g: Iterable<G>
+    ): List<Tuple6<B, C, D, E, F, G>> =
+      mapN(b, c, d, e, f, g) { b, c, d, e, f, g ->
+        Tuple6(b, c, d, e, f, g)
+      }
+
+    fun <B, C, D, E, F, G, H> tupledN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>,
+      g: Iterable<G>,
+      h: Iterable<H>
+    ): List<Tuple7<B, C, D, E, F, G, H>> =
+      mapN(b, c, d, e, f, g, h) { b, c, d, e, f, g, h ->
+        Tuple7(b, c, d, e, f, g, h)
+      }
+
+    fun <B, C, D, E, F, G, H, I> tupledN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>,
+      g: Iterable<G>,
+      h: Iterable<H>,
+      i: Iterable<I>
+    ): List<Tuple8<B, C, D, E, F, G, H, I>> =
+      mapN(b, c, d, e, f, g, h, i) { b, c, d, e, f, g, h, i ->
+        Tuple8(b, c, d, e, f, g, h, i)
+      }
+
+    fun <B, C, D, E, F, G, H, I, J> tupledN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>,
+      g: Iterable<G>,
+      h: Iterable<H>,
+      i: Iterable<I>,
+      j: Iterable<J>
+    ): List<Tuple9<B, C, D, E, F, G, H, I, J>> =
+      mapN(b, c, d, e, f, g, h, i, j) { b, c, d, e, f, g, h, i, j ->
+        Tuple9(b, c, d, e, f, g, h, i, j)
+      }
+
+    fun <B, C, D, E, F, G, H, I, J, K> tupledN(
+      b: Iterable<B>,
+      c: Iterable<C>,
+      d: Iterable<D>,
+      e: Iterable<E>,
+      f: Iterable<F>,
+      g: Iterable<G>,
+      h: Iterable<H>,
+      i: Iterable<I>,
+      j: Iterable<J>,
+      k: Iterable<K>
+    ): List<Tuple10<B, C, D, E, F, G, H, I, J, K>> =
+      mapN(b, c, d, e, f, g, h, i, j, k) { b, c, d, e, f, g, h, i, j, k ->
+        Tuple10(b, c, d, e, f, g, h, i, j, k)
+      }
   }
 }
 
@@ -482,9 +709,3 @@ fun <A> List<A>.k(): ListK<A> = ListK(this)
 
 fun <A> listKOf(vararg elements: A): ListK<A> =
   listOf(*elements).k()
-
-fun <A, B> Iterable<A>.mapConst(b: B): List<B> =
-  map { b }
-
-fun <A> Iterable<A>.void(): List<Unit> =
-  mapConst(Unit)
diff --git a/arrow-core-data/src/main/kotlin/arrow/core/Ordering.kt b/arrow-core-data/src/main/kotlin/arrow/core/Ordering.kt
index b3016b15d..799951206 100644
--- a/arrow-core-data/src/main/kotlin/arrow/core/Ordering.kt
+++ b/arrow-core-data/src/main/kotlin/arrow/core/Ordering.kt
@@ -119,7 +119,7 @@ private object OrderingMonoid : Monoid<Ordering> {
   override fun empty(): Ordering = EQ
 
   override fun Ordering.combine(b: Ordering): Ordering =
-    this.combine(b)
+    this + b
 }
 
 @Suppress("EXTENSION_SHADOWED_BY_MEMBER")
diff --git a/arrow-core-data/src/main/kotlin/arrow/core/map.kt b/arrow-core-data/src/main/kotlin/arrow/core/map.kt
index 385840058..94c6f7c51 100644
--- a/arrow-core-data/src/main/kotlin/arrow/core/map.kt
+++ b/arrow-core-data/src/main/kotlin/arrow/core/map.kt
@@ -3,3 +3,11 @@ package arrow.core
 object MapInstances
 
 object SortedMapInstances
+
+fun <K, A, B> Map<K, A>.align(b: Map<K, B>): Map<K, Ior<A, B>> =
+  (keys + b.keys).mapNotNull { key ->
+    Ior.fromNullables(this@align[key], b[key])?.let { key to it }
+  }.toMap()
+
+fun <K, A, B, C> Map<K, A>.align(b: Map<K, B>, fa: (Ior<A, B>) -> C): Map<K, C> =
+  this.align(b).mapValues { (_, v) -> fa(v) }
diff --git a/arrow-core-data/src/test/kotlin/arrow/core/IterableTest.kt b/arrow-core-data/src/test/kotlin/arrow/core/IterableTest.kt
new file mode 100644
index 000000000..229d2d827
--- /dev/null
+++ b/arrow-core-data/src/test/kotlin/arrow/core/IterableTest.kt
@@ -0,0 +1,98 @@
+package arrow.core
+
+import arrow.core.extensions.eq
+import arrow.core.test.UnitSpec
+import arrow.core.test.laws.equalUnderTheLaw
+import io.kotlintest.properties.Gen
+import io.kotlintest.properties.forAll
+import kotlin.math.max
+import kotlin.math.min
+
+class IterableTest : UnitSpec() {
+  init {
+    "can align lists with different lengths" {
+      forAll(Gen.list(Gen.bool()), Gen.list(Gen.bool())) { a, b ->
+        a.align(b).size == max(a.size, b.size)
+      }
+
+      forAll(Gen.list(Gen.bool()), Gen.list(Gen.bool())) { a, b ->
+        a.align(b).take(min(a.size, b.size)).all {
+          it.isBoth
+        }
+      }
+
+      forAll(Gen.list(Gen.bool()), Gen.list(Gen.bool())) { a, b ->
+        a.align(b).drop(min(a.size, b.size)).all {
+          if (a.size < b.size) {
+            it.isRight
+          } else {
+            it.isLeft
+          }
+        }
+      }
+    }
+
+    "leftPadZip (with map)" {
+      forAll(Gen.list(Gen.int()), Gen.list(Gen.int())) { a, b ->
+        val left = a.map { it } + List(max(0, b.count() - a.count())) { null }
+        val right = b.map { it } + List(max(0, a.count() - b.count())) { null }
+
+        val result = a.leftPadZip(b) { a, b -> a toT b }
+
+        result == left.zip(right) { l, r -> l toT r }.filter { it.b != null }
+      }
+    }
+
+    "leftPadZip (without map)" {
+      forAll(Gen.list(Gen.int()), Gen.list(Gen.int())) { a, b ->
+        val left = a.map { it } + List(max(0, b.count() - a.count())) { null }
+        val right = b.map { it } + List(max(0, a.count() - b.count())) { null }
+
+        val result = a.leftPadZip(b)
+
+        result == left.zip(right) { l, r -> l toT r }.filter { it.b != null }
+      }
+    }
+
+    "rightPadZip (without map)" {
+      forAll(Gen.list(Gen.int()), Gen.list(Gen.int())) { a, b ->
+        val left = a.map { it } + List(max(0, b.count() - a.count())) { null }
+        val right = b.map { it } + List(max(0, a.count() - b.count())) { null }
+
+        val result = a.rightPadZip(b)
+
+        result == left.zip(right) { l, r -> l toT r }.filter { it.a != null } &&
+          result.map { it.a }.equalUnderTheLaw(a, listEq(Int.eq()))
+      }
+    }
+
+    "rightPadZip (with map)" {
+      forAll(Gen.list(Gen.int()), Gen.list(Gen.int())) { a, b ->
+        val left = a.map { it } + List(max(0, b.count() - a.count())) { null }
+        val right = b.map { it } + List(max(0, a.count() - b.count())) { null }
+
+        val result = a.rightPadZip(b) { a, b -> a toT b }
+
+        result == left.zip(right) { l, r -> l toT r }.filter { it.a != null } &&
+          result.map { it.a }.equalUnderTheLaw(a, listEq(Int.eq()))
+      }
+    }
+
+    "padZip" {
+      forAll(Gen.list(Gen.int()), Gen.list(Gen.int())) { a, b ->
+        val left = a.map { it } + List(max(0, b.count() - a.count())) { null }
+        val right = b.map { it } + List(max(0, a.count() - b.count())) { null }
+        a.padZip(b) { l, r -> Ior.fromNullables(l, r) } == left.zip(right) { l, r -> Ior.fromNullables(l, r) }
+      }
+    }
+
+    "padZipWithNull" {
+      forAll(Gen.list(Gen.int()), Gen.list(Gen.int())) { a, b ->
+        val left = a.map { it } + List(max(0, b.count() - a.count())) { null }
+        val right = b.map { it } + List(max(0, a.count() - b.count())) { null }
+
+        a.padZip(b) == left.zip(right) { l, r -> l toT r }
+      }
+    }
+  }
+}
diff --git a/arrow-core-data/src/test/kotlin/arrow/core/ListKTest.kt b/arrow-core-data/src/test/kotlin/arrow/core/ListKTest.kt
index 86d8227e5..ae924bdc9 100644
--- a/arrow-core-data/src/test/kotlin/arrow/core/ListKTest.kt
+++ b/arrow-core-data/src/test/kotlin/arrow/core/ListKTest.kt
@@ -3,7 +3,6 @@ package arrow.core
 import arrow.Kind
 import arrow.core.extensions.eq
 import arrow.core.extensions.hash
-import arrow.core.extensions.list.zip.zipWith
 import arrow.core.extensions.listk.align.align
 import arrow.core.extensions.listk.applicative.applicative
 import arrow.core.extensions.listk.crosswalk.crosswalk
@@ -19,14 +18,12 @@ import arrow.core.extensions.listk.monoid.monoid
 import arrow.core.extensions.listk.monoidK.monoidK
 import arrow.core.extensions.listk.monoidal.monoidal
 import arrow.core.extensions.listk.order.order
-import arrow.core.extensions.listk.semialign.semialign
 import arrow.core.extensions.listk.semigroupK.semigroupK
 import arrow.core.extensions.listk.show.show
 import arrow.core.extensions.listk.traverse.traverse
 import arrow.core.extensions.listk.unalign.unalign
 import arrow.core.extensions.listk.unzip.unzip
 import arrow.core.extensions.order
-import arrow.core.extensions.listk.zip.zipWith
 import arrow.core.extensions.option.eq.eq
 import arrow.core.extensions.show
 import arrow.core.test.UnitSpec
@@ -47,13 +44,10 @@ import arrow.core.test.laws.ShowLaws
 import arrow.core.test.laws.TraverseLaws
 import arrow.core.test.laws.UnalignLaws
 import arrow.core.test.laws.UnzipLaws
-import arrow.core.test.laws.equalUnderTheLaw
 import arrow.typeclasses.Eq
 import io.kotlintest.properties.Gen
 import io.kotlintest.properties.forAll
 import io.kotlintest.shouldBe
-import kotlin.math.max
-import kotlin.math.min
 import arrow.core.extensions.list.monad.flatten as monadFlatten
 import arrow.core.extensions.listk.monad.flatten as kMonadFlatten
 
@@ -128,164 +122,6 @@ class ListKTest : UnitSpec() {
       a.kMonadFlatten() shouldBe listOf(0, 1, 2, 3, 4, 5)
     }
 
-    "can align lists with different lengths" {
-      forAll(Gen.listK(Gen.bool()), Gen.listK(Gen.bool())) { a, b ->
-        ListK.semialign().run {
-          align(a, b).fix().size == max(a.size, b.size)
-        }
-      }
-
-      forAll(Gen.listK(Gen.bool()), Gen.listK(Gen.bool())) { a, b ->
-        ListK.semialign().run {
-          align(a, b).fix().take(min(a.size, b.size)).all {
-            it.isBoth
-          }
-        }
-      }
-
-      forAll(Gen.listK(Gen.bool()), Gen.listK(Gen.bool())) { a, b ->
-        ListK.semialign().run {
-          align(a, b).fix().drop(min(a.size, b.size)).all {
-            if (a.size < b.size) {
-              it.isRight
-            } else {
-              it.isLeft
-            }
-          }
-        }
-      }
-    }
-
-    "lpadzip" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-
-        val result =
-          a.lpadZip(b)
-
-        result.map { it.b }.equalUnderTheLaw(b, ListK.eq(Int.eq()))
-      }
-    }
-
-    "lpadzipwith" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-
-        val result =
-          a.lpadZipWith(b) { a, b ->
-            a toT b
-          }
-
-        result.map { it.b }.equalUnderTheLaw(b, ListK.eq(Int.eq()))
-      }
-    }
-
-    "leftPadZip (with map)" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-        val left = a.map { it }.k() + List(max(0, b.count() - a.count())) { null }.k()
-        val right = b.map { it }.k() + List(max(0, a.count() - b.count())) { null }.k()
-
-        val result =
-          a.leftPadZip(b) { a, b ->
-            a toT b
-          }
-
-        result == left.zipWith(right) { l, r -> l toT r }.filter { it.b != null }
-      }
-    }
-
-    "leftPadZip (without map)" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-        val left = a.map { it }.k() + List(max(0, b.count() - a.count())) { null }.k()
-        val right = b.map { it }.k() + List(max(0, a.count() - b.count())) { null }.k()
-
-        val result = a.leftPadZip(b)
-
-        result == left.zipWith(right) { l, r -> l toT r }.filter { it.b != null }
-      }
-    }
-
-    "rpadzip" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-
-        val result =
-          a.rpadZip(b)
-
-        result.map { it.a }.equalUnderTheLaw(a, ListK.eq(Int.eq()))
-      }
-    }
-
-    "rightPadZip (without map)" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-        val left = a.map { it }.k() + List(max(0, b.count() - a.count())) { null }.k()
-        val right = b.map { it }.k() + List(max(0, a.count() - b.count())) { null }.k()
-
-        val result = a.rightPadZip(b)
-
-        result == left.zipWith(right) { l, r -> l toT r }.filter { it.a != null } &&
-          result.map { it.a }.equalUnderTheLaw(a, ListK.eq(Int.eq()))
-      }
-    }
-
-    "rpadzipwith" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-
-        val result =
-          a.rpadZipWith(b) { a, b ->
-            a toT b
-          }
-
-        result.map { it.a }.equalUnderTheLaw(a, ListK.eq(Int.eq()))
-      }
-    }
-
-    "rightPadZip (with map)" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-        val left = a.map { it }.k() + List(max(0, b.count() - a.count())) { null }.k()
-        val right = b.map { it }.k() + List(max(0, a.count() - b.count())) { null }.k()
-
-        val result =
-          a.rightPadZip(b) { a, b ->
-            a toT b
-          }
-
-        result == left.zipWith(right) { l, r -> l toT r }.filter { it.a != null } &&
-          result.map { it.a }.equalUnderTheLaw(a, ListK.eq(Int.eq()))
-      }
-    }
-
-    "padZip" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-        val left = a.map { Some(it) }.k() + List(max(0, b.count() - a.count())) { None }.k()
-        val right = b.map { Some(it) }.k() + List(max(0, a.count() - b.count())) { None }.k()
-
-        a.padZip(b) == left.zipWith(right) { l, r -> l toT r }
-      }
-    }
-
-    "padZipWith" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-        val left = a.map { Some(it) }.k() + List(max(0, b.count() - a.count())) { None }.k()
-        val right = b.map { Some(it) }.k() + List(max(0, a.count() - b.count())) { None }.k()
-        a.padZipWith(b) { l, r -> Ior.fromOptions(l, r) } == left.zipWith(right) { l, r -> Ior.fromOptions(l, r) }
-      }
-    }
-
-    "padZip (with map)" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-        val left = a.map { it }.k() + List(max(0, b.count() - a.count())) { null }.k()
-        val right = b.map { it }.k() + List(max(0, a.count() - b.count())) { null }.k()
-        a.padZip(b) { l, r -> Ior.fromNullables(l, r) } == left.zipWith(right) { l, r -> Ior.fromNullables(l, r) }
-      }
-    }
-
-    "padZipWithNull" {
-      forAll(Gen.listK(Gen.int()), Gen.listK(Gen.int())) { a, b ->
-        val left = a.map { it }.k() + List(max(0, b.count() - a.count())) { null }.k()
-        val right = b.map { it }.k() + List(max(0, a.count() - b.count())) { null }.k()
-
-        a.padZipWithNull(b) == left.zipWith(right) { l, r -> l toT r }
-      }
-    }
-
     "filterMap() should map list and filter out None values" {
       forAll(Gen.listK(Gen.int())) { listk ->
         listk.filterMap {
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/align/ListKAlign.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/align/ListKAlign.kt
new file mode 100644
index 000000000..f12bf35eb
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/align/ListKAlign.kt
@@ -0,0 +1,33 @@
+package arrow.core.extensions.list.align
+
+import arrow.core.extensions.ListKAlign
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("empty")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("emptyList()"))
+fun <A> empty(): List<A> =
+  emptyList()
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val align_singleton: ListKAlign = object : arrow.core.extensions.ListKAlign {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Align typeclasses is deprecated. Use concrete methods on List")
+  inline fun align(): ListKAlign = align_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/alternative/ListKAlternative.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/alternative/ListKAlternative.kt
new file mode 100644
index 000000000..114660026
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/alternative/ListKAlternative.kt
@@ -0,0 +1,126 @@
+package arrow.core.extensions.list.alternative
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.None
+import arrow.core.Option
+import arrow.core.SequenceK
+import arrow.core.Some
+import arrow.core.extensions.ListKAlternative
+import arrow.core.fix
+import kotlin.Boolean
+import kotlin.Function0
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("some")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("This method results in StackOverflow")
+fun <A> List<A>.some(): List<SequenceK<A>> =
+    arrow.core.extensions.list.alternative.List.alternative().run {
+  arrow.core.ListK(this@some).some<A>() as kotlin.collections.List<arrow.core.SequenceK<A>>
+}
+
+@JvmName("many")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("This method results in StackOverflow")
+fun <A> List<A>.many(): List<SequenceK<A>> =
+  arrow.core.extensions.list.alternative.List.alternative().run {
+    arrow.core.ListK(this@many).many<A>() as kotlin.collections.List<arrow.core.SequenceK<A>>
+  }
+
+@JvmName("alt")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("this + arg1"))
+infix fun <A> List<A>.alt(arg1: List<A>): List<A> =
+  this + arg1
+
+@JvmName("orElse")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("this + arg1"))
+fun <A> List<A>.orElse(arg1: List<A>): List<A> =
+  this + arg1
+
+@JvmName("combineK")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("this + arg1"))
+fun <A> List<A>.combineK(arg1: List<A>): List<A> =
+  this + arg1
+
+@JvmName("optional")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("map(::Some) + listOf(None)", "arrow.core.Some", "arrow.core.None"))
+fun <A> List<A>.optional(): List<Option<A>> =
+  map(::Some) + listOf(None)
+
+@JvmName("guard")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("if (arg0) listOf(Unit) else emptyList()"))
+fun guard(arg0: Boolean): List<Unit> =
+  if (arg0) listOf(Unit) else emptyList()
+
+@JvmName("lazyOrElse")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("this + arg1()"))
+fun <A> List<A>.lazyOrElse(arg1: Function0<Kind<ForListK, A>>): List<A> =
+  this + arg1().fix()
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val alternative_singleton: ListKAlternative = object :
+  arrow.core.extensions.ListKAlternative {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Alternative typeclasses is deprecated. Use concrete methods on List")
+  inline fun alternative(): ListKAlternative = alternative_singleton
+}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/applicative/ListKApplicative.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/applicative/ListKApplicative.kt
new file mode 100644
index 000000000..2d1beb57e
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/applicative/ListKApplicative.kt
@@ -0,0 +1,85 @@
+package arrow.core.extensions.list.applicative
+
+import arrow.core.extensions.ListKApplicative
+import arrow.typeclasses.Monoid
+import arrow.core.replicate as _replicate
+import kotlin.Function1
+import kotlin.collections.map as _map
+import kotlin.Int
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("just1")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("listOf(this)"))
+fun <A> A.just(): List<A> =
+  listOf(this)
+
+@JvmName("unit")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("listOf(Unit)"))
+fun unit(): List<Unit> =
+  listOf(Unit)
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("map(arg1)"))
+fun <A, B> List<A>.map(arg1: Function1<A, B>): List<B> =
+  _map(arg1)
+
+@JvmName("replicate")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("replicate(arg1)", "arrow.core.replicate"))
+fun <A> List<A>.replicate(arg1: Int): List<List<A>> =
+  _replicate(arg1)
+
+@JvmName("replicate")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("replicate(arg1, arg2)", "arrow.core.replicate"))
+fun <A> List<A>.replicate(arg1: Int, arg2: Monoid<A>): List<A> =
+  _replicate(arg1, arg2)
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val applicative_singleton: ListKApplicative = object :
+  arrow.core.extensions.ListKApplicative {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Applicative typeclasses is deprecated. Use concrete methods on List")
+  inline fun applicative(): ListKApplicative = applicative_singleton
+}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/apply/ListKApply.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/apply/ListKApply.kt
new file mode 100644
index 000000000..150fbaa19
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/apply/ListKApply.kt
@@ -0,0 +1,873 @@
+package arrow.core.extensions.list.apply
+
+import arrow.Kind
+import arrow.core.Eval
+import arrow.core.ap as _ap
+import arrow.core.map2 as _map2
+import arrow.core.product as _product
+import kotlin.collections.flatMap as _flatMap
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.Tuple10
+import arrow.core.Tuple2
+import arrow.core.Tuple3
+import arrow.core.Tuple4
+import arrow.core.Tuple5
+import arrow.core.Tuple6
+import arrow.core.Tuple7
+import arrow.core.Tuple8
+import arrow.core.Tuple9
+import arrow.core.extensions.ListKApply
+import arrow.core.fix
+import arrow.core.k
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("ap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("_ap(arg1)", "arrow.core.ap"))
+fun <A, B> List<A>.ap(arg1: List<Function1<A, B>>): List<B> =
+  _ap(arg1)
+
+@JvmName("apEval")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("arg1.map { this.ap(it.fix()) }.map { it.k() }", "arrow.core.k", "arrow.core.fix"))
+fun <A, B> List<A>.apEval(arg1: Eval<Kind<ForListK, Function1<A, B>>>): Eval<Kind<ForListK, B>> =
+  arg1.map { this.ap(it.fix()) }.map { it.k() }
+
+@JvmName("map2Eval")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("apEval(arg1.map { it.fix().map { b -> { a: A -> arg2(Tuple2(a, b)) } } })", "arrow.core.k", "arrow.core.Tuple2"))
+fun <A, B, Z> List<A>.map2Eval(arg1: Eval<Kind<ForListK, B>>, arg2: Function1<Tuple2<A, B>, Z>):
+  Eval<Kind<ForListK, Z>> =
+  apEval(arg1.map { it.fix().map { b -> { a: A -> arg2(Tuple2(a, b)) } } })
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1).map(arg2)", "arrow.core.tupledN"))
+fun <A, B, Z> map(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: Function1<Tuple2<A, B>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1).map(arg2)
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1).map(arg2)", "arrow.core.tupledN"))
+fun <A, B, Z> mapN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: Function1<Tuple2<A, B>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1).map(arg2)
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2).map(arg3)", "arrow.core.tupledN"))
+fun <A, B, C, Z> map(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: Function1<Tuple3<A, B, C>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2).map(arg3)
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2).map(arg3)", "arrow.core.tupledN"))
+fun <A, B, C, Z> mapN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: Function1<Tuple3<A, B, C>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2).map(arg3)
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3).map(arg4)", "arrow.core.tupledN"))
+fun <A, B, C, D, Z> map(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: Function1<Tuple4<A, B, C, D>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3).map(arg4)
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3).map(arg4)", "arrow.core.tupledN"))
+fun <A, B, C, D, Z> mapN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: Function1<Tuple4<A, B, C, D>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3).map(arg4)
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4).map(arg5)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, Z> map(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: Function1<Tuple5<A, B, C, D, E>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4).map(arg5)
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4).map(arg5)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, Z> mapN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: Function1<Tuple5<A, B, C, D, E>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4).map(arg5)
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5).map(arg6)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, Z> map(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: Function1<Tuple6<A, B, C, D, E, FF>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5).map(arg6)
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5).map(arg6)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, Z> mapN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: Function1<Tuple6<A, B, C, D, E, FF>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5).map(arg6)
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6).map(arg7)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, Z> map(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: Function1<Tuple7<A, B, C, D, E, FF, G>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6).map(arg7)
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6).map(arg7)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, Z> mapN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: Function1<Tuple7<A, B, C, D, E, FF, G>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6).map(arg7)
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7).map(arg8)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, Z> map(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>,
+  arg8: Function1<Tuple8<A, B, C, D, E, FF, G, H>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7).map(arg8)
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7).map(arg8)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, Z> mapN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>,
+  arg8: Function1<Tuple8<A, B, C, D, E, FF, G, H>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7).map(arg8)
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8).map(arg9)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, Z> map(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>,
+  arg8: List<I>,
+  arg9: Function1<Tuple9<A, B, C, D, E, FF, G, H, I>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8).map(arg9)
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8).map(arg9)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, Z> mapN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>,
+  arg8: List<I>,
+  arg9: Function1<Tuple9<A, B, C, D, E, FF, G, H, I>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8).map(arg9)
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9).map(arg10)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, J, Z> map(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>,
+  arg8: List<I>,
+  arg9: List<J>,
+  arg10: Function1<Tuple10<A, B, C, D, E, FF, G, H, I, J>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9).map(arg10)
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9).map(arg10)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, J, Z> mapN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>,
+  arg8: List<I>,
+  arg9: List<J>,
+  arg10: Function1<Tuple10<A, B, C, D, E, FF, G, H, I, J>, Z>
+): List<Z> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9).map(arg10)
+
+@JvmName("map2")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("map2(arg1, arg2)", "arrow.core.map2"))
+fun <A, B, Z> List<A>.map2(arg1: List<B>, arg2: Function1<Tuple2<A, B>, Z>): List<Z> =
+  _map2(arg1, arg2)
+
+@JvmName("product")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B> List<A>.product(arg1: List<B>): List<Tuple2<A, B>> =
+  _product(arg1)
+
+@JvmName("product1")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, Z> List<Tuple2<A, B>>.product(arg1: List<Z>): List<Tuple3<A, B, Z>> =
+  _product(arg1)
+
+@JvmName("product2")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, Z> List<Tuple3<A, B, C>>.product(arg1: List<Z>): List<Tuple4<A, B, C, Z>> =
+  _product(arg1)
+
+@JvmName("product3")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, Z> List<Tuple4<A, B, C, D>>.product(arg1: List<Z>): List<Tuple5<A, B, C, D, Z>> =
+  _product(arg1)
+
+@JvmName("product4")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, E, Z> List<Tuple5<A, B, C, D, E>>.product(arg1: List<Z>): List<Tuple6<A, B, C, D, E, Z>> =
+  _product(arg1)
+
+@JvmName("product5")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, E, FF, Z> List<Tuple6<A, B, C, D, E, FF>>.product(arg1: List<Z>): List<Tuple7<A, B,
+  C, D, E, FF, Z>> =
+  _product(arg1)
+
+@JvmName("product6")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, E, FF, G, Z> List<Tuple7<A, B, C, D, E, FF, G>>.product(arg1: List<Z>):
+  List<Tuple8<A, B, C, D, E, FF, G, Z>> =
+  _product(arg1)
+
+@JvmName("product7")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, E, FF, G, H, Z> List<Tuple8<A, B, C, D, E, FF, G, H>>.product(arg1: List<Z>):
+  List<Tuple9<A, B, C, D, E, FF, G, H, Z>> =
+  _product(arg1)
+
+@JvmName("product8")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, E, FF, G, H, I, Z> List<Tuple9<A, B, C, D, E, FF, G, H, I>>.product(arg1: List<Z>):
+  List<Tuple10<A, B, C, D, E, FF, G, H, I, Z>> =
+  _product(arg1)
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1)", "arrow.core.tupledN"))
+fun <A, B> tupled(arg0: List<A>, arg1: List<B>): List<Tuple2<A, B>> =
+  ListK.tupledN(arg0, arg1)
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1)", "arrow.core.tupledN"))
+fun <A, B> tupledN(arg0: List<A>, arg1: List<B>): List<Tuple2<A, B>> =
+  ListK.tupledN(arg0, arg1)
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2)", "arrow.core.tupledN"))
+fun <A, B, C> tupled(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>
+): List<Tuple3<A, B, C>> =
+  ListK.tupledN(arg0, arg1, arg2)
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2)", "arrow.core.tupledN"))
+fun <A, B, C> tupledN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>
+): List<Tuple3<A, B, C>> =
+  ListK.tupledN(arg0, arg1, arg2)
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3)", "arrow.core.tupledN"))
+fun <A, B, C, D> tupled(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>
+): List<Tuple4<A, B, C, D>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3)
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3)", "arrow.core.tupledN"))
+fun <A, B, C, D> tupledN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>
+): List<Tuple4<A, B, C, D>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3)
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4)", "arrow.core.tupledN"))
+fun <A, B, C, D, E> tupled(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>
+): List<Tuple5<A, B, C, D, E>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4)
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4)", "arrow.core.tupledN"))
+fun <A, B, C, D, E> tupledN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>
+): List<Tuple5<A, B, C, D, E>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4)
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF> tupled(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>
+): List<Tuple6<A, B, C, D, E, FF>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5)
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF> tupledN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>
+): List<Tuple6<A, B, C, D, E, FF>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5)
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G> tupled(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>
+): List<Tuple7<A, B, C, D, E, FF, G>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G> tupledN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>
+): List<Tuple7<A, B, C, D, E, FF, G>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H> tupled(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>
+): List<Tuple8<A, B, C, D, E, FF, G, H>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H> tupledN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>
+): List<Tuple8<A, B, C, D, E, FF, G, H>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I> tupled(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>,
+  arg8: List<I>
+): List<Tuple9<A, B, C, D, E, FF, G, H, I>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I> tupledN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>,
+  arg8: List<I>
+): List<Tuple9<A, B, C, D, E, FF, G, H, I>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, J> tupled(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>,
+  arg8: List<I>,
+  arg9: List<J>
+): List<Tuple10<A, B, C, D, E, FF, G, H, I, J>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, J> tupledN(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: List<C>,
+  arg3: List<D>,
+  arg4: List<E>,
+  arg5: List<FF>,
+  arg6: List<G>,
+  arg7: List<H>,
+  arg8: List<I>,
+  arg9: List<J>
+): List<Tuple10<A, B, C, D, E, FF, G, H, I, J>> =
+  ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+
+@JvmName("followedBy")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("flatMap { arg1 }"))
+fun <A, B> List<A>.followedBy(arg1: List<B>): List<B> =
+  _flatMap { arg1 }
+
+@JvmName("apTap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.mapN(this, arg1) { left, _ -> left }", "arrow.core.mapN"))
+fun <A, B> List<A>.apTap(arg1: List<B>): List<A> =
+  ListK.mapN(this, arg1) { left, _ -> left }
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val apply_singleton: ListKApply = object : arrow.core.extensions.ListKApply {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Apply typeclasses is deprecated. Use concrete methods on List")
+  inline fun apply(): ListKApply = apply_singleton
+}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/crosswalk/ListKCrosswalk.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/crosswalk/ListKCrosswalk.kt
new file mode 100644
index 000000000..10e8c6272
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/crosswalk/ListKCrosswalk.kt
@@ -0,0 +1,57 @@
+package arrow.core.extensions.list.crosswalk
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.extensions.ListKCrosswalk
+import arrow.typeclasses.Align
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("crosswalk")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with crosswalk, crosswalkMap or crosswalkNull from arrow.core.*")
+fun <F, A, B> crosswalk(
+  arg0: Align<F>,
+  arg1: List<A>,
+  arg2: Function1<A, Kind<F, B>>
+): Kind<F, Kind<ForListK, B>> = arrow.core.extensions.list.crosswalk.List
+   .crosswalk()
+   .crosswalk<F, A, B>(arg0, arrow.core.ListK(arg1), arg2) as arrow.Kind<F,
+    arrow.Kind<arrow.core.ForListK, B>>
+
+@JvmName("sequenceL")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with sequenceValidated or sequenceEither from arrow.core.*")
+fun <F, A> sequenceL(arg0: Align<F>, arg1: List<Kind<F, A>>): Kind<F, Kind<ForListK, A>> =
+    arrow.core.extensions.list.crosswalk.List
+   .crosswalk()
+   .sequenceL<F, A>(arg0, arrow.core.ListK(arg1)) as arrow.Kind<F, arrow.Kind<arrow.core.ForListK,
+    A>>
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val crosswalk_singleton: ListKCrosswalk = object : arrow.core.extensions.ListKCrosswalk {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Crosswalk typeclasses is deprecated. Use concrete methods on List")
+  inline fun crosswalk(): ListKCrosswalk = crosswalk_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/eq/ListKEq.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/eq/ListKEq.kt
new file mode 100644
index 000000000..5c180e521
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/eq/ListKEq.kt
@@ -0,0 +1,42 @@
+package arrow.core.extensions.list.eq
+
+import arrow.core.extensions.ListKEq
+import arrow.typeclasses.Eq
+import arrow.core.eqv as _eqv
+import arrow.core.neqv as _neqv
+import kotlin.Boolean
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("eqv")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("neqv(EQL, EQR, arg1)", "arrow.core.neqv"))
+fun <A> List<A>.eqv(EQ: Eq<A>, arg1: List<A>): Boolean =
+  _eqv(EQ, arg1)
+
+@JvmName("neqv")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("neqv(EQL, EQR, arg1)", "arrow.core.neqv"))
+fun <A> List<A>.neqv(EQ: Eq<A>, arg1: List<A>): Boolean =
+  _neqv(EQ, arg1)
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("@extension projected functions are deprecated", ReplaceWith("listEq(EQ)", "arrow.core.listEq"))
+  inline fun <A> eq(EQ: Eq<A>): ListKEq<A> = object : arrow.core.extensions.ListKEq<A> { override
+      fun EQ(): arrow.typeclasses.Eq<A> = EQ }}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/eqK/ListKEqK.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/eqK/ListKEqK.kt
new file mode 100644
index 000000000..f7bf8a5dd
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/eqK/ListKEqK.kt
@@ -0,0 +1,51 @@
+package arrow.core.extensions.list.eqK
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.extensions.ListKEqK
+import arrow.typeclasses.Eq
+import kotlin.Boolean
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("eqK")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+fun <A> List<A>.eqK(arg1: List<A>, arg2: Eq<A>): Boolean =
+    arrow.core.extensions.list.eqK.List.eqK().run {
+  arrow.core.ListK(this@eqK).eqK<A>(arrow.core.ListK(arg1), arg2) as kotlin.Boolean
+}
+
+@JvmName("liftEq")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+fun <A> liftEq(arg0: Eq<A>): Eq<Kind<ForListK, A>> = arrow.core.extensions.list.eqK.List
+   .eqK()
+   .liftEq<A>(arg0) as arrow.typeclasses.Eq<arrow.Kind<arrow.core.ForListK, A>>
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val eqK_singleton: ListKEqK = object : arrow.core.extensions.ListKEqK {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+  inline fun eqK(): ListKEqK = eqK_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/foldable/ListKFoldable.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/foldable/ListKFoldable.kt
new file mode 100644
index 000000000..e645f45a1
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/foldable/ListKFoldable.kt
@@ -0,0 +1,346 @@
+package arrow.core.extensions.list.foldable
+
+import arrow.Kind
+import arrow.core.Eval
+import arrow.core.foldRight as _foldRight
+import arrow.core.ForListK
+import arrow.core.Option
+import arrow.core.combineAll as _combineAll
+import arrow.core.foldMap as _foldMap
+import arrow.core.extensions.ListKFoldable
+import arrow.core.reduceOrNull
+import arrow.core.reduceRightEvalOrNull
+import arrow.typeclasses.Applicative
+import arrow.typeclasses.Monad
+import arrow.typeclasses.Monoid
+import kotlin.collections.all as _all
+import kotlin.collections.isNotEmpty as _isNotEmpty
+import kotlin.Boolean
+import kotlin.Function1
+import kotlin.Function2
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("foldLeft")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("fold(arg1, arg2)"))
+fun <A, B> List<A>.foldLeft(arg1: B, arg2: Function2<B, A, B>): B =
+  fold(arg1, arg2)
+
+@JvmName("foldRight")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("foldRight(arg1, arg2)", "arrow.core.foldRight"))
+fun <A, B> List<A>.foldRight(arg1: Eval<B>, arg2: Function2<A, Eval<B>, Eval<B>>): Eval<B> =
+  _foldRight(arg1, arg2)
+
+@JvmName("fold")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("combineAll(arg1)", "arrow.core.combineAll"))
+fun <A> List<A>.fold(arg1: Monoid<A>): A =
+  _combineAll(arg1)
+
+@JvmName("reduceLeftToOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(reduceNullable(arg1, arg2))", "arrow.core.reduceNullable", "arrow.core.Option"))
+fun <A, B> List<A>.reduceLeftToOption(arg1: Function1<A, B>, arg2: Function2<B, A, B>): Option<B> =
+  Option.fromNullable(reduceOrNull(arg1, arg2))
+
+@JvmName("reduceRightToOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("reduceRightNullable(arg1, arg2).map { Option.fromNullable(it) }", "arrow.core.reduceRightNullable", "arrow.core.Option"))
+fun <A, B> List<A>.reduceRightToOption(arg1: Function1<A, B>, arg2: Function2<A, Eval<B>, Eval<B>>): Eval<Option<B>> =
+  reduceRightEvalOrNull(arg1, arg2).map { Option.fromNullable(it) }
+
+@JvmName("reduceLeftOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith(" Option.fromNullable(reduceNullable({ it }, arg1))", "arrow.core.reduceNullable", "arrow.core.Option"))
+fun <A> List<A>.reduceLeftOption(arg1: Function2<A, A, A>): Option<A> =
+  Option.fromNullable(reduceOrNull({ it }, arg1))
+
+@JvmName("reduceRightOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("reduceRightOption({ it }, arg2).map { Option.fromNullable(it) }", "arrow.core.reduceRightNullable", "arrow.core.Option"))
+fun <A> List<A>.reduceRightOption(arg1: Function2<A, Eval<A>, Eval<A>>): Eval<Option<A>> =
+  reduceRightEvalOrNull({ it }, arg1).map { Option.fromNullable(it) }
+
+@JvmName("combineAll")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("combineAll(arg1)", "arrow.core.combineAll"))
+fun <A> List<A>.combineAll(arg1: Monoid<A>): A =
+  _combineAll(arg1)
+
+@JvmName("foldMap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("foldMap(arg1, arg2)", "arrow.core.foldMap"))
+fun <A, B> List<A>.foldMap(arg1: Monoid<B>, arg2: Function1<A, B>): B =
+  _foldMap(arg1, arg2)
+
+@JvmName("orEmpty")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listOf(arg1.empty())"))
+fun <A> orEmpty(arg0: Applicative<ForListK>, arg1: Monoid<A>): List<A> =
+  listOf(arg1.empty())
+
+@JvmName("traverse_")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with traverseValidated_ or traverseEither_ from arrow.core.*")
+fun <G, A, B> List<A>.traverse_(arg1: Applicative<G>, arg2: Function1<A, Kind<G, B>>): Kind<G, Unit> =
+  arrow.core.extensions.list.foldable.List.foldable().run {
+    arrow.core.ListK(this@traverse_).traverse_<G, A, B>(arg1, arg2) as arrow.Kind<G, kotlin.Unit>
+  }
+
+@JvmName("sequence_")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with sequenceValidated_ or sequenceEither_ from arrow.core.*")
+fun <G, A> List<Kind<G, A>>.sequence_(arg1: Applicative<G>): Kind<G, Unit> =
+  arrow.core.extensions.list.foldable.List.foldable().run {
+    arrow.core.ListK(this@sequence_).sequence_<G, A>(arg1) as arrow.Kind<G, kotlin.Unit>
+  }
+
+@JvmName("find")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(firstOrNull(arg1))", "arrow.core.Option"))
+fun <A> List<A>.find(arg1: Function1<A, Boolean>): Option<A> =
+  Option.fromNullable(firstOrNull(arg1))
+
+@JvmName("exists")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("any(arg1)"))
+fun <A> List<A>.exists(arg1: Function1<A, Boolean>): Boolean =
+  any(arg1)
+
+@JvmName("forAll")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("all(arg1)"))
+fun <A> List<A>.forAll(arg1: Function1<A, Boolean>): Boolean =
+  _all(arg1)
+
+@JvmName("all")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("all(arg1)"))
+fun <A> List<A>.all(arg1: Function1<A, Boolean>): Boolean =
+  _all(arg1)
+
+@JvmName("nonEmpty")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("isNotEmpty()"))
+fun <A> List<A>.nonEmpty(): Boolean =
+  _isNotEmpty()
+
+@JvmName("isNotEmpty")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("isNotEmpty()"))
+fun <A> List<A>.isNotEmpty(): Boolean =
+  _isNotEmpty()
+
+@JvmName("foldMapA")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Applicative typeclasses is deprecated. Use concrete methods on List")
+fun <G, A, B, AP : Applicative<G>, MO : Monoid<B>> List<A>.foldMapA(
+  arg1: AP,
+  arg2: MO,
+  arg3: Function1<A, Kind<G, B>>
+): Kind<G, B> = arrow.core.extensions.list.foldable.List.foldable().run {
+  arrow.core.ListK(this@foldMapA).foldMapA<G, A, B, AP, MO>(arg1, arg2, arg3) as arrow.Kind<G, B>
+}
+
+@JvmName("foldMapM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Applicative typeclasses is deprecated. Use concrete methods on List")
+fun <G, A, B, MA : Monad<G>, MO : Monoid<B>> List<A>.foldMapM(
+  arg1: MA,
+  arg2: MO,
+  arg3: Function1<A, Kind<G, B>>
+): Kind<G, B> = arrow.core.extensions.list.foldable.List.foldable().run {
+  arrow.core.ListK(this@foldMapM).foldMapM<G, A, B, MA, MO>(arg1, arg2, arg3) as arrow.Kind<G, B>
+}
+
+@JvmName("foldM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Applicative typeclasses is deprecated. Use concrete methods on List")
+fun <G, A, B> List<A>.foldM(
+  arg1: Monad<G>,
+  arg2: B,
+  arg3: Function2<B, A, Kind<G, B>>
+): Kind<G, B> = arrow.core.extensions.list.foldable.List.foldable().run {
+  arrow.core.ListK(this@foldM).foldM<G, A, B>(arg1, arg2, arg3) as arrow.Kind<G, B>
+}
+
+@JvmName("firstOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(firstOrNull())", "arrow.core.Option"))
+fun <A> List<A>.firstOption(): Option<A> =
+  Option.fromNullable(firstOrNull())
+
+@JvmName("firstOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(firstOrNull(arg1))", "arrow.core.Option"))
+fun <A> List<A>.firstOption(arg1: Function1<A, Boolean>): Option<A> =
+  Option.fromNullable(firstOrNull(arg1))
+
+@JvmName("firstOrNone")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(firstOrNull())", "arrow.core.Option"))
+fun <A> List<A>.firstOrNone(): Option<A> =
+  Option.fromNullable(firstOrNull())
+
+@JvmName("firstOrNone")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(firstOrNull(arg1))", "arrow.core.Option"))
+fun <A> List<A>.firstOrNone(arg1: Function1<A, Boolean>): Option<A> =
+  Option.fromNullable(firstOrNull(arg1))
+
+@JvmName("toList")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("this"))
+fun <A> List<A>.toList(): List<A> =
+  this
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val foldable_singleton: ListKFoldable = object : arrow.core.extensions.ListKFoldable {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Foldable typeclasses is deprecated. Use concrete methods on List")
+  inline fun foldable(): ListKFoldable = foldable_singleton
+}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/functor/ListKFunctor.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/functor/ListKFunctor.kt
new file mode 100644
index 000000000..27b7e2f9d
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/functor/ListKFunctor.kt
@@ -0,0 +1,194 @@
+package arrow.core.extensions.list.functor
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.void as _void
+import arrow.core.fproduct as _fproduct
+import arrow.core.mapConst as _mapConst
+import arrow.core.tupleLeft as _tupleLeft
+import arrow.core.tupleRight as _tupleRight
+import arrow.core.widen as _widen
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKFunctor
+import kotlin.Function1
+import kotlin.collections.map as _map
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+/**
+ *  Transform the [F] wrapped value [A] into [B] preserving the [F] structure
+ *  Kind<F, A> -> Kind<F, B>
+ *
+ *  ```kotlin:ank:playground
+ *  import arrow.core.*
+ * import arrow.core.extensions.listk.functor.*
+ * import arrow.core.*
+ *
+ *
+ *  import arrow.core.extensions.listk.applicative.just
+ *
+ *  fun main(args: Array<String>) {
+ *   val result =
+ *   //sampleStart
+ *   "Hello".just().map({ "$it World" })
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ */
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("map(arg1)"))
+fun <A, B> List<A>.map(arg1: Function1<A, B>): List<B> =
+  _map(arg1)
+
+@JvmName("imap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("map(arg1)"))
+fun <A, B> List<A>.imap(arg1: Function1<A, B>, arg2: Function1<B, A>): List<B> =
+  _map(arg1)
+
+/**
+ *  Lifts a function `A -> B` to the [F] structure returning a polymorphic function
+ *  that can be applied over all [F] values in the shape of Kind<F, A>
+ *
+ *  `A -> B -> Kind<F, A> -> Kind<F, B>`
+ *
+ *  ```kotlin:ank:playground
+ *  import arrow.core.*
+ * import arrow.core.extensions.listk.functor.*
+ * import arrow.core.*
+ *
+ *
+ *  import arrow.core.extensions.listk.applicative.just
+ *
+ *  fun main(args: Array<String>) {
+ *   val result =
+ *   //sampleStart
+ *   lift({ s: CharSequence -> "$s World" })("Hello".just())
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ */
+@JvmName("lift")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("{ l: List<A> -> l.map(arg0) }"))
+fun <A, B> lift(arg0: Function1<A, B>): Function1<Kind<ForListK, A>, Kind<ForListK, B>> =
+    arrow.core.extensions.list.functor.List
+   .functor()
+   .lift<A, B>(arg0) as kotlin.Function1<arrow.Kind<arrow.core.ForListK, A>,
+    arrow.Kind<arrow.core.ForListK, B>>
+
+@JvmName("void")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("void()", "arrow.core.void"))
+fun <A> List<A>.void(): List<Unit> =
+  _void()
+
+@JvmName("fproduct")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("fproduct(arg1)", "arrow.core.fproduct"))
+fun <A, B> List<A>.fproduct(arg1: Function1<A, B>): List<Tuple2<A, B>> =
+  _fproduct(arg1)
+
+@JvmName("mapConst")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("mapConst(arg1)", "arrow.core.mapConst"))
+fun <A, B> List<A>.mapConst(arg1: B): List<B> =
+  _mapConst(arg1)
+
+/**
+ *  Replaces the [B] value inside [F] with [A] resulting in a Kind<F, A>
+ */
+@JvmName("mapConst")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg1.mapConst(this)", "arrow.core.mapConst"))
+fun <A, B> A.mapConst(arg1: List<B>): List<A> =
+  arg1._mapConst(this)
+
+@JvmName("tupleLeft")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("tupleLeft(arg1)", "arrow.core.tupleLeft"))
+fun <A, B> List<A>.tupleLeft(arg1: B): List<Tuple2<B, A>> =
+  _tupleLeft(arg1)
+
+@JvmName("tupleRight")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("tupleRight(arg1)", "arrow.core.tupleRight"))
+fun <A, B> List<A>.tupleRight(arg1: B): List<Tuple2<A, B>> =
+  _tupleRight(arg1)
+
+@JvmName("widen")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("widen()", "arrow.core.widen"))
+fun <B, A : B> List<A>.widen(): List<B> =
+  _widen()
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val functor_singleton: ListKFunctor = object : arrow.core.extensions.ListKFunctor {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Functor typeclasses is deprecated. Use concrete methods on List")
+  inline fun functor(): ListKFunctor = functor_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/functorFilter/ListKFunctorFilter.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/functorFilter/ListKFunctorFilter.kt
new file mode 100644
index 000000000..2fa016c3b
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/functorFilter/ListKFunctorFilter.kt
@@ -0,0 +1,72 @@
+package arrow.core.extensions.list.functorFilter
+
+import arrow.core.Option
+import arrow.core.extensions.ListKFunctorFilter
+import java.lang.Class
+import kotlin.Boolean
+import kotlin.collections.filter as _filter
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("filterMap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("mapNotNull { arg1(it).orNull() }"))
+fun <A, B> List<A>.filterMap(arg1: Function1<A, Option<B>>): List<B> =
+  mapNotNull { arg1(it).orNull() }
+
+@JvmName("flattenOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("mapNotNull { it.orNull() }"))
+fun <A> List<Option<A>>.flattenOption(): List<A> =
+  mapNotNull { it.orNull() }
+
+@JvmName("filter")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("filter(arg1)"))
+fun <A> List<A>.filter(arg1: Function1<A, Boolean>): List<A> =
+  _filter(arg1)
+
+@JvmName("filterIsInstance")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("filter(arg1::isInstance).map { arg1.cast(it) }"))
+fun <A, B> List<A>.filterIsInstance(arg1: Class<B>): List<B> =
+  _filter(arg1::isInstance).map { arg1.cast(it) }
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val functorFilter_singleton: ListKFunctorFilter = object :
+    arrow.core.extensions.ListKFunctorFilter {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Functor typeclasses is deprecated. Use concrete methods on List")
+  inline fun functorFilter(): ListKFunctorFilter = functorFilter_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/hash/ListKHash.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/hash/ListKHash.kt
new file mode 100644
index 000000000..6028596b2
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/hash/ListKHash.kt
@@ -0,0 +1,42 @@
+package arrow.core.extensions.list.hash
+
+import arrow.core.extensions.ListKHash
+import arrow.typeclasses.Hash
+import arrow.core.hash as _hash
+import arrow.core.hashWithSalt as _hashWithSalt
+import kotlin.Int
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("hash")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("hash(HA)", "arrow.core.hash"))
+fun <A> List<A>.hash(HA: Hash<A>): Int =
+  _hash(HA)
+
+@JvmName("hashWithSalt")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("hashWithSalt(HA, arg1)", "arrow.core.hashWithSalt"))
+fun <A> List<A>.hashWithSalt(HA: Hash<A>, arg1: Int): Int =
+  _hashWithSalt(HA, arg1)
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("@extension projected functions are deprecated", ReplaceWith("listHash(HA)", "arrow.core.listHash"))
+  inline fun <A> hash(HA: Hash<A>): ListKHash<A> = object : arrow.core.extensions.ListKHash<A> {
+      override fun HA(): arrow.typeclasses.Hash<A> = HA }}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/monad/ListKMonad.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monad/ListKMonad.kt
new file mode 100644
index 000000000..4995b5d88
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monad/ListKMonad.kt
@@ -0,0 +1,283 @@
+package arrow.core.extensions.list.monad
+
+import arrow.Kind
+import arrow.core.Either
+import arrow.core.Eval
+import arrow.core.ForListK
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKMonad
+import arrow.core.fix
+import arrow.core.tailRecMIterable
+import kotlin.Boolean
+import kotlin.collections.flatMap as _flatMap
+import kotlin.Function0
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("flatMap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap(arg1)"))
+fun <A, B> List<A>.flatMap(arg1: Function1<A, Kind<ForListK, B>>): List<B> =
+  _flatMap { arg1(it).fix() }
+
+@JvmName("tailRecM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("tailRecMIterable(arg0) { arg1(it) }"))
+fun <A, B> tailRecM(arg0: A, arg1: Function1<A, Kind<ForListK, Either<A, B>>>): List<B> =
+  tailRecMIterable(arg0) { arg1(it).fix() }
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("map(arg1)"))
+fun <A, B> List<A>.map(arg1: Function1<A, B>): List<B> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@map).map<A, B>(arg1) as kotlin.collections.List<B>
+}
+
+/**
+ *  @see [Apply.ap]
+ */
+@JvmName("ap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("ap(arg1)", "arrow.core.ap"))
+fun <A, B> List<A>.ap(arg1: List<Function1<A, B>>): List<B> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@ap).ap<A, B>(arrow.core.ListK(arg1)) as kotlin.collections.List<B>
+}
+
+@JvmName("flatten")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatten"))
+fun <A> List<List<A>>.flatten(): List<A> = arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@flatten).flatten<A>() as kotlin.collections.List<A>
+}
+
+@JvmName("followedBy")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { arg1 }"))
+fun <A, B> List<A>.followedBy(arg1: List<B>): List<B> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@followedBy).followedBy<A, B>(arrow.core.ListK(arg1)) as
+    kotlin.collections.List<B>
+}
+
+@JvmName("apTap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1.map { a } }"))
+fun <A, B> List<A>.apTap(arg1: List<B>): List<A> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@apTap).apTap<A, B>(arrow.core.ListK(arg1)) as kotlin.collections.List<A>
+}
+
+@JvmName("followedByEval")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { arg1.value() }"))
+fun <A, B> List<A>.followedByEval(arg1: Eval<Kind<ForListK, B>>): List<B> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@followedByEval).followedByEval<A, B>(arg1) as kotlin.collections.List<B>
+}
+
+@JvmName("effectM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1(a).map { a } }"))
+fun <A, B> List<A>.effectM(arg1: Function1<A, Kind<ForListK, B>>): List<A> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@effectM).effectM<A, B>(arg1) as kotlin.collections.List<A>
+}
+
+@JvmName("flatTap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1(a).map { a } }"))
+fun <A, B> List<A>.flatTap(arg1: Function1<A, Kind<ForListK, B>>): List<A> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@flatTap).flatTap<A, B>(arg1) as kotlin.collections.List<A>
+}
+
+@JvmName("productL")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1.map { a } }"))
+fun <A, B> List<A>.productL(arg1: List<B>): List<A> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@productL).productL<A, B>(arrow.core.ListK(arg1)) as
+    kotlin.collections.List<A>
+}
+
+@JvmName("forEffect")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1.map { a } }"))
+fun <A, B> List<A>.forEffect(arg1: List<B>): List<A> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@forEffect).forEffect<A, B>(arrow.core.ListK(arg1)) as
+    kotlin.collections.List<A>
+}
+
+@JvmName("productLEval")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1.value().map { a } }"))
+fun <A, B> List<A>.productLEval(arg1: Eval<Kind<ForListK, B>>): List<A> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@productLEval).productLEval<A, B>(arg1) as kotlin.collections.List<A>
+}
+
+@JvmName("forEffectEval")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1.value().map { a } }"))
+fun <A, B> List<A>.forEffectEval(arg1: Eval<Kind<ForListK, B>>): List<A> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@forEffectEval).forEffectEval<A, B>(arg1) as kotlin.collections.List<A>
+}
+
+@JvmName("mproduct")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1(a).map { b -> Tuple2(a, b) } }"))
+fun <A, B> List<A>.mproduct(arg1: Function1<A, Kind<ForListK, B>>): List<Tuple2<A, B>> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@mproduct).mproduct<A, B>(arg1) as
+    kotlin.collections.List<arrow.core.Tuple2<A, B>>
+}
+
+@JvmName("ifM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("ifM(arg1, arg2)", "arrow.core.ifM"))
+fun <B> List<Boolean>.ifM(arg1: Function0<Kind<ForListK, B>>, arg2: Function0<Kind<ForListK, B>>):
+    List<B> = arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@ifM).ifM<B>(arg1, arg2) as kotlin.collections.List<B>
+}
+
+@JvmName("selectM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("selectM(arg1)", "arrow.core.selectM"))
+fun <A, B> List<Either<A, B>>.selectM(arg1: List<Function1<A, B>>): List<B> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@selectM).selectM<A, B>(arrow.core.ListK(arg1)) as kotlin.collections.List<B>
+}
+
+@JvmName("select")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("select(arg1)", "arrow.core.select"))
+fun <A, B> List<Either<A, B>>.select(arg1: List<Function1<A, B>>): List<B> =
+    arrow.core.extensions.list.monad.List.monad().run {
+  arrow.core.ListK(this@select).select<A, B>(arrow.core.ListK(arg1)) as kotlin.collections.List<B>
+}
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monad_singleton: ListKMonad = object : arrow.core.extensions.ListKMonad {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  /**
+   *  ank_macro_hierarchy(arrow.typeclasses.Monad)
+   *
+   *  [Monad] abstract over the ability to declare sequential computations that are dependent in the order or
+   *  the results of previous computations.
+   *
+   *  Given a type constructor [F] with a value of [A] we can compose multiple operations of type
+   *  `Kind<F, ?>` where `?` denotes a value being transformed.
+   *
+   *  This is true for all type constructors that can support the [Monad] type class including and not limited to
+   *  [IO], [ObservableK], [Option], [Either], [List] ...
+   *
+   *  [The Monad Tutorial](https://arrow-kt.io/docs/patterns/monads/)
+   */
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Monad typeclasses are deprecated. Use concrete methods on List")
+  inline fun monad(): ListKMonad = monad_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadCombine/ListKMonadCombine.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadCombine/ListKMonadCombine.kt
new file mode 100644
index 000000000..acc017c96
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadCombine/ListKMonadCombine.kt
@@ -0,0 +1,55 @@
+package arrow.core.extensions.list.monadCombine
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKMonadCombine
+import arrow.typeclasses.Bifoldable
+import arrow.typeclasses.Foldable
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("unite")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Foldable typeclasses is deprecated. Use concrete methods on List")
+fun <G, A> List<Kind<G, A>>.unite(arg1: Foldable<G>): List<A> =
+    arrow.core.extensions.list.monadCombine.List.monadCombine().run {
+  arrow.core.ListK(this@unite).unite<G, A>(arg1) as kotlin.collections.List<A>
+}
+
+@JvmName("separate")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Foldable typeclasses is deprecated. Use concrete methods on List")
+fun <G, A, B> List<Kind<Kind<G, A>, B>>.separate(arg1: Bifoldable<G>): Tuple2<Kind<ForListK, A>,
+    Kind<ForListK, B>> = arrow.core.extensions.list.monadCombine.List.monadCombine().run {
+  arrow.core.ListK(this@separate).separate<G, A, B>(arg1) as
+    arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>, arrow.Kind<arrow.core.ForListK, B>>
+}
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monadCombine_singleton: ListKMonadCombine = object :
+    arrow.core.extensions.ListKMonadCombine {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("MonadCombine typeclasses is deprecated. Use concrete methods on List")
+  inline fun monadCombine(): ListKMonadCombine = monadCombine_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadFilter/ListKMonadFilter.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadFilter/ListKMonadFilter.kt
new file mode 100644
index 000000000..0452770a6
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadFilter/ListKMonadFilter.kt
@@ -0,0 +1,53 @@
+package arrow.core.extensions.list.monadFilter
+
+import arrow.core.ForListK
+import arrow.core.Option
+import arrow.core.extensions.ListKMonadFilter
+import arrow.typeclasses.MonadFilterSyntax
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("filterMap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("mapNotNull { arg1(it).orNull() }"))
+fun <A, B> List<A>.filterMap(arg1: Function1<A, Option<B>>): List<B> =
+    arrow.core.extensions.list.monadFilter.List.monadFilter().run {
+  arrow.core.ListK(this@filterMap).filterMap<A, B>(arg1) as kotlin.collections.List<B>
+}
+
+@JvmName("bindingFilter")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Monad bindings are deprecated")
+fun <B> bindingFilter(arg0: suspend MonadFilterSyntax<ForListK>.() -> B): List<B> =
+    arrow.core.extensions.list.monadFilter.List
+   .monadFilter()
+   .bindingFilter<B>(arg0) as kotlin.collections.List<B>
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monadFilter_singleton: ListKMonadFilter = object :
+    arrow.core.extensions.ListKMonadFilter {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("MonadFilter typeclasses is deprecated. Use concrete methods on List")
+  inline fun monadFilter(): ListKMonadFilter = monadFilter_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadLogic/ListKMonadLogic.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadLogic/ListKMonadLogic.kt
new file mode 100644
index 000000000..3f20ac096
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadLogic/ListKMonadLogic.kt
@@ -0,0 +1,110 @@
+package arrow.core.extensions.list.monadLogic
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.Option
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKMonadLogic
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("splitM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("split()", "arrow.core.split"))
+fun <A> List<A>.splitM(): List<Option<Tuple2<Kind<ForListK, A>, A>>> =
+    arrow.core.extensions.list.monadLogic.List.monadLogic().run {
+  arrow.core.ListK(this@splitM).splitM<A>() as
+    kotlin.collections.List<arrow.core.Option<arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>,
+    A>>>
+}
+
+@JvmName("interleave")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("interleave(arg1)", "arrow.core.interleave"))
+fun <A> List<A>.interleave(arg1: List<A>): List<A> =
+    arrow.core.extensions.list.monadLogic.List.monadLogic().run {
+  arrow.core.ListK(this@interleave).interleave<A>(arrow.core.ListK(arg1)) as
+    kotlin.collections.List<A>
+}
+
+@JvmName("unweave")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("unweave(arg1)", "arrow.core.unweave"))
+fun <A, B> List<A>.unweave(arg1: Function1<A, Kind<ForListK, B>>): List<B> =
+    arrow.core.extensions.list.monadLogic.List.monadLogic().run {
+  arrow.core.ListK(this@unweave).unweave<A, B>(arg1) as kotlin.collections.List<B>
+}
+
+@JvmName("ifThen")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("ifThen(arg1, arg2)", "arrow.core.ifThen"))
+fun <A, B> List<A>.ifThen(arg1: List<B>, arg2: Function1<A, Kind<ForListK, B>>): List<B> =
+    arrow.core.extensions.list.monadLogic.List.monadLogic().run {
+  arrow.core.ListK(this@ifThen).ifThen<A, B>(arrow.core.ListK(arg1), arg2) as
+    kotlin.collections.List<B>
+}
+
+@JvmName("once")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listOfNotNull<A>(firstOrNull())"))
+fun <A> List<A>.once(): List<A> = arrow.core.extensions.list.monadLogic.List.monadLogic().run {
+  arrow.core.ListK(this@once).once<A>() as kotlin.collections.List<A>
+}
+
+@JvmName("voidIfValue")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("firstOrNull()?.let { emptyList<Unit>() } ?: listOf(Unit)"))
+fun <A> List<A>.voidIfValue(): List<Unit> =
+    arrow.core.extensions.list.monadLogic.List.monadLogic().run {
+  arrow.core.ListK(this@voidIfValue).voidIfValue<A>() as kotlin.collections.List<kotlin.Unit>
+}
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monadLogic_singleton: ListKMonadLogic = object : arrow.core.extensions.ListKMonadLogic
+    {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("MonadLogic typeclasses is deprecated. Use concrete methods on List")
+  inline fun monadLogic(): ListKMonadLogic = monadLogic_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadPlus/ListKMonadPlus.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadPlus/ListKMonadPlus.kt
new file mode 100644
index 000000000..ee22adfcf
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monadPlus/ListKMonadPlus.kt
@@ -0,0 +1,47 @@
+package arrow.core.extensions.list.monadPlus
+
+import arrow.core.extensions.ListKMonadPlus
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("zeroM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("emptyList()"))
+fun <A> zeroM(): List<A> = arrow.core.extensions.list.monadPlus.List
+   .monadPlus()
+   .zeroM<A>() as kotlin.collections.List<A>
+
+@JvmName("plusM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("this + arg1"))
+fun <A> List<A>.plusM(arg1: List<A>): List<A> =
+    arrow.core.extensions.list.monadPlus.List.monadPlus().run {
+  arrow.core.ListK(this@plusM).plusM<A>(arrow.core.ListK(arg1)) as kotlin.collections.List<A>
+}
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monadPlus_singleton: ListKMonadPlus = object : arrow.core.extensions.ListKMonadPlus {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("MonadPlus typeclasses is deprecated. Use concrete methods on List")
+  inline fun monadPlus(): ListKMonadPlus = monadPlus_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/monoid/ListKMonoid.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monoid/ListKMonoid.kt
new file mode 100644
index 000000000..f3170be0f
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monoid/ListKMonoid.kt
@@ -0,0 +1,50 @@
+package arrow.core.extensions.list.monoid
+
+import arrow.core.ListK
+import arrow.core.extensions.ListKMonoid
+import kotlin.Any
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.Collection
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("combineAll")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.fold(emptyList()) { acc, l -> acc + l }"))
+fun <A> Collection<ListK<A>>.combineAll(): List<A> =
+    arrow.core.extensions.list.monoid.List.monoid<A>().run {
+  this@combineAll.combineAll() as kotlin.collections.List<A>
+}
+
+@JvmName("combineAll")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.fold(emptyList()) { acc, l -> acc + l }"))
+fun <A> combineAll(arg0: List<ListK<A>>): List<A> =
+  arg0.fold(emptyList()) { acc, l -> acc + l }
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monoid_singleton: ListKMonoid<Any?> = object : ListKMonoid<Any?> {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("@extension projected functions are deprecated", ReplaceWith("listMonoid<A>()", "arrow.core.listMonoid"))
+  inline fun <A> monoid(): ListKMonoid<A> = monoid_singleton as
+      arrow.core.extensions.ListKMonoid<A>}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/monoidK/ListKMonoidK.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monoidK/ListKMonoidK.kt
new file mode 100644
index 000000000..d710cdbc1
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monoidK/ListKMonoidK.kt
@@ -0,0 +1,36 @@
+package arrow.core.extensions.list.monoidK
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.extensions.ListKMonoidK
+import arrow.typeclasses.Monoid
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+@JvmName("algebra")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listMonoid<A>()", "arrow.core.listMonoid"))
+fun <A> algebra(): Monoid<Kind<ForListK, A>> = arrow.core.extensions.list.monoidK.List
+   .monoidK()
+   .algebra<A>() as arrow.typeclasses.Monoid<arrow.Kind<arrow.core.ForListK, A>>
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monoidK_singleton: ListKMonoidK = object : arrow.core.extensions.ListKMonoidK {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+  inline fun monoidK(): ListKMonoidK = monoidK_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/monoidal/ListKMonoidal.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monoidal/ListKMonoidal.kt
new file mode 100644
index 000000000..44dcb37a2
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/monoidal/ListKMonoidal.kt
@@ -0,0 +1,34 @@
+package arrow.core.extensions.list.monoidal
+
+import arrow.core.extensions.ListKMonoidal
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("identity")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("emptyList<A>()"))
+fun <A> identity(): List<A> = arrow.core.extensions.list.monoidal.List
+   .monoidal()
+   .identity<A>() as kotlin.collections.List<A>
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monoidal_singleton: ListKMonoidal = object : arrow.core.extensions.ListKMonoidal {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Monoidal typeclasses is deprecated. Use concrete methods on List")
+  inline fun monoidal(): ListKMonoidal = monoidal_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/order/ListKOrder.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/order/ListKOrder.kt
new file mode 100644
index 000000000..e5acd8661
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/order/ListKOrder.kt
@@ -0,0 +1,137 @@
+package arrow.core.extensions.list.order
+
+import arrow.core.Ordering
+import arrow.core.extensions.ListKOrder
+import arrow.typeclasses.Order
+import kotlin.Boolean
+import kotlin.Int
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("compare")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("compare(OA, arg1)", "arrow.core.compare"))
+fun <A> List<A>.compare(OA: Order<A>, arg1: List<A>): Ordering =
+    arrow.core.extensions.list.order.List.order<A>(OA).run {
+  arrow.core.ListK(this@compare).compare(arrow.core.ListK(arg1)) as arrow.core.Ordering
+}
+
+@JvmName("compareTo")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("compareTo(OA, arg1)", "arrow.core.compareTo"))
+fun <A> List<A>.compareTo(OA: Order<A>, arg1: List<A>): Int =
+    arrow.core.extensions.list.order.List.order<A>(OA).run {
+  arrow.core.ListK(this@compareTo).compareTo(arrow.core.ListK(arg1)) as kotlin.Int
+}
+
+@JvmName("eqv")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("eqv(OA, arg1)", "arrow.core.eqv"))
+fun <A> List<A>.eqv(OA: Order<A>, arg1: List<A>): Boolean =
+    arrow.core.extensions.list.order.List.order<A>(OA).run {
+  arrow.core.ListK(this@eqv).eqv(arrow.core.ListK(arg1)) as kotlin.Boolean
+}
+
+@JvmName("lt")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("lt(OA, arg1)", "arrow.core.lt"))
+fun <A> List<A>.lt(OA: Order<A>, arg1: List<A>): Boolean =
+    arrow.core.extensions.list.order.List.order<A>(OA).run {
+  arrow.core.ListK(this@lt).lt(arrow.core.ListK(arg1)) as kotlin.Boolean
+}
+
+@JvmName("lte")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("lte(OA, arg1)", "arrow.core.lte"))
+fun <A> List<A>.lte(OA: Order<A>, arg1: List<A>): Boolean =
+    arrow.core.extensions.list.order.List.order<A>(OA).run {
+  arrow.core.ListK(this@lte).lte(arrow.core.ListK(arg1)) as kotlin.Boolean
+}
+
+@JvmName("gt")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("gt(OA, arg1)", "arrow.core.gt"))
+fun <A> List<A>.gt(OA: Order<A>, arg1: List<A>): Boolean =
+    arrow.core.extensions.list.order.List.order<A>(OA).run {
+  arrow.core.ListK(this@gt).gt(arrow.core.ListK(arg1)) as kotlin.Boolean
+}
+
+@JvmName("gte")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("gte(OA, arg1)", "arrow.core.gte"))
+fun <A> List<A>.gte(OA: Order<A>, arg1: List<A>): Boolean =
+    arrow.core.extensions.list.order.List.order<A>(OA).run {
+  arrow.core.ListK(this@gte).gte(arrow.core.ListK(arg1)) as kotlin.Boolean
+}
+
+@JvmName("max")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("max(OA, arg1)", "arrow.core.max"))
+fun <A> List<A>.max(OA: Order<A>, arg1: List<A>): List<A> =
+    arrow.core.extensions.list.order.List.order<A>(OA).run {
+  arrow.core.ListK(this@max).max(arrow.core.ListK(arg1)) as kotlin.collections.List<A>
+}
+
+@JvmName("min")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("min(OA, arg1)", "arrow.core.min"))
+fun <A> List<A>.min(OA: Order<A>, arg1: List<A>): List<A> =
+    arrow.core.extensions.list.order.List.order<A>(OA).run {
+  arrow.core.ListK(this@min).min(arrow.core.ListK(arg1)) as kotlin.collections.List<A>
+}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("@extension projected functions are deprecated", ReplaceWith("listOrder(OA)", "arrow.core.listOrder"))
+  inline fun <A> order(OA: Order<A>): ListKOrder<A> = object : arrow.core.extensions.ListKOrder<A> {
+      override fun OA(): arrow.typeclasses.Order<A> = OA }}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/semialign/ListKSemialign.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/semialign/ListKSemialign.kt
new file mode 100644
index 000000000..cb9e48c9b
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/semialign/ListKSemialign.kt
@@ -0,0 +1,101 @@
+package arrow.core.extensions.list.semialign
+
+import arrow.core.Ior
+import arrow.core.Option
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKSemialign
+import arrow.typeclasses.Semigroup
+import kotlin.Function1
+import kotlin.Function2
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("align")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.align(arg1)", "arrow.core.align"))
+fun <A, B> align(arg0: List<A>, arg1: List<B>): List<Ior<A, B>> =
+    arrow.core.extensions.list.semialign.List
+   .semialign()
+   .align<A, B>(arrow.core.ListK(arg0), arrow.core.ListK(arg1)) as
+    kotlin.collections.List<arrow.core.Ior<A, B>>
+
+@JvmName("alignWith")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.align(arg1, arg2)", "arrow.core.align"))
+fun <A, B, C> alignWith(
+  arg0: List<A>,
+  arg1: List<B>,
+  arg2: Function1<Ior<A, B>, C>
+): List<C> = arrow.core.extensions.list.semialign.List
+   .semialign()
+   .alignWith<A, B, C>(arrow.core.ListK(arg0), arrow.core.ListK(arg1), arg2) as
+    kotlin.collections.List<C>
+
+@JvmName("salign")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.salign(arg1, arg2)", "arrow.core.salign"))
+fun <A> List<A>.salign(arg1: Semigroup<A>, arg2: List<A>): List<A> =
+    arrow.core.extensions.list.semialign.List.semialign().run {
+  arrow.core.ListK(this@salign).salign<A>(arg1, arrow.core.ListK(arg2)) as
+    kotlin.collections.List<A>
+}
+
+@JvmName("padZip")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.padZip(arg1)", "arrow.core.padZip"))
+fun <A, B> List<A>.padZip(arg1: List<B>): List<Tuple2<Option<A>, Option<B>>> =
+    arrow.core.extensions.list.semialign.List.semialign().run {
+  arrow.core.ListK(this@padZip).padZip<A, B>(arrow.core.ListK(arg1)) as
+    kotlin.collections.List<arrow.core.Tuple2<arrow.core.Option<A>, arrow.core.Option<B>>>
+}
+
+@JvmName("padZipWith")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.padZip(arg1, arg2)", "arrow.core.padZip"))
+fun <A, B, C> List<A>.padZipWith(arg1: List<B>, arg2: Function2<Option<A>, Option<B>, C>): List<C> =
+    arrow.core.extensions.list.semialign.List.semialign().run {
+  arrow.core.ListK(this@padZipWith).padZipWith<A, B, C>(arrow.core.ListK(arg1), arg2) as
+    kotlin.collections.List<C>
+}
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val semialign_singleton: ListKSemialign = object : arrow.core.extensions.ListKSemialign {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Semialign typeclasses is deprecated. Use concrete methods on List")
+  inline fun semialign(): ListKSemialign = semialign_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/semigroup/ListKSemigroup.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/semigroup/ListKSemigroup.kt
new file mode 100644
index 000000000..023b199fc
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/semigroup/ListKSemigroup.kt
@@ -0,0 +1,51 @@
+package arrow.core.extensions.list.semigroup
+
+import arrow.core.extensions.ListKSemigroup
+import kotlin.Any
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("plus")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("this.plus(arg1)"))
+operator fun <A> List<A>.plus(arg1: List<A>): List<A> =
+    arrow.core.extensions.list.semigroup.List.semigroup<A>().run {
+  arrow.core.ListK(this@plus).plus(arrow.core.ListK(arg1)) as kotlin.collections.List<A>
+}
+
+@JvmName("maybeCombine")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("(arg1?.plus(this) ?: emptyList<A>())"))
+fun <A> List<A>.maybeCombine(arg1: List<A>): List<A> =
+    arrow.core.extensions.list.semigroup.List.semigroup<A>().run {
+  arrow.core.ListK(this@maybeCombine).maybeCombine(arrow.core.ListK(arg1)) as
+    kotlin.collections.List<A>
+}
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val semigroup_singleton: ListKSemigroup<Any?> = object : ListKSemigroup<Any?> {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("@extension projected functions are deprecated", ReplaceWith("listMonoid<A>()", "arrow.core.listMonoid"))
+  inline fun <A> semigroup(): ListKSemigroup<A> = semigroup_singleton as
+      arrow.core.extensions.ListKSemigroup<A>}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/semigroupK/ListKSemigroupK.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/semigroupK/ListKSemigroupK.kt
new file mode 100644
index 000000000..3708ca3dc
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/semigroupK/ListKSemigroupK.kt
@@ -0,0 +1,51 @@
+package arrow.core.extensions.list.semigroupK
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.extensions.ListKSemigroupK
+import arrow.typeclasses.Semigroup
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("combineK")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A> List<A>.combineK(arg1: List<A>): List<A> =
+    arrow.core.extensions.list.semigroupK.List.semigroupK().run {
+  arrow.core.ListK(this@combineK).combineK<A>(arrow.core.ListK(arg1)) as kotlin.collections.List<A>
+}
+
+@JvmName("algebra")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listMonoid<A>()", "arrow.core.listMonoid"))
+fun <A> algebra(): Semigroup<Kind<ForListK, A>> = arrow.core.extensions.list.semigroupK.List
+   .semigroupK()
+   .algebra<A>() as arrow.typeclasses.Semigroup<arrow.Kind<arrow.core.ForListK, A>>
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val semigroupK_singleton: ListKSemigroupK = object : arrow.core.extensions.ListKSemigroupK
+    {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+  inline fun semigroupK(): ListKSemigroupK = semigroupK_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/semigroupal/ListKSemigroupal.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/semigroupal/ListKSemigroupal.kt
new file mode 100644
index 000000000..f8d389510
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/semigroupal/ListKSemigroupal.kt
@@ -0,0 +1,144 @@
+package arrow.core.extensions.list.semigroupal
+
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKSemigroupal
+import arrow.core.product as _product
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+/**
+ *  Multiplicatively combine F<A> and F<B> into F<Tuple2<A, B>>
+ */
+@JvmName("product")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B> List<A>.product(arg1: List<B>): List<Tuple2<A, B>> =
+  _product(arg1)
+
+/**
+ * syntax
+ */
+@JvmName("times")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+operator fun <A, B> List<A>.times(arg1: List<B>): List<Tuple2<A, B>> =
+  _product(arg1)
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val semigroupal_singleton: ListKSemigroupal = object :
+    arrow.core.extensions.ListKSemigroupal {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  /**
+   *  ank_macro_hierarchy(arrow.typeclasses.Semigroupal)
+   *
+   *  The [Semigroupal] type class for a given type `F` can be seen as an abstraction over the [cartesian product](https://en.wikipedia.org/wiki/Cartesian_product).
+   *  It defines the function [product].
+   *
+   *  The [product] function for a given type `F`, `A` and `B` combines a `Kind<F, A>` and a `Kind<F, B>` into a `Kind<F, Tuple2<A, B>>`.
+   *  This function guarantees compliance with the following laws:
+   *
+   *  [Semigroupal]s are associative under the bijection `f = (a,(b,c)) -> ((a,b),c)` or `f = ((a,b),c) -> (a,(b,c))`.
+   *  Therefore, the following laws also apply:
+   *
+   *  ```kotlin
+   *  f((a.product(b)).product(c)) == a.product(b.product(c))
+   *  ```
+   *
+   *  ```kotlin
+   *  f(a.product(b.product(c))) == (a.product(b)).product(c)
+   *  ```
+   *
+   *  Currently, [Semigroupal] instances are defined for [Option], [ListK], [SequenceK] and [SetK].
+   *
+   *  ```kotlin:ank:playground
+   *  import arrow.core.*
+   * import arrow.core.extensions.listk.semigroupal.*
+   * import arrow.core.*
+   *
+   *
+   *
+   *  fun main(args: Array<String>) {
+   *   val result =
+   *   //sampleStart
+   *   ListK.semigroupal()
+   *   //sampleEnd
+   *   println(result)
+   *  }
+   *  ```
+   *
+   *  ### Examples
+   *
+   *  Here a some examples:
+   *
+   *  ```kotlin:ank:playground
+   *  import arrow.core.Option
+   *  import arrow.core.extensions.option.semigroupal.semigroupal
+   *
+   *  fun main(args: Array<String>) {
+   *   val result =
+   *   //sampleStart
+   *   Option.semigroupal().run {
+   *       Option.just(1).product(Option.just(1))
+   *   }
+   *   //sampleEnd
+   *   println(result)
+   *  }
+   *  ```
+   *
+   *  [Semigroupal] also has support of the `*` syntax:
+   *
+   *  ```kotlin:ank:playground
+   *  import arrow.core.Option
+   *  import arrow.core.extensions.option.semigroupal.semigroupal
+   *
+   *  fun main(args: Array<String>) {
+   *   val result =
+   *   //sampleStart
+   *   Option.semigroupal().run {
+   * Option.just(2)
+   *   }
+   *   //sampleEnd
+   *   println(result)
+   *  }
+   *  ```
+   *  The same applies to [ListK], [SequenceK] and [SetK] instances:
+   *
+   *  ```kotlin:ank:playground
+   *  import arrow.core.ListK
+   *  import arrow.core.extensions.listk.semigroupal.semigroupal
+   *  import arrow.core.k
+   *
+   *  fun main(args: Array<String>) {
+   *   val result =
+   *   //sampleStart
+   *   ListK.semigroupal().run {
+   * listOf('a','b','c').k()
+   *   }
+   *   //sampleEnd
+   *   println(result)
+   *  }
+   *  ```
+   */
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+  inline fun semigroupal(): ListKSemigroupal = semigroupal_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/show/ListKShow.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/show/ListKShow.kt
new file mode 100644
index 000000000..2a93abd85
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/show/ListKShow.kt
@@ -0,0 +1,30 @@
+package arrow.core.extensions.list.show
+
+import arrow.core.extensions.ListKShow
+import arrow.core.show as _show
+import arrow.typeclasses.Show
+import kotlin.String
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("show")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("show(arg1)", "arrow.core.show"))
+fun <A> List<A>.show(SA: Show<A>): String =
+  _show(SA)
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("@extension projected functions are deprecated", ReplaceWith("listShow(arg1)", "arrow.core.listShow"))
+  inline fun <A> show(SA: Show<A>): ListKShow<A> = object : arrow.core.extensions.ListKShow<A> {
+      override fun SA(): arrow.typeclasses.Show<A> = SA }}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/traverse/ListKTraverse.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/traverse/ListKTraverse.kt
new file mode 100644
index 000000000..a52a7298e
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/traverse/ListKTraverse.kt
@@ -0,0 +1,85 @@
+package arrow.core.extensions.list.traverse
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.extensions.ListKTraverse
+import arrow.typeclasses.Applicative
+import arrow.typeclasses.Monad
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("traverse")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with traverseEither or traverseValidated from arrow.core.*")
+fun <G, A, B> List<A>.traverse(arg1: Applicative<G>, arg2: Function1<A, Kind<G, B>>): Kind<G,
+    Kind<ForListK, B>> = arrow.core.extensions.list.traverse.List.traverse().run {
+  arrow.core.ListK(this@traverse).traverse<G, A, B>(arg1, arg2) as arrow.Kind<G,
+    arrow.Kind<arrow.core.ForListK, B>>
+}
+
+@JvmName("sequence")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with sequenceEither or sequenceValidated from arrow.core.*")
+fun <G, A> List<Kind<G, A>>.sequence(arg1: Applicative<G>): Kind<G, Kind<ForListK, A>> =
+    arrow.core.extensions.list.traverse.List.traverse().run {
+  arrow.core.ListK(this@sequence).sequence<G, A>(arg1) as arrow.Kind<G,
+    arrow.Kind<arrow.core.ForListK, A>>
+}
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("map(arg1)"))
+fun <A, B> List<A>.map(arg1: Function1<A, B>): List<B> =
+    arrow.core.extensions.list.traverse.List.traverse().run {
+  arrow.core.ListK(this@map).map<A, B>(arg1) as kotlin.collections.List<B>
+}
+
+@JvmName("flatTraverse")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with flatTraverseEither or flatTraverseValidated from arrow.core.*")
+fun <G, A, B> List<A>.flatTraverse(
+  arg1: Monad<ForListK>,
+  arg2: Applicative<G>,
+  arg3: Function1<A, Kind<G, Kind<ForListK, B>>>
+): Kind<G, Kind<ForListK, B>> = arrow.core.extensions.list.traverse.List.traverse().run {
+  arrow.core.ListK(this@flatTraverse).flatTraverse<G, A, B>(arg1, arg2, arg3) as arrow.Kind<G,
+    arrow.Kind<arrow.core.ForListK, B>>
+}
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val traverse_singleton: ListKTraverse = object : arrow.core.extensions.ListKTraverse {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Traverse typeclasses is deprecated. Use concrete methods on Iterable")
+  inline fun traverse(): ListKTraverse = traverse_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/unalign/ListKUnalign.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/unalign/ListKUnalign.kt
new file mode 100644
index 000000000..dcde8cb3f
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/unalign/ListKUnalign.kt
@@ -0,0 +1,55 @@
+package arrow.core.extensions.list.unalign
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.Ior
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKUnalign
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("unalign")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.unalign()", "arrow.core.unalign"))
+fun <A, B> unalign(arg0: List<Ior<A, B>>): Tuple2<Kind<ForListK, A>, Kind<ForListK, B>> =
+    arrow.core.extensions.list.unalign.List
+   .unalign()
+   .unalign<A, B>(arrow.core.ListK(arg0)) as arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>,
+    arrow.Kind<arrow.core.ForListK, B>>
+
+@JvmName("unalignWith")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.unalign(arg1)", "arrow.core.unalign"))
+fun <A, B, C> unalignWith(arg0: List<C>, arg1: Function1<C, Ior<A, B>>): Tuple2<Kind<ForListK, A>,
+    Kind<ForListK, B>> = arrow.core.extensions.list.unalign.List
+   .unalign()
+   .unalignWith<A, B, C>(arrow.core.ListK(arg0), arg1) as
+    arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>, arrow.Kind<arrow.core.ForListK, B>>
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val unalign_singleton: ListKUnalign = object : arrow.core.extensions.ListKUnalign {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Unalign typeclasses is deprecated. Use concrete methods on Iterable")
+  inline fun unalign(): ListKUnalign = unalign_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/unzip/ListKUnzip.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/unzip/ListKUnzip.kt
new file mode 100644
index 000000000..0aadb463d
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/unzip/ListKUnzip.kt
@@ -0,0 +1,54 @@
+package arrow.core.extensions.list.unzip
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKUnzip
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+@JvmName("unzip")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("unzip()", "arrow.core.unzip"))
+fun <A, B> List<Tuple2<A, B>>.unzip(): Tuple2<Kind<ForListK, A>, Kind<ForListK, B>> =
+    arrow.core.extensions.list.unzip.List.unzip().run {
+  arrow.core.ListK(this@unzip).unzip<A, B>() as arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK,
+    A>, arrow.Kind<arrow.core.ForListK, B>>
+}
+
+@JvmName("unzipWith")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("unzip(arg1)", "arrow.core.unzip"))
+fun <A, B, C> List<C>.unzipWith(arg1: Function1<C, Tuple2<A, B>>): Tuple2<Kind<ForListK, A>,
+    Kind<ForListK, B>> = arrow.core.extensions.list.unzip.List.unzip().run {
+  arrow.core.ListK(this@unzipWith).unzipWith<A, B, C>(arg1) as
+    arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>, arrow.Kind<arrow.core.ForListK, B>>
+}
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val unzip_singleton: ListKUnzip = object : arrow.core.extensions.ListKUnzip {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Unzip typeclasses is deprecated. Use concrete methods on Iterable")
+  inline fun unzip(): ListKUnzip = unzip_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/list/zip/ListKZip.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/list/zip/ListKZip.kt
new file mode 100644
index 000000000..fa681cabb
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/list/zip/ListKZip.kt
@@ -0,0 +1,48 @@
+package arrow.core.extensions.list.zip
+
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKZip
+import arrow.core.toTuple2
+import kotlin.Function2
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.collections.zip as _zip
+import kotlin.jvm.JvmName
+
+@JvmName("zip")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("zip(arg1).map { it.toTuple2() }", "arrow.core.toTuple2"))
+fun <A, B> List<A>.zip(arg1: List<B>): List<Tuple2<A, B>> =
+  _zip(arg1).map { it.toTuple2() }
+
+@JvmName("zipWith")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("zip(arg1, arg2)"))
+fun <A, B, C> List<A>.zipWith(arg1: List<B>, arg2: Function2<A, B, C>): List<C> =
+  _zip(arg1, arg2)
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val zip_singleton: ListKZip = object : arrow.core.extensions.ListKZip {}
+
+@Deprecated("Receiver List object is deprecated, prefer to turn List functions into top-level functions")
+object List {
+  @Suppress(
+    "UNCHECKED_CAST",
+    "NOTHING_TO_INLINE"
+  )
+  @Deprecated("Zip typeclasses is deprecated. Use concrete methods on Iterable")
+  inline fun zip(): ListKZip = zip_singleton}
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk.kt
index e12a8b0f1..930f933e0 100644
--- a/arrow-core/src/main/kotlin/arrow/core/extensions/listk.kt
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk.kt
@@ -22,7 +22,6 @@ import arrow.core.fix
 import arrow.core.identity
 import arrow.core.k
 import arrow.core.toT
-import arrow.extension
 import arrow.typeclasses.Align
 import arrow.typeclasses.Alternative
 import arrow.typeclasses.Applicative
@@ -58,19 +57,16 @@ import arrow.core.combineK as listCombineK
 import kotlin.collections.plus as listPlus
 import kotlin.collections.zip as listZip
 
-@extension
 interface ListKSemigroup<A> : Semigroup<ListK<A>> {
   override fun ListK<A>.combine(b: ListK<A>): ListK<A> =
     (this.listPlus(b)).k()
 }
 
-@extension
 interface ListKMonoid<A> : Monoid<ListK<A>>, ListKSemigroup<A> {
   override fun empty(): ListK<A> =
     emptyList<A>().k()
 }
 
-@extension
 interface ListKEq<A> : Eq<ListKOf<A>> {
 
   fun EQ(): Eq<A>
@@ -84,19 +80,16 @@ interface ListKEq<A> : Eq<ListKOf<A>> {
     else false
 }
 
-@extension
 interface ListKShow<A> : Show<ListKOf<A>> {
   fun SA(): Show<A>
   override fun ListKOf<A>.show(): String = fix().show(SA())
 }
 
-@extension
 interface ListKFunctor : Functor<ForListK> {
   override fun <A, B> Kind<ForListK, A>.map(f: (A) -> B): ListK<B> =
     fix().map(f)
 }
 
-@extension
 interface ListKApply : Apply<ForListK> {
   override fun <A, B> Kind<ForListK, A>.ap(ff: Kind<ForListK, (A) -> B>): ListK<B> =
     fix().ap(ff)
@@ -108,7 +101,6 @@ interface ListKApply : Apply<ForListK> {
     fix().map2(fb, f)
 }
 
-@extension
 interface ListKApplicative : Applicative<ForListK> {
   override fun <A, B> Kind<ForListK, A>.ap(ff: Kind<ForListK, (A) -> B>): ListK<B> =
     fix().ap(ff)
@@ -123,7 +115,6 @@ interface ListKApplicative : Applicative<ForListK> {
     ListK.just(a)
 }
 
-@extension
 interface ListKMonad : Monad<ForListK> {
   override fun <A, B> Kind<ForListK, A>.ap(ff: Kind<ForListK, (A) -> B>): ListK<B> =
     fix().ap(ff)
@@ -150,7 +141,6 @@ interface ListKMonad : Monad<ForListK> {
     ListK.just(a)
 }
 
-@extension
 interface ListKFoldable : Foldable<ForListK> {
   override fun <A, B> Kind<ForListK, A>.foldLeft(b: B, f: (B, A) -> B): B =
     fix().foldLeft(b, f)
@@ -162,7 +152,6 @@ interface ListKFoldable : Foldable<ForListK> {
     fix().isEmpty()
 }
 
-@extension
 interface ListKTraverse : Traverse<ForListK> {
   override fun <A, B> Kind<ForListK, A>.map(f: (A) -> B): ListK<B> =
     fix().map(f)
@@ -180,24 +169,20 @@ interface ListKTraverse : Traverse<ForListK> {
     fix().isEmpty()
 }
 
-@extension
 interface ListKSemigroupK : SemigroupK<ForListK> {
   override fun <A> Kind<ForListK, A>.combineK(y: Kind<ForListK, A>): ListK<A> =
     fix().listCombineK(y)
 }
 
-@extension
 interface ListKSemigroupal : Semigroupal<ForListK> {
   override fun <A, B> Kind<ForListK, A>.product(fb: Kind<ForListK, B>): Kind<ForListK, Tuple2<A, B>> =
     fb.fix().ap(fix().map { a: A -> { b: B -> Tuple2(a, b) } })
 }
 
-@extension
 interface ListKMonoidal : Monoidal<ForListK>, ListKSemigroupal {
   override fun <A> identity(): Kind<ForListK, A> = ListK.empty()
 }
 
-@extension
 interface ListKMonoidK : MonoidK<ForListK> {
   override fun <A> empty(): ListK<A> =
     ListK.empty()
@@ -206,7 +191,6 @@ interface ListKMonoidK : MonoidK<ForListK> {
     fix().listCombineK(y)
 }
 
-@extension
 interface ListKHash<A> : Hash<ListKOf<A>> {
 
   fun HA(): Hash<A>
@@ -215,7 +199,6 @@ interface ListKHash<A> : Hash<ListKOf<A>> {
     HA().run { foldLeft(salt) { hash, x -> x.hashWithSalt(hash) } }.hashWithSalt(fix().size)
 }
 
-@extension
 interface ListKOrder<A> : Order<ListKOf<A>> {
   fun OA(): Order<A>
   override fun ListKOf<A>.compare(b: ListKOf<A>): Ordering =
@@ -223,7 +206,6 @@ interface ListKOrder<A> : Order<ListKOf<A>> {
       .fold(Ordering.monoid())
 }
 
-@extension
 interface ListKFunctorFilter : FunctorFilter<ForListK> {
   override fun <A, B> Kind<ForListK, A>.filterMap(f: (A) -> Option<B>): ListK<B> =
     fix().filterMap(f)
@@ -235,7 +217,6 @@ interface ListKFunctorFilter : FunctorFilter<ForListK> {
 fun <A> ListK.Companion.fx(c: suspend MonadSyntax<ForListK>.() -> A): ListK<A> =
   ListK.monad().fx.monad(c).fix()
 
-@extension
 interface ListKMonadCombine : MonadCombine<ForListK>, ListKAlternative {
   override fun <A> empty(): ListK<A> =
     ListK.empty()
@@ -262,7 +243,6 @@ interface ListKMonadCombine : MonadCombine<ForListK>, ListKAlternative {
     ListK.just(a)
 }
 
-@extension
 interface ListKMonadFilter : MonadFilter<ForListK> {
   override fun <A> empty(): ListK<A> =
     ListK.empty()
@@ -289,14 +269,12 @@ interface ListKMonadFilter : MonadFilter<ForListK> {
     ListK.just(a)
 }
 
-@extension
 interface ListKAlternative : Alternative<ForListK>, ListKApplicative {
   override fun <A> empty(): Kind<ForListK, A> = emptyList<A>().k()
   override fun <A> Kind<ForListK, A>.orElse(b: Kind<ForListK, A>): Kind<ForListK, A> =
     (this.fix() + b.fix()).k()
 }
 
-@extension
 interface ListKEqK : EqK<ForListK> {
   override fun <A> Kind<ForListK, A>.eqK(other: Kind<ForListK, A>, EQ: Eq<A>) =
     (this.fix() to other.fix()).let {
@@ -306,7 +284,6 @@ interface ListKEqK : EqK<ForListK> {
     }
 }
 
-@extension
 interface ListKSemialign : Semialign<ForListK>, ListKFunctor {
   override fun <A, B> align(
     a: Kind<ForListK, A>,
@@ -314,12 +291,10 @@ interface ListKSemialign : Semialign<ForListK>, ListKFunctor {
   ): Kind<ForListK, Ior<A, B>> = ListK.align(a.fix(), b.fix())
 }
 
-@extension
 interface ListKAlign : Align<ForListK>, ListKSemialign {
   override fun <A> empty(): Kind<ForListK, A> = ListK.empty()
 }
 
-@extension
 interface ListKUnalign : Unalign<ForListK>, ListKSemialign {
   override fun <A, B> unalign(ior: Kind<ForListK, Ior<A, B>>): Tuple2<Kind<ForListK, A>, Kind<ForListK, B>> =
     ior.fix().let { list ->
@@ -333,13 +308,11 @@ interface ListKUnalign : Unalign<ForListK>, ListKSemialign {
     }
 }
 
-@extension
 interface ListKZip : Zip<ForListK>, ListKSemialign {
   override fun <A, B> Kind<ForListK, A>.zip(other: Kind<ForListK, B>): Kind<ForListK, Tuple2<A, B>> =
     this.fix().listZip(other.fix()).map { it.first toT it.second }.k()
 }
 
-@extension
 interface ListKUnzip : Unzip<ForListK>, ListKZip {
   override fun <A, B> Kind<ForListK, Tuple2<A, B>>.unzip(): Tuple2<Kind<ForListK, A>, Kind<ForListK, B>> =
     this.fix().let { list ->
@@ -349,7 +322,6 @@ interface ListKUnzip : Unzip<ForListK>, ListKZip {
     }.bimap({ it.k() }, { it.k() })
 }
 
-@extension
 interface ListKCrosswalk : Crosswalk<ForListK>, ListKFunctor, ListKFoldable {
   override fun <F, A, B> crosswalk(
     ALIGN: Align<F>,
@@ -368,7 +340,6 @@ interface ListKCrosswalk : Crosswalk<ForListK>, ListKFunctor, ListKFoldable {
     }
 }
 
-@extension
 interface ListKMonadPlus : MonadPlus<ForListK>, ListKMonad, ListKAlternative {
   override fun <A, B> Kind<ForListK, A>.ap(ff: Kind<ForListK, (A) -> B>): ListK<B> =
     fix().ap(ff)
@@ -383,7 +354,6 @@ interface ListKMonadPlus : MonadPlus<ForListK>, ListKMonad, ListKAlternative {
     ListK.just(a)
 }
 
-@extension
 interface ListKMonadLogic : MonadLogic<ForListK>, ListKMonadPlus {
 
   private fun <E> ListK<E>.tail(): ListK<E> = this.drop(1).k()
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/align/ListKAlign.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/align/ListKAlign.kt
new file mode 100644
index 000000000..109021c7d
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/align/ListKAlign.kt
@@ -0,0 +1,33 @@
+package arrow.core.extensions.listk.align
+
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKAlign
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val align_singleton: ListKAlign = object : arrow.core.extensions.ListKAlign {}
+
+@JvmName("empty")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("emptyList()"))
+fun <A> empty(): ListK<A> = arrow.core.ListK
+   .align()
+   .empty<A>() as arrow.core.ListK<A>
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Align typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.align(): ListKAlign = align_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/alternative/ListKAlternative.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/alternative/ListKAlternative.kt
new file mode 100644
index 000000000..227a64755
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/alternative/ListKAlternative.kt
@@ -0,0 +1,129 @@
+package arrow.core.extensions.listk.alternative
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Option
+import arrow.core.SequenceK
+import arrow.core.extensions.ListKAlternative
+import kotlin.Boolean
+import kotlin.Function0
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val alternative_singleton: ListKAlternative = object :
+    arrow.core.extensions.ListKAlternative {}
+
+@JvmName("some")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("This method results in StackOverflow")
+fun <A> Kind<ForListK, A>.some(): ListK<SequenceK<A>> = arrow.core.ListK.alternative().run {
+  this@some.some<A>() as arrow.core.ListK<arrow.core.SequenceK<A>>
+}
+
+@JvmName("many")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("This method results in StackOverflow")
+fun <A> Kind<ForListK, A>.many(): ListK<SequenceK<A>> = arrow.core.ListK.alternative().run {
+  this@many.many<A>() as arrow.core.ListK<arrow.core.SequenceK<A>>
+}
+
+@JvmName("alt")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("this + arg1"))
+infix fun <A> Kind<ForListK, A>.alt(arg1: Kind<ForListK, A>): ListK<A> =
+    arrow.core.ListK.alternative().run {
+  this@alt.alt<A>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("orElse")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("this + arg1"))
+fun <A> Kind<ForListK, A>.orElse(arg1: Kind<ForListK, A>): ListK<A> =
+    arrow.core.ListK.alternative().run {
+  this@orElse.orElse<A>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("combineK")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("this + arg1"))
+fun <A> Kind<ForListK, A>.combineK(arg1: Kind<ForListK, A>): ListK<A> =
+    arrow.core.ListK.alternative().run {
+  this@combineK.combineK<A>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("optional")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("map(::Some) + listOf(None)", "arrow.core.Some", "arrow.core.None"))
+fun <A> Kind<ForListK, A>.optional(): ListK<Option<A>> = arrow.core.ListK.alternative().run {
+  this@optional.optional<A>() as arrow.core.ListK<arrow.core.Option<A>>
+}
+
+@JvmName("guard")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("if (arg0) listOf(Unit) else emptyList()"))
+fun guard(arg0: Boolean): ListK<Unit> = arrow.core.ListK
+   .alternative()
+   .guard(arg0) as arrow.core.ListK<kotlin.Unit>
+
+@JvmName("lazyOrElse")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("this + arg1()"))
+fun <A> Kind<ForListK, A>.lazyOrElse(arg1: Function0<Kind<ForListK, A>>): ListK<A> =
+    arrow.core.ListK.alternative().run {
+  this@lazyOrElse.lazyOrElse<A>(arg1) as arrow.core.ListK<A>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Alternative typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.alternative(): ListKAlternative = alternative_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/applicative/ListKApplicative.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/applicative/ListKApplicative.kt
new file mode 100644
index 000000000..38edf9c9a
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/applicative/ListKApplicative.kt
@@ -0,0 +1,92 @@
+package arrow.core.extensions.listk.applicative
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKApplicative
+import arrow.typeclasses.Monoid
+import kotlin.Function1
+import kotlin.Int
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val applicative_singleton: ListKApplicative = object :
+    arrow.core.extensions.ListKApplicative {}
+
+@JvmName("just1")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("listOf(this)"))
+fun <A> A.just(): ListK<A> = arrow.core.ListK.applicative().run {
+  this@just.just<A>() as arrow.core.ListK<A>
+}
+
+@JvmName("unit")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("listOf(Unit)"))
+fun unit(): ListK<Unit> = arrow.core.ListK
+   .applicative()
+   .unit() as arrow.core.ListK<kotlin.Unit>
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("map(arg1)"))
+fun <A, B> Kind<ForListK, A>.map(arg1: Function1<A, B>): ListK<B> =
+    arrow.core.ListK.applicative().run {
+  this@map.map<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@JvmName("replicate")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("replicate(arg1)", "arrow.core.replicate"))
+fun <A> Kind<ForListK, A>.replicate(arg1: Int): ListK<List<A>> =
+    arrow.core.ListK.applicative().run {
+  this@replicate.replicate<A>(arg1) as arrow.core.ListK<kotlin.collections.List<A>>
+}
+
+@JvmName("replicate")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("replicate(arg1, arg2)", "arrow.core.replicate"))
+fun <A> Kind<ForListK, A>.replicate(arg1: Int, arg2: Monoid<A>): ListK<A> =
+    arrow.core.ListK.applicative().run {
+  this@replicate.replicate<A>(arg1, arg2) as arrow.core.ListK<A>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Applicative typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.applicative(): ListKApplicative = applicative_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/apply/ListKApply.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/apply/ListKApply.kt
new file mode 100644
index 000000000..b8ea5e563
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/apply/ListKApply.kt
@@ -0,0 +1,962 @@
+package arrow.core.extensions.listk.apply
+
+import arrow.Kind
+import arrow.core.Eval
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Tuple10
+import arrow.core.Tuple2
+import arrow.core.Tuple3
+import arrow.core.Tuple4
+import arrow.core.Tuple5
+import arrow.core.Tuple6
+import arrow.core.Tuple7
+import arrow.core.Tuple8
+import arrow.core.Tuple9
+import arrow.core.extensions.ListKApply
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val apply_singleton: ListKApply = object : arrow.core.extensions.ListKApply {}
+
+@JvmName("ap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("_ap(arg1)", "arrow.core.ap"))
+fun <A, B> Kind<ForListK, A>.ap(arg1: Kind<ForListK, Function1<A, B>>): ListK<B> =
+  arrow.core.ListK.apply().run {
+    this@ap.ap<A, B>(arg1) as arrow.core.ListK<B>
+  }
+
+@JvmName("apEval")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("arg1.map { this.ap(it.fix()) }.map { it.k() }", "arrow.core.k", "arrow.core.fix"))
+fun <A, B> Kind<ForListK, A>.apEval(arg1: Eval<Kind<ForListK, Function1<A, B>>>):
+  Eval<Kind<ForListK, B>> = arrow.core.ListK.apply().run {
+  this@apEval.apEval<A, B>(arg1) as arrow.core.Eval<arrow.Kind<arrow.core.ForListK, B>>
+}
+
+@JvmName("map2Eval")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("apEval(arg1.map { it.fix().map { b -> { a: A -> arg2(Tuple2(a, b)) } } })", "arrow.core.k", "arrow.core.Tuple2"))
+fun <A, B, Z> Kind<ForListK, A>.map2Eval(
+  arg1: Eval<Kind<ForListK, B>>,
+  arg2: Function1<Tuple2<A,
+    B>, Z>
+): Eval<Kind<ForListK, Z>> = arrow.core.ListK.apply().run {
+  this@map2Eval.map2Eval<A, B, Z>(arg1, arg2) as arrow.core.Eval<arrow.Kind<arrow.core.ForListK, Z>>
+}
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1).map(arg2)", "arrow.core.tupledN"))
+fun <A, B, Z> map(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Function1<Tuple2<A, B>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .map<A, B, Z>(arg0, arg1, arg2) as arrow.core.ListK<Z>
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1).map(arg2)", "arrow.core.tupledN"))
+fun <A, B, Z> mapN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Function1<Tuple2<A, B>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .mapN<A, B, Z>(arg0, arg1, arg2) as arrow.core.ListK<Z>
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2).map(arg3)", "arrow.core.tupledN"))
+fun <A, B, C, Z> map(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Function1<Tuple3<A, B, C>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .map<A, B, C, Z>(arg0, arg1, arg2, arg3) as arrow.core.ListK<Z>
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2).map(arg3)", "arrow.core.tupledN"))
+fun <A, B, C, Z> mapN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Function1<Tuple3<A, B, C>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .mapN<A, B, C, Z>(arg0, arg1, arg2, arg3) as arrow.core.ListK<Z>
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3).map(arg4)", "arrow.core.tupledN"))
+fun <A, B, C, D, Z> map(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Function1<Tuple4<A, B, C, D>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .map<A, B, C, D, Z>(arg0, arg1, arg2, arg3, arg4) as arrow.core.ListK<Z>
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3).map(arg4)", "arrow.core.tupledN"))
+fun <A, B, C, D, Z> mapN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Function1<Tuple4<A, B, C, D>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .mapN<A, B, C, D, Z>(arg0, arg1, arg2, arg3, arg4) as arrow.core.ListK<Z>
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4).map(arg5)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, Z> map(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Function1<Tuple5<A, B, C, D, E>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .map<A, B, C, D, E, Z>(arg0, arg1, arg2, arg3, arg4, arg5) as arrow.core.ListK<Z>
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4).map(arg5)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, Z> mapN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Function1<Tuple5<A, B, C, D, E>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .mapN<A, B, C, D, E, Z>(arg0, arg1, arg2, arg3, arg4, arg5) as arrow.core.ListK<Z>
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5).map(arg6)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, Z> map(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Function1<Tuple6<A, B, C, D, E, FF>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .map<A, B, C, D, E, FF, Z>(arg0, arg1, arg2, arg3, arg4, arg5, arg6) as arrow.core.ListK<Z>
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5).map(arg6)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, Z> mapN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Function1<Tuple6<A, B, C, D, E, FF>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .mapN<A, B, C, D, E, FF, Z>(arg0, arg1, arg2, arg3, arg4, arg5, arg6) as arrow.core.ListK<Z>
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6).map(arg7)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, Z> map(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Function1<Tuple7<A, B, C, D, E, FF, G>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .map<A, B, C, D, E, FF, G, Z>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) as
+  arrow.core.ListK<Z>
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6).map(arg7)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, Z> mapN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Function1<Tuple7<A, B, C, D, E, FF, G>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .mapN<A, B, C, D, E, FF, G, Z>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) as
+  arrow.core.ListK<Z>
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7).map(arg8)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, Z> map(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>,
+  arg8: Function1<Tuple8<A, B, C, D, E, FF, G, H>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .map<A, B, C, D, E, FF, G, H, Z>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) as
+  arrow.core.ListK<Z>
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7).map(arg8)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, Z> mapN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>,
+  arg8: Function1<Tuple8<A, B, C, D, E, FF, G, H>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .mapN<A, B, C, D, E, FF, G, H, Z>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) as
+  arrow.core.ListK<Z>
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8).map(arg9)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, Z> map(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>,
+  arg8: Kind<ForListK, I>,
+  arg9: Function1<Tuple9<A, B, C, D, E, FF, G, H, I>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .map<A, B, C, D, E, FF, G, H, I, Z>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+  as arrow.core.ListK<Z>
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8).map(arg9)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, Z> mapN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>,
+  arg8: Kind<ForListK, I>,
+  arg9: Function1<Tuple9<A, B, C, D, E, FF, G, H, I>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .mapN<A, B, C, D, E, FF, G, H, I, Z>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+  as arrow.core.ListK<Z>
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9).map(arg10)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, J, Z> map(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>,
+  arg8: Kind<ForListK, I>,
+  arg9: Kind<ForListK, J>,
+  arg10: Function1<Tuple10<A, B, C, D, E, FF, G, H, I, J>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .map<A, B, C, D, E, FF, G, H, I, J,
+    Z>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) as arrow.core.ListK<Z>
+
+@JvmName("mapN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9).map(arg10)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, J, Z> mapN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>,
+  arg8: Kind<ForListK, I>,
+  arg9: Kind<ForListK, J>,
+  arg10: Function1<Tuple10<A, B, C, D, E, FF, G, H, I, J>, Z>
+): ListK<Z> = arrow.core.ListK
+  .apply()
+  .mapN<A, B, C, D, E, FF, G, H, I, J,
+    Z>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) as arrow.core.ListK<Z>
+
+@JvmName("map2")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("map2(arg1, arg2)", "arrow.core.map2"))
+fun <A, B, Z> Kind<ForListK, A>.map2(arg1: Kind<ForListK, B>, arg2: Function1<Tuple2<A, B>, Z>):
+  ListK<Z> = arrow.core.ListK.apply().run {
+  this@map2.map2<A, B, Z>(arg1, arg2) as arrow.core.ListK<Z>
+}
+
+@JvmName("product")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B> Kind<ForListK, A>.product(arg1: Kind<ForListK, B>): ListK<Tuple2<A, B>> =
+  arrow.core.ListK.apply().run {
+    this@product.product<A, B>(arg1) as arrow.core.ListK<arrow.core.Tuple2<A, B>>
+  }
+
+@JvmName("product1")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, Z> Kind<ForListK, Tuple2<A, B>>.product(arg1: Kind<ForListK, Z>): ListK<Tuple3<A, B, Z>> =
+  arrow.core.ListK.apply().run {
+    this@product.product<A, B, Z>(arg1) as arrow.core.ListK<arrow.core.Tuple3<A, B, Z>>
+  }
+
+@JvmName("product2")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, Z> Kind<ForListK, Tuple3<A, B, C>>.product(arg1: Kind<ForListK, Z>): ListK<Tuple4<A,
+  B, C, Z>> = arrow.core.ListK.apply().run {
+  this@product.product<A, B, C, Z>(arg1) as arrow.core.ListK<arrow.core.Tuple4<A, B, C, Z>>
+}
+
+@JvmName("product3")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, Z> Kind<ForListK, Tuple4<A, B, C, D>>.product(arg1: Kind<ForListK, Z>):
+  ListK<Tuple5<A, B, C, D, Z>> = arrow.core.ListK.apply().run {
+  this@product.product<A, B, C, D, Z>(arg1) as arrow.core.ListK<arrow.core.Tuple5<A, B, C, D, Z>>
+}
+
+@JvmName("product4")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, E, Z> Kind<ForListK, Tuple5<A, B, C, D, E>>.product(arg1: Kind<ForListK, Z>):
+  ListK<Tuple6<A, B, C, D, E, Z>> = arrow.core.ListK.apply().run {
+  this@product.product<A, B, C, D, E, Z>(arg1) as arrow.core.ListK<arrow.core.Tuple6<A, B, C, D, E,
+    Z>>
+}
+
+@JvmName("product5")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, E, FF, Z> Kind<ForListK, Tuple6<A, B, C, D, E, FF>>.product(
+  arg1: Kind<ForListK,
+    Z>
+): ListK<Tuple7<A, B, C, D, E, FF, Z>> = arrow.core.ListK.apply().run {
+  this@product.product<A, B, C, D, E, FF, Z>(arg1) as arrow.core.ListK<arrow.core.Tuple7<A, B, C, D,
+    E, FF, Z>>
+}
+
+@JvmName("product6")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, E, FF, G, Z> Kind<ForListK, Tuple7<A, B, C, D, E, FF,
+  G>>.product(arg1: Kind<ForListK, Z>): ListK<Tuple8<A, B, C, D, E, FF, G, Z>> =
+  arrow.core.ListK.apply().run {
+    this@product.product<A, B, C, D, E, FF, G, Z>(arg1) as arrow.core.ListK<arrow.core.Tuple8<A, B, C,
+      D, E, FF, G, Z>>
+  }
+
+@JvmName("product7")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, E, FF, G, H, Z> Kind<ForListK, Tuple8<A, B, C, D, E, FF, G,
+  H>>.product(arg1: Kind<ForListK, Z>): ListK<Tuple9<A, B, C, D, E, FF, G, H, Z>> =
+  arrow.core.ListK.apply().run {
+    this@product.product<A, B, C, D, E, FF, G, H, Z>(arg1) as arrow.core.ListK<arrow.core.Tuple9<A, B,
+      C, D, E, FF, G, H, Z>>
+  }
+
+@JvmName("product8")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B, C, D, E, FF, G, H, I, Z> Kind<ForListK, Tuple9<A, B, C, D, E, FF, G, H,
+  I>>.product(arg1: Kind<ForListK, Z>): ListK<Tuple10<A, B, C, D, E, FF, G, H, I, Z>> =
+  arrow.core.ListK.apply().run {
+    this@product.product<A, B, C, D, E, FF, G, H, I, Z>(arg1) as
+      arrow.core.ListK<arrow.core.Tuple10<A, B, C, D, E, FF, G, H, I, Z>>
+  }
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1)", "arrow.core.tupledN"))
+fun <A, B> tupled(arg0: Kind<ForListK, A>, arg1: Kind<ForListK, B>): ListK<Tuple2<A, B>> =
+  arrow.core.ListK
+    .apply()
+    .tupled<A, B>(arg0, arg1) as arrow.core.ListK<arrow.core.Tuple2<A, B>>
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1)", "arrow.core.tupledN"))
+fun <A, B> tupledN(arg0: Kind<ForListK, A>, arg1: Kind<ForListK, B>): ListK<Tuple2<A, B>> =
+  arrow.core.ListK
+    .apply()
+    .tupledN<A, B>(arg0, arg1) as arrow.core.ListK<arrow.core.Tuple2<A, B>>
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2)", "arrow.core.tupledN"))
+fun <A, B, C> tupled(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>
+): ListK<Tuple3<A, B, C>> = arrow.core.ListK
+  .apply()
+  .tupled<A, B, C>(arg0, arg1, arg2) as arrow.core.ListK<arrow.core.Tuple3<A, B, C>>
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2)", "arrow.core.tupledN"))
+fun <A, B, C> tupledN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>
+): ListK<Tuple3<A, B, C>> = arrow.core.ListK
+  .apply()
+  .tupledN<A, B, C>(arg0, arg1, arg2) as arrow.core.ListK<arrow.core.Tuple3<A, B, C>>
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3)", "arrow.core.tupledN"))
+fun <A, B, C, D> tupled(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>
+): ListK<Tuple4<A, B, C, D>> = arrow.core.ListK
+  .apply()
+  .tupled<A, B, C, D>(arg0, arg1, arg2, arg3) as arrow.core.ListK<arrow.core.Tuple4<A, B, C, D>>
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3)", "arrow.core.tupledN"))
+fun <A, B, C, D> tupledN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>
+): ListK<Tuple4<A, B, C, D>> = arrow.core.ListK
+  .apply()
+  .tupledN<A, B, C, D>(arg0, arg1, arg2, arg3) as arrow.core.ListK<arrow.core.Tuple4<A, B, C, D>>
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4)", "arrow.core.tupledN"))
+fun <A, B, C, D, E> tupled(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>
+): ListK<Tuple5<A, B, C, D, E>> = arrow.core.ListK
+  .apply()
+  .tupled<A, B, C, D, E>(arg0, arg1, arg2, arg3, arg4) as arrow.core.ListK<arrow.core.Tuple5<A, B,
+  C, D, E>>
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4)", "arrow.core.tupledN"))
+fun <A, B, C, D, E> tupledN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>
+): ListK<Tuple5<A, B, C, D, E>> = arrow.core.ListK
+  .apply()
+  .tupledN<A, B, C, D, E>(arg0, arg1, arg2, arg3, arg4) as arrow.core.ListK<arrow.core.Tuple5<A, B,
+  C, D, E>>
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF> tupled(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>
+): ListK<Tuple6<A, B, C, D, E, FF>> = arrow.core.ListK
+  .apply()
+  .tupled<A, B, C, D, E, FF>(arg0, arg1, arg2, arg3, arg4, arg5) as
+  arrow.core.ListK<arrow.core.Tuple6<A, B, C, D, E, FF>>
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF> tupledN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>
+): ListK<Tuple6<A, B, C, D, E, FF>> = arrow.core.ListK
+  .apply()
+  .tupledN<A, B, C, D, E, FF>(arg0, arg1, arg2, arg3, arg4, arg5) as
+  arrow.core.ListK<arrow.core.Tuple6<A, B, C, D, E, FF>>
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G> tupled(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>
+): ListK<Tuple7<A, B, C, D, E, FF, G>> = arrow.core.ListK
+  .apply()
+  .tupled<A, B, C, D, E, FF, G>(arg0, arg1, arg2, arg3, arg4, arg5, arg6) as
+  arrow.core.ListK<arrow.core.Tuple7<A, B, C, D, E, FF, G>>
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G> tupledN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>
+): ListK<Tuple7<A, B, C, D, E, FF, G>> = arrow.core.ListK
+  .apply()
+  .tupledN<A, B, C, D, E, FF, G>(arg0, arg1, arg2, arg3, arg4, arg5, arg6) as
+  arrow.core.ListK<arrow.core.Tuple7<A, B, C, D, E, FF, G>>
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H> tupled(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>
+): ListK<Tuple8<A, B, C, D, E, FF, G, H>> = arrow.core.ListK
+  .apply()
+  .tupled<A, B, C, D, E, FF, G, H>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) as
+  arrow.core.ListK<arrow.core.Tuple8<A, B, C, D, E, FF, G, H>>
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H> tupledN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>
+): ListK<Tuple8<A, B, C, D, E, FF, G, H>> = arrow.core.ListK
+  .apply()
+  .tupledN<A, B, C, D, E, FF, G, H>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) as
+  arrow.core.ListK<arrow.core.Tuple8<A, B, C, D, E, FF, G, H>>
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I> tupled(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>,
+  arg8: Kind<ForListK, I>
+): ListK<Tuple9<A, B, C, D, E, FF, G, H, I>> = arrow.core.ListK
+  .apply()
+  .tupled<A, B, C, D, E, FF, G, H, I>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) as
+  arrow.core.ListK<arrow.core.Tuple9<A, B, C, D, E, FF, G, H, I>>
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I> tupledN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>,
+  arg8: Kind<ForListK, I>
+): ListK<Tuple9<A, B, C, D, E, FF, G, H, I>> = arrow.core.ListK
+  .apply()
+  .tupledN<A, B, C, D, E, FF, G, H, I>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) as
+  arrow.core.ListK<arrow.core.Tuple9<A, B, C, D, E, FF, G, H, I>>
+
+@JvmName("tupled")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, J> tupled(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>,
+  arg8: Kind<ForListK, I>,
+  arg9: Kind<ForListK, J>
+): ListK<Tuple10<A, B, C, D, E, FF, G, H, I, J>> = arrow.core.ListK
+  .apply()
+  .tupled<A, B, C, D, E, FF, G, H, I,
+    J>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) as
+  arrow.core.ListK<arrow.core.Tuple10<A, B, C, D, E, FF, G, H, I, J>>
+
+@JvmName("tupledN")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.tupledN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)", "arrow.core.tupledN"))
+fun <A, B, C, D, E, FF, G, H, I, J> tupledN(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Kind<ForListK, C>,
+  arg3: Kind<ForListK, D>,
+  arg4: Kind<ForListK, E>,
+  arg5: Kind<ForListK, FF>,
+  arg6: Kind<ForListK, G>,
+  arg7: Kind<ForListK, H>,
+  arg8: Kind<ForListK, I>,
+  arg9: Kind<ForListK, J>
+): ListK<Tuple10<A, B, C, D, E, FF, G, H, I, J>> = arrow.core.ListK
+  .apply()
+  .tupledN<A, B, C, D, E, FF, G, H, I,
+    J>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) as
+  arrow.core.ListK<arrow.core.Tuple10<A, B, C, D, E, FF, G, H, I, J>>
+
+@JvmName("followedBy")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("flatMap { arg1 }"))
+fun <A, B> Kind<ForListK, A>.followedBy(arg1: Kind<ForListK, B>): ListK<B> =
+  arrow.core.ListK.apply().run {
+    this@followedBy.followedBy<A, B>(arg1) as arrow.core.ListK<B>
+  }
+
+@JvmName("apTap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("ListK.mapN(this, arg1) { left, _ -> left }", "arrow.core.mapN"))
+fun <A, B> Kind<ForListK, A>.apTap(arg1: Kind<ForListK, B>): ListK<A> =
+  arrow.core.ListK.apply().run {
+    this@apTap.apTap<A, B>(arg1) as arrow.core.ListK<A>
+  }
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Apply typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.apply(): ListKApply = apply_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/crosswalk/ListKCrosswalk.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/crosswalk/ListKCrosswalk.kt
new file mode 100644
index 000000000..590abfb5c
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/crosswalk/ListKCrosswalk.kt
@@ -0,0 +1,53 @@
+package arrow.core.extensions.listk.crosswalk
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKCrosswalk
+import arrow.typeclasses.Align
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val crosswalk_singleton: ListKCrosswalk = object : arrow.core.extensions.ListKCrosswalk {}
+
+@JvmName("crosswalk")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with crosswalk, crosswalkMap or crosswalkNull from arrow.core.*")
+fun <F, A, B> crosswalk(
+  arg0: Align<F>,
+  arg1: Kind<ForListK, A>,
+  arg2: Function1<A, Kind<F, B>>
+): Kind<F, Kind<ForListK, B>> = arrow.core.ListK
+   .crosswalk()
+   .crosswalk<F, A, B>(arg0, arg1, arg2) as arrow.Kind<F, arrow.Kind<arrow.core.ForListK, B>>
+
+@JvmName("sequenceL")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with sequenceValidated or sequenceEither from arrow.core.*")
+fun <F, A> sequenceL(arg0: Align<F>, arg1: Kind<ForListK, Kind<F, A>>): Kind<F, Kind<ForListK, A>> =
+    arrow.core.ListK
+   .crosswalk()
+   .sequenceL<F, A>(arg0, arg1) as arrow.Kind<F, arrow.Kind<arrow.core.ForListK, A>>
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Crosswalk typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.crosswalk(): ListKCrosswalk = crosswalk_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/eq/ListKEq.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/eq/ListKEq.kt
new file mode 100644
index 000000000..384ade335
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/eq/ListKEq.kt
@@ -0,0 +1,44 @@
+package arrow.core.extensions.listk.eq
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKEq
+import arrow.typeclasses.Eq
+import kotlin.Boolean
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+@JvmName("eqv")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("neqv(EQL, EQR, arg1)", "arrow.core.neqv"))
+fun <A> Kind<ForListK, A>.eqv(EQ: Eq<A>, arg1: Kind<ForListK, A>): Boolean =
+    arrow.core.ListK.eq<A>(EQ).run {
+  this@eqv.eqv(arg1) as kotlin.Boolean
+}
+
+@JvmName("neqv")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("neqv(EQL, EQR, arg1)", "arrow.core.neqv"))
+fun <A> Kind<ForListK, A>.neqv(EQ: Eq<A>, arg1: Kind<ForListK, A>): Boolean =
+    arrow.core.ListK.eq<A>(EQ).run {
+  this@neqv.neqv(arg1) as kotlin.Boolean
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listEq(EQ)", "arrow.core.listEq"))
+inline fun <A> Companion.eq(EQ: Eq<A>): ListKEq<A> = object : arrow.core.extensions.ListKEq<A> {
+    override fun EQ(): arrow.typeclasses.Eq<A> = EQ }
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/eqK/ListKEqK.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/eqK/ListKEqK.kt
new file mode 100644
index 000000000..907af4888
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/eqK/ListKEqK.kt
@@ -0,0 +1,49 @@
+package arrow.core.extensions.listk.eqK
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKEqK
+import arrow.typeclasses.Eq
+import kotlin.Boolean
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val eqK_singleton: ListKEqK = object : arrow.core.extensions.ListKEqK {}
+
+@JvmName("eqK")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+fun <A> Kind<ForListK, A>.eqK(arg1: Kind<ForListK, A>, arg2: Eq<A>): Boolean =
+    arrow.core.ListK.eqK().run {
+  this@eqK.eqK<A>(arg1, arg2) as kotlin.Boolean
+}
+
+@JvmName("liftEq")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+fun <A> liftEq(arg0: Eq<A>): Eq<Kind<ForListK, A>> = arrow.core.ListK
+   .eqK()
+   .liftEq<A>(arg0) as arrow.typeclasses.Eq<arrow.Kind<arrow.core.ForListK, A>>
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+inline fun Companion.eqK(): ListKEqK = eqK_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/foldable/ListKFoldable.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/foldable/ListKFoldable.kt
new file mode 100644
index 000000000..a18800b2d
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/foldable/ListKFoldable.kt
@@ -0,0 +1,413 @@
+package arrow.core.extensions.listk.foldable
+
+import arrow.Kind
+import arrow.core.Eval
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Option
+import arrow.core.extensions.ListKFoldable
+import arrow.typeclasses.Applicative
+import arrow.typeclasses.Monad
+import arrow.typeclasses.Monoid
+import kotlin.Boolean
+import kotlin.Function1
+import kotlin.Function2
+import kotlin.Long
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val foldable_singleton: ListKFoldable = object : arrow.core.extensions.ListKFoldable {}
+
+@JvmName("foldLeft")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("fold(arg1, arg2)"))
+fun <A, B> Kind<ForListK, A>.foldLeft(arg1: B, arg2: Function2<B, A, B>): B =
+  arrow.core.ListK.foldable().run {
+    this@foldLeft.foldLeft<A, B>(arg1, arg2) as B
+  }
+
+@JvmName("foldRight")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("foldRight(arg1, arg2)", "arrow.core.foldRight"))
+fun <A, B> Kind<ForListK, A>.foldRight(arg1: Eval<B>, arg2: Function2<A, Eval<B>, Eval<B>>): Eval<B> =
+  arrow.core.ListK.foldable().run {
+    this@foldRight.foldRight<A, B>(arg1, arg2) as arrow.core.Eval<B>
+  }
+
+@JvmName("fold")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("combineAll(arg1)", "arrow.core.combineAll"))
+fun <A> Kind<ForListK, A>.fold(arg1: Monoid<A>): A = arrow.core.ListK.foldable().run {
+  this@fold.fold<A>(arg1) as A
+}
+
+@JvmName("reduceLeftToOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(reduceNullable(arg1, arg2))", "arrow.core.reduceNullable", "arrow.core.Option"))
+fun <A, B> Kind<ForListK, A>.reduceLeftToOption(arg1: Function1<A, B>, arg2: Function2<B, A, B>):
+  Option<B> = arrow.core.ListK.foldable().run {
+  this@reduceLeftToOption.reduceLeftToOption<A, B>(arg1, arg2) as arrow.core.Option<B>
+}
+
+@JvmName("reduceRightToOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("reduceRightNullable(arg1, arg2).map { Option.fromNullable(it) }", "arrow.core.reduceRightNullable", "arrow.core.Option"))
+fun <A, B> Kind<ForListK, A>.reduceRightToOption(
+  arg1: Function1<A, B>,
+  arg2: Function2<A, Eval<B>,
+    Eval<B>>
+): Eval<Option<B>> = arrow.core.ListK.foldable().run {
+  this@reduceRightToOption.reduceRightToOption<A, B>(arg1, arg2) as
+    arrow.core.Eval<arrow.core.Option<B>>
+}
+
+@JvmName("reduceLeftOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith(" Option.fromNullable(reduceNullable({ it }, arg1))", "arrow.core.reduceNullable", "arrow.core.Option"))
+fun <A> Kind<ForListK, A>.reduceLeftOption(arg1: Function2<A, A, A>): Option<A> =
+  arrow.core.ListK.foldable().run {
+    this@reduceLeftOption.reduceLeftOption<A>(arg1) as arrow.core.Option<A>
+  }
+
+@JvmName("reduceRightOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("reduceRightOption({ it }, arg2).map { Option.fromNullable(it) }", "arrow.core.reduceRightNullable", "arrow.core.Option"))
+fun <A> Kind<ForListK, A>.reduceRightOption(arg1: Function2<A, Eval<A>, Eval<A>>): Eval<Option<A>> =
+  arrow.core.ListK.foldable().run {
+    this@reduceRightOption.reduceRightOption<A>(arg1) as arrow.core.Eval<arrow.core.Option<A>>
+  }
+
+@JvmName("combineAll")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("combineAll(arg1)", "arrow.core.combineAll"))
+fun <A> Kind<ForListK, A>.combineAll(arg1: Monoid<A>): A = arrow.core.ListK.foldable().run {
+  this@combineAll.combineAll<A>(arg1) as A
+}
+
+@JvmName("foldMap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("foldMap(arg1, arg2)", "arrow.core.foldMap"))
+fun <A, B> Kind<ForListK, A>.foldMap(arg1: Monoid<B>, arg2: Function1<A, B>): B =
+  arrow.core.ListK.foldable().run {
+    this@foldMap.foldMap<A, B>(arg1, arg2) as B
+  }
+
+@JvmName("orEmpty")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listOf(arg1.empty())"))
+fun <A> orEmpty(arg0: Applicative<ForListK>, arg1: Monoid<A>): ListK<A> = arrow.core.ListK
+  .foldable()
+  .orEmpty<A>(arg0, arg1) as arrow.core.ListK<A>
+
+@JvmName("traverse_")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with traverseValidated_ or traverseEither_ from arrow.core.*")
+fun <G, A, B> Kind<ForListK, A>.traverse_(arg1: Applicative<G>, arg2: Function1<A, Kind<G, B>>):
+  Kind<G, Unit> = arrow.core.ListK.foldable().run {
+  this@traverse_.traverse_<G, A, B>(arg1, arg2) as arrow.Kind<G, kotlin.Unit>
+}
+
+@JvmName("sequence_")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with sequenceValidated_ or sequenceEither_ from arrow.core.*")
+fun <G, A> Kind<ForListK, Kind<G, A>>.sequence_(arg1: Applicative<G>): Kind<G, Unit> =
+  arrow.core.ListK.foldable().run {
+    this@sequence_.sequence_<G, A>(arg1) as arrow.Kind<G, kotlin.Unit>
+  }
+
+@JvmName("find")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(firstOrNull(arg1))", "arrow.core.Option"))
+fun <A> Kind<ForListK, A>.find(arg1: Function1<A, Boolean>): Option<A> =
+  arrow.core.ListK.foldable().run {
+    this@find.find<A>(arg1) as arrow.core.Option<A>
+  }
+
+@JvmName("exists")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("any(arg1)"))
+fun <A> Kind<ForListK, A>.exists(arg1: Function1<A, Boolean>): Boolean =
+  arrow.core.ListK.foldable().run {
+    this@exists.exists<A>(arg1) as kotlin.Boolean
+  }
+
+@JvmName("forAll")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("all(arg1)"))
+fun <A> Kind<ForListK, A>.forAll(arg1: Function1<A, Boolean>): Boolean =
+  arrow.core.ListK.foldable().run {
+    this@forAll.forAll<A>(arg1) as kotlin.Boolean
+  }
+
+@JvmName("all")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("all(arg1)"))
+fun <A> Kind<ForListK, A>.all(arg1: Function1<A, Boolean>): Boolean =
+  arrow.core.ListK.foldable().run {
+    this@all.all<A>(arg1) as kotlin.Boolean
+  }
+
+@JvmName("isEmpty")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("isEmpty()"))
+fun <A> Kind<ForListK, A>.isEmpty(): Boolean = arrow.core.ListK.foldable().run {
+  this@isEmpty.isEmpty<A>() as kotlin.Boolean
+}
+
+@JvmName("nonEmpty")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("isNotEmpty()"))
+fun <A> Kind<ForListK, A>.nonEmpty(): Boolean = arrow.core.ListK.foldable().run {
+  this@nonEmpty.nonEmpty<A>() as kotlin.Boolean
+}
+
+@JvmName("isNotEmpty")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("isNotEmpty()"))
+fun <A> Kind<ForListK, A>.isNotEmpty(): Boolean = arrow.core.ListK.foldable().run {
+  this@isNotEmpty.isNotEmpty<A>() as kotlin.Boolean
+}
+
+@JvmName("size")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("size"))
+fun <A> Kind<ForListK, A>.size(arg1: Monoid<Long>): Long = arrow.core.ListK.foldable().run {
+  this@size.size<A>(arg1) as kotlin.Long
+}
+
+@JvmName("foldMapA")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Applicative typeclasses is deprecated. Use concrete methods on List")
+fun <G, A, B, AP : Applicative<G>, MO : Monoid<B>> Kind<ForListK, A>.foldMapA(
+  arg1: AP,
+  arg2: MO,
+  arg3: Function1<A, Kind<G, B>>
+): Kind<G, B> = arrow.core.ListK.foldable().run {
+  this@foldMapA.foldMapA<G, A, B, AP, MO>(arg1, arg2, arg3) as arrow.Kind<G, B>
+}
+
+@JvmName("foldMapM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Applicative typeclasses is deprecated. Use concrete methods on List")
+fun <G, A, B, MA : Monad<G>, MO : Monoid<B>> Kind<ForListK, A>.foldMapM(
+  arg1: MA,
+  arg2: MO,
+  arg3: Function1<A, Kind<G, B>>
+): Kind<G, B> = arrow.core.ListK.foldable().run {
+  this@foldMapM.foldMapM<G, A, B, MA, MO>(arg1, arg2, arg3) as arrow.Kind<G, B>
+}
+
+@JvmName("foldM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Applicative typeclasses is deprecated. Use concrete methods on List")
+fun <G, A, B> Kind<ForListK, A>.foldM(
+  arg1: Monad<G>,
+  arg2: B,
+  arg3: Function2<B, A, Kind<G, B>>
+): Kind<G, B> = arrow.core.ListK.foldable().run {
+  this@foldM.foldM<G, A, B>(arg1, arg2, arg3) as arrow.Kind<G, B>
+}
+
+@JvmName("get")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("[arg1]"))
+fun <A> Kind<ForListK, A>.get(arg1: Long): Option<A> = arrow.core.ListK.foldable().run {
+  this@get.get<A>(arg1) as arrow.core.Option<A>
+}
+
+@JvmName("firstOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(firstOrNull())", "arrow.core.Option"))
+fun <A> Kind<ForListK, A>.firstOption(): Option<A> = arrow.core.ListK.foldable().run {
+  this@firstOption.firstOption<A>() as arrow.core.Option<A>
+}
+
+@JvmName("firstOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(firstOrNull(arg1))", "arrow.core.Option"))
+fun <A> Kind<ForListK, A>.firstOption(arg1: Function1<A, Boolean>): Option<A> =
+  arrow.core.ListK.foldable().run {
+    this@firstOption.firstOption<A>(arg1) as arrow.core.Option<A>
+  }
+
+@JvmName("firstOrNone")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(firstOrNull())", "arrow.core.Option"))
+fun <A> Kind<ForListK, A>.firstOrNone(): Option<A> = arrow.core.ListK.foldable().run {
+  this@firstOrNone.firstOrNone<A>() as arrow.core.Option<A>
+}
+
+@JvmName("firstOrNone")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("Option.fromNullable(firstOrNull(arg1))", "arrow.core.Option"))
+fun <A> Kind<ForListK, A>.firstOrNone(arg1: Function1<A, Boolean>): Option<A> =
+  arrow.core.ListK.foldable().run {
+    this@firstOrNone.firstOrNone<A>(arg1) as arrow.core.Option<A>
+  }
+
+@JvmName("toList")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("this"))
+fun <A> Kind<ForListK, A>.toList(): List<A> = arrow.core.ListK.foldable().run {
+  this@toList.toList<A>() as kotlin.collections.List<A>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Foldable typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.foldable(): ListKFoldable = foldable_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/functor/ListKFunctor.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/functor/ListKFunctor.kt
new file mode 100644
index 000000000..5d1eed700
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/functor/ListKFunctor.kt
@@ -0,0 +1,199 @@
+package arrow.core.extensions.listk.functor
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKFunctor
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val functor_singleton: ListKFunctor = object : arrow.core.extensions.ListKFunctor {}
+
+/**
+ *  Transform the [F] wrapped value [A] into [B] preserving the [F] structure
+ *  Kind<F, A> -> Kind<F, B>
+ *
+ *  ```kotlin:ank:playground
+ *  import arrow.core.*
+ * import arrow.core.extensions.listk.functor.*
+ * import arrow.core.*
+ *
+ *
+ *  import arrow.core.extensions.listk.applicative.just
+ *
+ *  fun main(args: Array<String>) {
+ *   val result =
+ *   //sampleStart
+ *   "Hello".just().map({ "$it World" })
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ */
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("map(arg1)"))
+fun <A, B> Kind<ForListK, A>.map(arg1: Function1<A, B>): ListK<B> = arrow.core.ListK.functor().run {
+  this@map.map<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@JvmName("imap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("map(arg1)"))
+fun <A, B> Kind<ForListK, A>.imap(arg1: Function1<A, B>, arg2: Function1<B, A>): ListK<B> =
+    arrow.core.ListK.functor().run {
+  this@imap.imap<A, B>(arg1, arg2) as arrow.core.ListK<B>
+}
+
+/**
+ *  Lifts a function `A -> B` to the [F] structure returning a polymorphic function
+ *  that can be applied over all [F] values in the shape of Kind<F, A>
+ *
+ *  `A -> B -> Kind<F, A> -> Kind<F, B>`
+ *
+ *  ```kotlin:ank:playground
+ *  import arrow.core.*
+ * import arrow.core.extensions.listk.functor.*
+ * import arrow.core.*
+ *
+ *
+ *  import arrow.core.extensions.listk.applicative.just
+ *
+ *  fun main(args: Array<String>) {
+ *   val result =
+ *   //sampleStart
+ *   lift({ s: CharSequence -> "$s World" })("Hello".just())
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ */
+@JvmName("lift")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("{ l: List<A> -> l.map(arg0) }"))
+fun <A, B> lift(arg0: Function1<A, B>): Function1<Kind<ForListK, A>, Kind<ForListK, B>> =
+    arrow.core.ListK
+   .functor()
+   .lift<A, B>(arg0) as kotlin.Function1<arrow.Kind<arrow.core.ForListK, A>,
+    arrow.Kind<arrow.core.ForListK, B>>
+
+@JvmName("void")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("void()", "arrow.core.void"))
+fun <A> Kind<ForListK, A>.void(): ListK<Unit> = arrow.core.ListK.functor().run {
+  this@void.void<A>() as arrow.core.ListK<kotlin.Unit>
+}
+
+@JvmName("fproduct")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("fproduct(arg1)", "arrow.core.fproduct"))
+fun <A, B> Kind<ForListK, A>.fproduct(arg1: Function1<A, B>): ListK<Tuple2<A, B>> =
+    arrow.core.ListK.functor().run {
+  this@fproduct.fproduct<A, B>(arg1) as arrow.core.ListK<arrow.core.Tuple2<A, B>>
+}
+
+@JvmName("mapConst")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("mapConst(arg1)", "arrow.core.mapConst"))
+fun <A, B> Kind<ForListK, A>.mapConst(arg1: B): ListK<B> = arrow.core.ListK.functor().run {
+  this@mapConst.mapConst<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+/**
+ *  Replaces the [B] value inside [F] with [A] resulting in a Kind<F, A>
+ */
+@JvmName("mapConst")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg1.mapConst(this)", "arrow.core.mapConst"))
+fun <A, B> A.mapConst(arg1: Kind<ForListK, B>): ListK<A> = arrow.core.ListK.functor().run {
+  this@mapConst.mapConst<A, B>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("tupleLeft")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("tupleLeft(arg1)", "arrow.core.tupleLeft"))
+fun <A, B> Kind<ForListK, A>.tupleLeft(arg1: B): ListK<Tuple2<B, A>> =
+    arrow.core.ListK.functor().run {
+  this@tupleLeft.tupleLeft<A, B>(arg1) as arrow.core.ListK<arrow.core.Tuple2<B, A>>
+}
+
+@JvmName("tupleRight")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("tupleRight(arg1)", "arrow.core.tupleRight"))
+fun <A, B> Kind<ForListK, A>.tupleRight(arg1: B): ListK<Tuple2<A, B>> =
+    arrow.core.ListK.functor().run {
+  this@tupleRight.tupleRight<A, B>(arg1) as arrow.core.ListK<arrow.core.Tuple2<A, B>>
+}
+
+@JvmName("widen")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("widen()", "arrow.core.widen"))
+fun <B, A : B> Kind<ForListK, A>.widen(): ListK<B> = arrow.core.ListK.functor().run {
+  this@widen.widen<B, A>() as arrow.core.ListK<B>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Functor typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.functor(): ListKFunctor = functor_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/functorFilter/ListKFunctorFilter.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/functorFilter/ListKFunctorFilter.kt
new file mode 100644
index 000000000..a14b3b2b7
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/functorFilter/ListKFunctorFilter.kt
@@ -0,0 +1,78 @@
+package arrow.core.extensions.listk.functorFilter
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Option
+import arrow.core.extensions.ListKFunctorFilter
+import java.lang.Class
+import kotlin.Boolean
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val functorFilter_singleton: ListKFunctorFilter = object :
+    arrow.core.extensions.ListKFunctorFilter {}
+
+@JvmName("filterMap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("mapNotNull { arg1(it).orNull() }"))
+fun <A, B> Kind<ForListK, A>.filterMap(arg1: Function1<A, Option<B>>): ListK<B> =
+    arrow.core.ListK.functorFilter().run {
+  this@filterMap.filterMap<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@JvmName("flattenOption")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+fun <A> Kind<ForListK, Option<A>>.flattenOption(): ListK<A> = arrow.core.ListK.functorFilter().run {
+  this@flattenOption.flattenOption<A>() as arrow.core.ListK<A>
+}
+
+@JvmName("filter")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("mapNotNull { it.orNull() }"))
+fun <A> Kind<ForListK, A>.filter(arg1: Function1<A, Boolean>): ListK<A> =
+    arrow.core.ListK.functorFilter().run {
+  this@filter.filter<A>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("filterIsInstance")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("filter(arg1::isInstance).map { arg1.cast(it) }"))
+fun <A, B> Kind<ForListK, A>.filterIsInstance(arg1: Class<B>): ListK<B> =
+    arrow.core.ListK.functorFilter().run {
+  this@filterIsInstance.filterIsInstance<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Functor typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.functorFilter(): ListKFunctorFilter = functorFilter_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/hash/ListKHash.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/hash/ListKHash.kt
new file mode 100644
index 000000000..a41014e50
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/hash/ListKHash.kt
@@ -0,0 +1,43 @@
+package arrow.core.extensions.listk.hash
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKHash
+import arrow.typeclasses.Hash
+import kotlin.Int
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+@JvmName("hash")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("hash(HA)", "arrow.core.hash"))
+fun <A> Kind<ForListK, A>.hash(HA: Hash<A>): Int = arrow.core.ListK.hash<A>(HA).run {
+  this@hash.hash() as kotlin.Int
+}
+
+@JvmName("hashWithSalt")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("hashWithSalt(HA, arg1)", "arrow.core.hashWithSalt"))
+fun <A> Kind<ForListK, A>.hashWithSalt(HA: Hash<A>, arg1: Int): Int =
+    arrow.core.ListK.hash<A>(HA).run {
+  this@hashWithSalt.hashWithSalt(arg1) as kotlin.Int
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listHash(HA)", "arrow.core.listHash"))
+inline fun <A> Companion.hash(HA: Hash<A>): ListKHash<A> = object :
+    arrow.core.extensions.ListKHash<A> { override fun HA(): arrow.typeclasses.Hash<A> = HA }
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monad/ListKMonad.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monad/ListKMonad.kt
new file mode 100644
index 000000000..fc8df2a1c
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monad/ListKMonad.kt
@@ -0,0 +1,280 @@
+package arrow.core.extensions.listk.monad
+
+import arrow.Kind
+import arrow.core.Either
+import arrow.core.Eval
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKMonad
+import kotlin.Boolean
+import kotlin.Function0
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monad_singleton: ListKMonad = object : arrow.core.extensions.ListKMonad {}
+
+@JvmName("flatMap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap(arg1)"))
+fun <A, B> Kind<ForListK, A>.flatMap(arg1: Function1<A, Kind<ForListK, B>>): ListK<B> =
+    arrow.core.ListK.monad().run {
+  this@flatMap.flatMap<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@JvmName("tailRecM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("tailRecMIterable(arg0) { arg1(it) }"))
+fun <A, B> tailRecM(arg0: A, arg1: Function1<A, Kind<ForListK, Either<A, B>>>): ListK<B> =
+    arrow.core.ListK
+   .monad()
+   .tailRecM<A, B>(arg0, arg1) as arrow.core.ListK<B>
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("map(arg1)"))
+fun <A, B> Kind<ForListK, A>.map(arg1: Function1<A, B>): ListK<B> = arrow.core.ListK.monad().run {
+  this@map.map<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+/**
+ *  @see [Apply.ap]
+ */
+@JvmName("ap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("ap(arg1)", "arrow.core.ap"))
+fun <A, B> Kind<ForListK, A>.ap(arg1: Kind<ForListK, Function1<A, B>>): ListK<B> =
+    arrow.core.ListK.monad().run {
+  this@ap.ap<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@JvmName("flatten")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatten"))
+fun <A> Kind<ForListK, Kind<ForListK, A>>.flatten(): ListK<A> = arrow.core.ListK.monad().run {
+  this@flatten.flatten<A>() as arrow.core.ListK<A>
+}
+
+@JvmName("followedBy")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { arg1 }"))
+fun <A, B> Kind<ForListK, A>.followedBy(arg1: Kind<ForListK, B>): ListK<B> =
+    arrow.core.ListK.monad().run {
+  this@followedBy.followedBy<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@JvmName("apTap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1.map { a } }"))
+fun <A, B> Kind<ForListK, A>.apTap(arg1: Kind<ForListK, B>): ListK<A> =
+    arrow.core.ListK.monad().run {
+  this@apTap.apTap<A, B>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("followedByEval")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { arg1.value() }"))
+fun <A, B> Kind<ForListK, A>.followedByEval(arg1: Eval<Kind<ForListK, B>>): ListK<B> =
+    arrow.core.ListK.monad().run {
+  this@followedByEval.followedByEval<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@JvmName("effectM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1(a).map { a } }"))
+fun <A, B> Kind<ForListK, A>.effectM(arg1: Function1<A, Kind<ForListK, B>>): ListK<A> =
+    arrow.core.ListK.monad().run {
+  this@effectM.effectM<A, B>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("flatTap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1(a).map { a } }"))
+fun <A, B> Kind<ForListK, A>.flatTap(arg1: Function1<A, Kind<ForListK, B>>): ListK<A> =
+    arrow.core.ListK.monad().run {
+  this@flatTap.flatTap<A, B>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("productL")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1.map { a } }"))
+fun <A, B> Kind<ForListK, A>.productL(arg1: Kind<ForListK, B>): ListK<A> =
+    arrow.core.ListK.monad().run {
+  this@productL.productL<A, B>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("forEffect")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1.map { a } }"))
+fun <A, B> Kind<ForListK, A>.forEffect(arg1: Kind<ForListK, B>): ListK<A> =
+    arrow.core.ListK.monad().run {
+  this@forEffect.forEffect<A, B>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("productLEval")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1.value().map { a } }"))
+fun <A, B> Kind<ForListK, A>.productLEval(arg1: Eval<Kind<ForListK, B>>): ListK<A> =
+    arrow.core.ListK.monad().run {
+  this@productLEval.productLEval<A, B>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("forEffectEval")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1.value().map { a } }"))
+fun <A, B> Kind<ForListK, A>.forEffectEval(arg1: Eval<Kind<ForListK, B>>): ListK<A> =
+    arrow.core.ListK.monad().run {
+  this@forEffectEval.forEffectEval<A, B>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("mproduct")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("flatMap { a -> arg1(a).map { b -> Tuple2(a, b) } }"))
+fun <A, B> Kind<ForListK, A>.mproduct(arg1: Function1<A, Kind<ForListK, B>>): ListK<Tuple2<A, B>> =
+    arrow.core.ListK.monad().run {
+  this@mproduct.mproduct<A, B>(arg1) as arrow.core.ListK<arrow.core.Tuple2<A, B>>
+}
+
+@JvmName("ifM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("ifM(arg1, arg2)", "arrow.core.ifM"))
+fun <B> Kind<ForListK, Boolean>.ifM(
+  arg1: Function0<Kind<ForListK, B>>,
+  arg2: Function0<Kind<ForListK, B>>
+): ListK<B> = arrow.core.ListK.monad().run {
+  this@ifM.ifM<B>(arg1, arg2) as arrow.core.ListK<B>
+}
+
+@JvmName("selectM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("selectM(arg1)", "arrow.core.selectM"))
+fun <A, B> Kind<ForListK, Either<A, B>>.selectM(arg1: Kind<ForListK, Function1<A, B>>): ListK<B> =
+    arrow.core.ListK.monad().run {
+  this@selectM.selectM<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@JvmName("select")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("select(arg1)", "arrow.core.select"))
+fun <A, B> Kind<ForListK, Either<A, B>>.select(arg1: Kind<ForListK, Function1<A, B>>): ListK<B> =
+    arrow.core.ListK.monad().run {
+  this@select.select<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+/**
+ *  ank_macro_hierarchy(arrow.typeclasses.Monad)
+ *
+ *  [Monad] abstract over the ability to declare sequential computations that are dependent in the order or
+ *  the results of previous computations.
+ *
+ *  Given a type constructor [F] with a value of [A] we can compose multiple operations of type
+ *  `Kind<F, ?>` where `?` denotes a value being transformed.
+ *
+ *  This is true for all type constructors that can support the [Monad] type class including and not limited to
+ *  [IO], [ObservableK], [Option], [Either], [List] ...
+ *
+ *  [The Monad Tutorial](https://arrow-kt.io/docs/patterns/monads/)
+ */
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Monad typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.monad(): ListKMonad = monad_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadCombine/ListKMonadCombine.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadCombine/ListKMonadCombine.kt
new file mode 100644
index 000000000..a12d19507
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadCombine/ListKMonadCombine.kt
@@ -0,0 +1,54 @@
+package arrow.core.extensions.listk.monadCombine
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKMonadCombine
+import arrow.typeclasses.Bifoldable
+import arrow.typeclasses.Foldable
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monadCombine_singleton: ListKMonadCombine = object :
+    arrow.core.extensions.ListKMonadCombine {}
+
+@JvmName("unite")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Foldable typeclasses is deprecated. Use concrete methods on List")
+fun <G, A> Kind<ForListK, Kind<G, A>>.unite(arg1: Foldable<G>): ListK<A> =
+    arrow.core.ListK.monadCombine().run {
+  this@unite.unite<G, A>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("separate")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Foldable typeclasses is deprecated. Use concrete methods on List")
+fun <G, A, B> Kind<ForListK, Kind<Kind<G, A>, B>>.separate(arg1: Bifoldable<G>):
+    Tuple2<Kind<ForListK, A>, Kind<ForListK, B>> = arrow.core.ListK.monadCombine().run {
+  this@separate.separate<G, A, B>(arg1) as arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>,
+    arrow.Kind<arrow.core.ForListK, B>>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("MonadCombine typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.monadCombine(): ListKMonadCombine = monadCombine_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadFilter/ListKMonadFilter.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadFilter/ListKMonadFilter.kt
new file mode 100644
index 000000000..9f456c6ce
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadFilter/ListKMonadFilter.kt
@@ -0,0 +1,53 @@
+package arrow.core.extensions.listk.monadFilter
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Option
+import arrow.core.extensions.ListKMonadFilter
+import arrow.typeclasses.MonadFilterSyntax
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monadFilter_singleton: ListKMonadFilter = object :
+    arrow.core.extensions.ListKMonadFilter {}
+
+@JvmName("filterMap")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("mapNotNull { arg1(it).orNull() }"))
+fun <A, B> Kind<ForListK, A>.filterMap(arg1: Function1<A, Option<B>>): ListK<B> =
+    arrow.core.ListK.monadFilter().run {
+  this@filterMap.filterMap<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@JvmName("bindingFilter")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("Monad bindings are deprecated")
+fun <B> bindingFilter(arg0: suspend MonadFilterSyntax<ForListK>.() -> B): ListK<B> =
+    arrow.core.ListK
+   .monadFilter()
+   .bindingFilter<B>(arg0) as arrow.core.ListK<B>
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("MonadFilter typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.monadFilter(): ListKMonadFilter = monadFilter_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadLogic/ListKMonadLogic.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadLogic/ListKMonadLogic.kt
new file mode 100644
index 000000000..27859123a
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadLogic/ListKMonadLogic.kt
@@ -0,0 +1,105 @@
+package arrow.core.extensions.listk.monadLogic
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Option
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKMonadLogic
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monadLogic_singleton: ListKMonadLogic = object : arrow.core.extensions.ListKMonadLogic
+    {}
+
+@JvmName("splitM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("split()", "arrow.core.split()"))
+fun <A> Kind<ForListK, A>.splitM(): ListK<Option<Tuple2<Kind<ForListK, A>, A>>> =
+    arrow.core.ListK.monadLogic().run {
+  this@splitM.splitM<A>() as
+    arrow.core.ListK<arrow.core.Option<arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>, A>>>
+}
+
+@JvmName("interleave")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("interleave(arg1)", "arrow.core.interleave"))
+fun <A> Kind<ForListK, A>.interleave(arg1: Kind<ForListK, A>): ListK<A> =
+    arrow.core.ListK.monadLogic().run {
+  this@interleave.interleave<A>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("unweave")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("unweave(arg1)", "arrow.core.unweave"))
+fun <A, B> Kind<ForListK, A>.unweave(arg1: Function1<A, Kind<ForListK, B>>): ListK<B> =
+    arrow.core.ListK.monadLogic().run {
+  this@unweave.unweave<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@JvmName("ifThen")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("ifThen(arg1, arg2)", "arrow.core.ifThen"))
+fun <A, B> Kind<ForListK, A>.ifThen(arg1: Kind<ForListK, B>, arg2: Function1<A, Kind<ForListK, B>>):
+    ListK<B> = arrow.core.ListK.monadLogic().run {
+  this@ifThen.ifThen<A, B>(arg1, arg2) as arrow.core.ListK<B>
+}
+
+@JvmName("once")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listOfNotNull<A>(firstOrNull())"))
+fun <A> Kind<ForListK, A>.once(): ListK<A> = arrow.core.ListK.monadLogic().run {
+  this@once.once<A>() as arrow.core.ListK<A>
+}
+
+@JvmName("voidIfValue")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("firstOrNull()?.let { emptyList<Unit>() } ?: listOf(Unit)"))
+fun <A> Kind<ForListK, A>.voidIfValue(): ListK<Unit> = arrow.core.ListK.monadLogic().run {
+  this@voidIfValue.voidIfValue<A>() as arrow.core.ListK<kotlin.Unit>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("MonadLogic typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.monadLogic(): ListKMonadLogic = monadLogic_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadPlus/ListKMonadPlus.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadPlus/ListKMonadPlus.kt
new file mode 100644
index 000000000..c7129f6fe
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monadPlus/ListKMonadPlus.kt
@@ -0,0 +1,48 @@
+package arrow.core.extensions.listk.monadPlus
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKMonadPlus
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monadPlus_singleton: ListKMonadPlus = object : arrow.core.extensions.ListKMonadPlus {}
+
+@JvmName("zeroM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("emptyList()"))
+fun <A> zeroM(): ListK<A> = arrow.core.ListK
+   .monadPlus()
+   .zeroM<A>() as arrow.core.ListK<A>
+
+@JvmName("plusM")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("this + arg1"))
+fun <A> Kind<ForListK, A>.plusM(arg1: Kind<ForListK, A>): ListK<A> =
+    arrow.core.ListK.monadPlus().run {
+  this@plusM.plusM<A>(arg1) as arrow.core.ListK<A>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("MonadPlus typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.monadPlus(): ListKMonadPlus = monadPlus_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monoid/ListKMonoid.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monoid/ListKMonoid.kt
new file mode 100644
index 000000000..21546cc89
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monoid/ListKMonoid.kt
@@ -0,0 +1,49 @@
+package arrow.core.extensions.listk.monoid
+
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKMonoid
+import kotlin.Any
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.collections.Collection
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monoid_singleton: ListKMonoid<Any?> = object : ListKMonoid<Any?> {}
+
+@JvmName("combineAll")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.fold(emptyList()) { acc, l -> acc + l }"))
+fun <A> Collection<ListK<A>>.combineAll(): ListK<A> = arrow.core.ListK.monoid<A>().run {
+  this@combineAll.combineAll() as arrow.core.ListK<A>
+}
+
+@JvmName("combineAll")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.fold(emptyList()) { acc, l -> acc + l }"))
+fun <A> combineAll(arg0: List<ListK<A>>): ListK<A> = arrow.core.ListK
+   .monoid<A>()
+   .combineAll(arg0) as arrow.core.ListK<A>
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listMonoid<A>()", "arrow.core.listMonoid"))
+inline fun <A> Companion.monoid(): ListKMonoid<A> = monoid_singleton as
+    arrow.core.extensions.ListKMonoid<A>
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monoidK/ListKMonoidK.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monoidK/ListKMonoidK.kt
new file mode 100644
index 000000000..837da958a
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monoidK/ListKMonoidK.kt
@@ -0,0 +1,35 @@
+package arrow.core.extensions.listk.monoidK
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKMonoidK
+import arrow.typeclasses.Monoid
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monoidK_singleton: ListKMonoidK = object : arrow.core.extensions.ListKMonoidK {}
+
+@JvmName("algebra")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listMonoid<A>()", "arrow.core.listMonoid"))
+fun <A> algebra(): Monoid<Kind<ForListK, A>> = arrow.core.ListK
+   .monoidK()
+   .algebra<A>() as arrow.typeclasses.Monoid<arrow.Kind<arrow.core.ForListK, A>>
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+inline fun Companion.monoidK(): ListKMonoidK = monoidK_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monoidal/ListKMonoidal.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monoidal/ListKMonoidal.kt
new file mode 100644
index 000000000..0af7da54b
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/monoidal/ListKMonoidal.kt
@@ -0,0 +1,33 @@
+package arrow.core.extensions.listk.monoidal
+
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKMonoidal
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val monoidal_singleton: ListKMonoidal = object : arrow.core.extensions.ListKMonoidal {}
+
+@JvmName("identity")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("emptyList<A>()"))
+fun <A> identity(): ListK<A> = arrow.core.ListK
+   .monoidal()
+   .identity<A>() as arrow.core.ListK<A>
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Monoidal typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.monoidal(): ListKMonoidal = monoidal_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/order/ListKOrder.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/order/ListKOrder.kt
new file mode 100644
index 000000000..b9cd4b650
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/order/ListKOrder.kt
@@ -0,0 +1,153 @@
+package arrow.core.extensions.listk.order
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Ordering
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKOrder
+import arrow.typeclasses.Order
+import kotlin.Boolean
+import kotlin.Int
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+@JvmName("compare")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("compare(OA, arg1)", "arrow.core.compare"))
+fun <A> Kind<ForListK, A>.compare(OA: Order<A>, arg1: Kind<ForListK, A>): Ordering =
+    arrow.core.ListK.order<A>(OA).run {
+  this@compare.compare(arg1) as arrow.core.Ordering
+}
+
+@JvmName("compareTo")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("compareTo(OA, arg1)", "arrow.core.compareTo"))
+fun <A> Kind<ForListK, A>.compareTo(OA: Order<A>, arg1: Kind<ForListK, A>): Int =
+    arrow.core.ListK.order<A>(OA).run {
+  this@compareTo.compareTo(arg1) as kotlin.Int
+}
+
+@JvmName("eqv")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("eqv(OA, arg1)", "arrow.core.eqv"))
+fun <A> Kind<ForListK, A>.eqv(OA: Order<A>, arg1: Kind<ForListK, A>): Boolean =
+    arrow.core.ListK.order<A>(OA).run {
+  this@eqv.eqv(arg1) as kotlin.Boolean
+}
+
+@JvmName("lt")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("lt(OA, arg1)", "arrow.core.lt"))
+fun <A> Kind<ForListK, A>.lt(OA: Order<A>, arg1: Kind<ForListK, A>): Boolean =
+    arrow.core.ListK.order<A>(OA).run {
+  this@lt.lt(arg1) as kotlin.Boolean
+}
+
+@JvmName("lte")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("lte(OA, arg1)", "arrow.core.lte"))
+fun <A> Kind<ForListK, A>.lte(OA: Order<A>, arg1: Kind<ForListK, A>): Boolean =
+    arrow.core.ListK.order<A>(OA).run {
+  this@lte.lte(arg1) as kotlin.Boolean
+}
+
+@JvmName("gt")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("gt(OA, arg1)", "arrow.core.gt"))
+fun <A> Kind<ForListK, A>.gt(OA: Order<A>, arg1: Kind<ForListK, A>): Boolean =
+    arrow.core.ListK.order<A>(OA).run {
+  this@gt.gt(arg1) as kotlin.Boolean
+}
+
+@JvmName("gte")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("gte(OA, arg1)", "arrow.core.gte"))
+fun <A> Kind<ForListK, A>.gte(OA: Order<A>, arg1: Kind<ForListK, A>): Boolean =
+    arrow.core.ListK.order<A>(OA).run {
+  this@gte.gte(arg1) as kotlin.Boolean
+}
+
+@JvmName("max")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("max(OA, arg1)", "arrow.core.max"))
+fun <A> Kind<ForListK, A>.max(OA: Order<A>, arg1: Kind<ForListK, A>): ListK<A> =
+    arrow.core.ListK.order<A>(OA).run {
+  this@max.max(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("min")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("min(OA, arg1)", "arrow.core.min"))
+fun <A> Kind<ForListK, A>.min(OA: Order<A>, arg1: Kind<ForListK, A>): ListK<A> =
+    arrow.core.ListK.order<A>(OA).run {
+  this@min.min(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("sort")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("sort(OA, arg1)", "arrow.core.sort"))
+fun <A> Kind<ForListK, A>.sort(OA: Order<A>, arg1: Kind<ForListK, A>): Tuple2<Kind<ForListK, A>,
+    Kind<ForListK, A>> = arrow.core.ListK.order<A>(OA).run {
+  this@sort.sort(arg1) as arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>,
+    arrow.Kind<arrow.core.ForListK, A>>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listOrder(OA)", "arrow.core.listOrder"))
+inline fun <A> Companion.order(OA: Order<A>): ListKOrder<A> = object :
+    arrow.core.extensions.ListKOrder<A> { override fun OA(): arrow.typeclasses.Order<A> = OA }
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semialign/ListKSemialign.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semialign/ListKSemialign.kt
new file mode 100644
index 000000000..a9c323113
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semialign/ListKSemialign.kt
@@ -0,0 +1,101 @@
+package arrow.core.extensions.listk.semialign
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.Ior
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Option
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKSemialign
+import arrow.typeclasses.Semigroup
+import kotlin.Function1
+import kotlin.Function2
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val semialign_singleton: ListKSemialign = object : arrow.core.extensions.ListKSemialign {}
+
+@JvmName("align")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.align(arg1)", "arrow.core.align"))
+fun <A, B> align(arg0: Kind<ForListK, A>, arg1: Kind<ForListK, B>): ListK<Ior<A, B>> =
+  arrow.core.ListK
+    .semialign()
+    .align<A, B>(arg0, arg1) as arrow.core.ListK<arrow.core.Ior<A, B>>
+
+@JvmName("alignWith")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.alignWith(arg1, arg2)", "arrow.core.alignWith"))
+fun <A, B, C> alignWith(
+  arg0: Kind<ForListK, A>,
+  arg1: Kind<ForListK, B>,
+  arg2: Function1<Ior<A, B>, C>
+): ListK<C> = arrow.core.ListK
+  .semialign()
+  .alignWith<A, B, C>(arg0, arg1, arg2) as arrow.core.ListK<C>
+
+@JvmName("salign")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.salign(arg1, arg2)", "arrow.core.salign"))
+fun <A> Kind<ForListK, A>.salign(arg1: Semigroup<A>, arg2: Kind<ForListK, A>): ListK<A> =
+  arrow.core.ListK.semialign().run {
+    this@salign.salign<A>(arg1, arg2) as arrow.core.ListK<A>
+  }
+
+@JvmName("padZip")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.padZip(arg1)", "arrow.core.padZip"))
+fun <A, B> Kind<ForListK, A>.padZip(arg1: Kind<ForListK, B>): ListK<Tuple2<Option<A>, Option<B>>> =
+  arrow.core.ListK.semialign().run {
+    this@padZip.padZip<A, B>(arg1) as arrow.core.ListK<arrow.core.Tuple2<arrow.core.Option<A>,
+      arrow.core.Option<B>>>
+  }
+
+@JvmName("padZipWith")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.padZipWith(arg1, arg2)", "arrow.core.padZipWith"))
+fun <A, B, C> Kind<ForListK, A>.padZipWith(
+  arg1: Kind<ForListK, B>,
+  arg2: Function2<Option<A>,
+    Option<B>, C>
+): ListK<C> = arrow.core.ListK.semialign().run {
+  this@padZipWith.padZipWith<A, B, C>(arg1, arg2) as arrow.core.ListK<C>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Semialign typeclasses is deprecated. Use concrete methods on List")
+inline fun Companion.semialign(): ListKSemialign = semialign_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semigroup/ListKSemigroup.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semigroup/ListKSemigroup.kt
new file mode 100644
index 000000000..863c0a374
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semigroup/ListKSemigroup.kt
@@ -0,0 +1,47 @@
+package arrow.core.extensions.listk.semigroup
+
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKSemigroup
+import kotlin.Any
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val semigroup_singleton: ListKSemigroup<Any?> = object : ListKSemigroup<Any?> {}
+
+@JvmName("plus")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("this.plus(arg1)"))
+operator fun <A> ListK<A>.plus(arg1: ListK<A>): ListK<A> = arrow.core.ListK.semigroup<A>().run {
+  this@plus.plus(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("maybeCombine")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("(arg1?.plus(this) ?: emptyList<A>())"))
+fun <A> ListK<A>.maybeCombine(arg1: ListK<A>): ListK<A> = arrow.core.ListK.semigroup<A>().run {
+  this@maybeCombine.maybeCombine(arg1) as arrow.core.ListK<A>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listMonoid<A>()", "arrow.core.listMonoid"))
+inline fun <A> Companion.semigroup(): ListKSemigroup<A> = semigroup_singleton as
+    arrow.core.extensions.ListKSemigroup<A>
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semigroupK/ListKSemigroupK.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semigroupK/ListKSemigroupK.kt
new file mode 100644
index 000000000..fdeb2746f
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semigroupK/ListKSemigroupK.kt
@@ -0,0 +1,50 @@
+package arrow.core.extensions.listk.semigroupK
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKSemigroupK
+import arrow.typeclasses.Semigroup
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val semigroupK_singleton: ListKSemigroupK = object : arrow.core.extensions.ListKSemigroupK
+    {}
+
+@JvmName("combineK")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A> Kind<ForListK, A>.combineK(arg1: Kind<ForListK, A>): ListK<A> =
+    arrow.core.ListK.semigroupK().run {
+  this@combineK.combineK<A>(arg1) as arrow.core.ListK<A>
+}
+
+@JvmName("algebra")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listMonoid<A>()", "arrow.core.listMonoid"))
+fun <A> algebra(): Semigroup<Kind<ForListK, A>> = arrow.core.ListK
+   .semigroupK()
+   .algebra<A>() as arrow.typeclasses.Semigroup<arrow.Kind<arrow.core.ForListK, A>>
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+inline fun Companion.semigroupK(): ListKSemigroupK = semigroupK_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semigroupal/ListKSemigroupal.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semigroupal/ListKSemigroupal.kt
new file mode 100644
index 000000000..ddce37ad2
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/semigroupal/ListKSemigroupal.kt
@@ -0,0 +1,148 @@
+package arrow.core.extensions.listk.semigroupal
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKSemigroupal
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val semigroupal_singleton: ListKSemigroupal = object :
+    arrow.core.extensions.ListKSemigroupal {}
+
+/**
+ *  Multiplicatively combine F<A> and F<B> into F<Tuple2<A, B>>
+ */
+@JvmName("product")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+fun <A, B> Kind<ForListK, A>.product(arg1: Kind<ForListK, B>): ListK<Tuple2<A, B>> =
+    arrow.core.ListK.semigroupal().run {
+  this@product.product<A, B>(arg1) as arrow.core.ListK<arrow.core.Tuple2<A, B>>
+}
+
+/**
+ * syntax
+ */
+@JvmName("times")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("product(arg1)", "arrow.core.product"))
+operator fun <A, B> Kind<ForListK, A>.times(arg1: Kind<ForListK, B>): ListK<Tuple2<A, B>> =
+    arrow.core.ListK.semigroupal().run {
+  this@times.times<A, B>(arg1) as arrow.core.ListK<arrow.core.Tuple2<A, B>>
+}
+
+/**
+ *  ank_macro_hierarchy(arrow.typeclasses.Semigroupal)
+ *
+ *  The [Semigroupal] type class for a given type `F` can be seen as an abstraction over the [cartesian product](https://en.wikipedia.org/wiki/Cartesian_product).
+ *  It defines the function [product].
+ *
+ *  The [product] function for a given type `F`, `A` and `B` combines a `Kind<F, A>` and a `Kind<F, B>` into a `Kind<F, Tuple2<A, B>>`.
+ *  This function guarantees compliance with the following laws:
+ *
+ *  [Semigroupal]s are associative under the bijection `f = (a,(b,c)) -> ((a,b),c)` or `f = ((a,b),c) -> (a,(b,c))`.
+ *  Therefore, the following laws also apply:
+ *
+ *  ```kotlin
+ *  f((a.product(b)).product(c)) == a.product(b.product(c))
+ *  ```
+ *
+ *  ```kotlin
+ *  f(a.product(b.product(c))) == (a.product(b)).product(c)
+ *  ```
+ *
+ *  Currently, [Semigroupal] instances are defined for [Option], [ListK], [SequenceK] and [SetK].
+ *
+ *  ```kotlin:ank:playground
+ *  import arrow.core.*
+ * import arrow.core.extensions.listk.semigroupal.*
+ * import arrow.core.*
+ *
+ *
+ *
+ *  fun main(args: Array<String>) {
+ *   val result =
+ *   //sampleStart
+ *   ListK.semigroupal()
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ *
+ *  ### Examples
+ *
+ *  Here a some examples:
+ *
+ *  ```kotlin:ank:playground
+ *  import arrow.core.Option
+ *  import arrow.core.extensions.option.semigroupal.semigroupal
+ *
+ *  fun main(args: Array<String>) {
+ *   val result =
+ *   //sampleStart
+ *   Option.semigroupal().run {
+ *       Option.just(1).product(Option.just(1))
+ *   }
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ *
+ *  [Semigroupal] also has support of the `*` syntax:
+ *
+ *  ```kotlin:ank:playground
+ *  import arrow.core.Option
+ *  import arrow.core.extensions.option.semigroupal.semigroupal
+ *
+ *  fun main(args: Array<String>) {
+ *   val result =
+ *   //sampleStart
+ *   Option.semigroupal().run {
+ * Option.just(2)
+ *   }
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ *  The same applies to [ListK], [SequenceK] and [SetK] instances:
+ *
+ *  ```kotlin:ank:playground
+ *  import arrow.core.ListK
+ *  import arrow.core.extensions.listk.semigroupal.semigroupal
+ *  import arrow.core.k
+ *
+ *  fun main(args: Array<String>) {
+ *   val result =
+ *   //sampleStart
+ *   ListK.semigroupal().run {
+ * listOf('a','b','c').k()
+ *   }
+ *   //sampleEnd
+ *   println(result)
+ *  }
+ *  ```
+ */
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Kind/type constructors will be deprecated, so this typeclass will no longer be available from 0.13.0")
+inline fun Companion.semigroupal(): ListKSemigroupal = semigroupal_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/show/ListKShow.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/show/ListKShow.kt
new file mode 100644
index 000000000..31915eb27
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/show/ListKShow.kt
@@ -0,0 +1,30 @@
+package arrow.core.extensions.listk.show
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKShow
+import arrow.typeclasses.Show
+import kotlin.String
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+@JvmName("show")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("show(arg1)", "arrow.core.show"))
+fun <A> Kind<ForListK, A>.show(SA: Show<A>): String = arrow.core.ListK.show<A>(SA).run {
+  this@show.show() as kotlin.String
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("listShow(arg1)", "arrow.core.listShow"))
+inline fun <A> Companion.show(SA: Show<A>): ListKShow<A> = object :
+    arrow.core.extensions.ListKShow<A> { override fun SA(): arrow.typeclasses.Show<A> = SA }
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/traverse/ListKTraverse.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/traverse/ListKTraverse.kt
new file mode 100644
index 000000000..3896a61df
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/traverse/ListKTraverse.kt
@@ -0,0 +1,82 @@
+package arrow.core.extensions.listk.traverse
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.extensions.ListKTraverse
+import arrow.typeclasses.Applicative
+import arrow.typeclasses.Monad
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val traverse_singleton: ListKTraverse = object : arrow.core.extensions.ListKTraverse {}
+
+@JvmName("traverse")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with traverseEither or traverseValidated from arrow.core.*")
+fun <G, A, B> Kind<ForListK, A>.traverse(arg1: Applicative<G>, arg2: Function1<A, Kind<G, B>>):
+    Kind<G, Kind<ForListK, B>> = arrow.core.ListK.traverse().run {
+  this@traverse.traverse<G, A, B>(arg1, arg2) as arrow.Kind<G, arrow.Kind<arrow.core.ForListK, B>>
+}
+
+@JvmName("sequence")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with sequenceEither or sequenceValidated from arrow.core.*")
+fun <G, A> Kind<ForListK, Kind<G, A>>.sequence(arg1: Applicative<G>): Kind<G, Kind<ForListK, A>> =
+    arrow.core.ListK.traverse().run {
+  this@sequence.sequence<G, A>(arg1) as arrow.Kind<G, arrow.Kind<arrow.core.ForListK, A>>
+}
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated", ReplaceWith("map(arg1)"))
+fun <A, B> Kind<ForListK, A>.map(arg1: Function1<A, B>): ListK<B> =
+    arrow.core.ListK.traverse().run {
+  this@map.map<A, B>(arg1) as arrow.core.ListK<B>
+}
+
+@JvmName("flatTraverse")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension kinded projected functions are deprecated. Replace with flatTraverseEither or flatTraverseValidated from arrow.core.*")
+fun <G, A, B> Kind<ForListK, A>.flatTraverse(
+  arg1: Monad<ForListK>,
+  arg2: Applicative<G>,
+  arg3: Function1<A, Kind<G, Kind<ForListK, B>>>
+): Kind<G, Kind<ForListK, B>> = arrow.core.ListK.traverse().run {
+  this@flatTraverse.flatTraverse<G, A, B>(arg1, arg2, arg3) as arrow.Kind<G,
+    arrow.Kind<arrow.core.ForListK, B>>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Traverse typeclasses is deprecated. Use concrete methods on Iterable")
+inline fun Companion.traverse(): ListKTraverse = traverse_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/unalign/ListKUnalign.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/unalign/ListKUnalign.kt
new file mode 100644
index 000000000..4a8e62b41
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/unalign/ListKUnalign.kt
@@ -0,0 +1,53 @@
+package arrow.core.extensions.listk.unalign
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.Ior
+import arrow.core.ListK.Companion
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKUnalign
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val unalign_singleton: ListKUnalign = object : arrow.core.extensions.ListKUnalign {}
+
+@JvmName("unalign")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.unalign()", "arrow.core.unalign"))
+fun <A, B> unalign(arg0: Kind<ForListK, Ior<A, B>>): Tuple2<Kind<ForListK, A>, Kind<ForListK, B>> =
+    arrow.core.ListK
+   .unalign()
+   .unalign<A, B>(arg0) as arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>,
+    arrow.Kind<arrow.core.ForListK, B>>
+
+@JvmName("unalignWith")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("arg0.unalignWith(arg1)", "arrow.core.unalignWith"))
+fun <A, B, C> unalignWith(arg0: Kind<ForListK, C>, arg1: Function1<C, Ior<A, B>>):
+    Tuple2<Kind<ForListK, A>, Kind<ForListK, B>> = arrow.core.ListK
+   .unalign()
+   .unalignWith<A, B, C>(arg0, arg1) as arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>,
+    arrow.Kind<arrow.core.ForListK, B>>
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Unalign typeclasses is deprecated. Use concrete methods on Iterable")
+inline fun Companion.unalign(): ListKUnalign = unalign_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/unzip/ListKUnzip.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/unzip/ListKUnzip.kt
new file mode 100644
index 000000000..c37632638
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/unzip/ListKUnzip.kt
@@ -0,0 +1,52 @@
+package arrow.core.extensions.listk.unzip
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK.Companion
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKUnzip
+import kotlin.Function1
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val unzip_singleton: ListKUnzip = object : arrow.core.extensions.ListKUnzip {}
+
+@JvmName("unzip")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("unzip()", "arrow.core.unzip"))
+fun <A, B> Kind<ForListK, Tuple2<A, B>>.unzip(): Tuple2<Kind<ForListK, A>, Kind<ForListK, B>> =
+    arrow.core.ListK.unzip().run {
+  this@unzip.unzip<A, B>() as arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>,
+    arrow.Kind<arrow.core.ForListK, B>>
+}
+
+@JvmName("unzipWith")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("unzipWith(arg1)", "arrow.core.unzipWith"))
+fun <A, B, C> Kind<ForListK, C>.unzipWith(arg1: Function1<C, Tuple2<A, B>>): Tuple2<Kind<ForListK,
+    A>, Kind<ForListK, B>> = arrow.core.ListK.unzip().run {
+  this@unzipWith.unzipWith<A, B, C>(arg1) as arrow.core.Tuple2<arrow.Kind<arrow.core.ForListK, A>,
+    arrow.Kind<arrow.core.ForListK, B>>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Unzip typeclasses is deprecated. Use concrete methods on Iterable")
+inline fun Companion.unzip(): ListKUnzip = unzip_singleton
diff --git a/arrow-core/src/main/kotlin/arrow/core/extensions/listk/zip/ListKZip.kt b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/zip/ListKZip.kt
new file mode 100644
index 000000000..e3e6123d7
--- /dev/null
+++ b/arrow-core/src/main/kotlin/arrow/core/extensions/listk/zip/ListKZip.kt
@@ -0,0 +1,51 @@
+package arrow.core.extensions.listk.zip
+
+import arrow.Kind
+import arrow.core.ForListK
+import arrow.core.ListK
+import arrow.core.ListK.Companion
+import arrow.core.Tuple2
+import arrow.core.extensions.ListKZip
+import kotlin.Function2
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val zip_singleton: ListKZip = object : arrow.core.extensions.ListKZip {}
+
+@JvmName("zip")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("zip(arg1).map { it.toTuple2() }", "arrow.core.toTuple2"))
+fun <A, B> Kind<ForListK, A>.zip(arg1: Kind<ForListK, B>): ListK<Tuple2<A, B>> =
+    arrow.core.ListK.zip().run {
+  this@zip.zip<A, B>(arg1) as arrow.core.ListK<arrow.core.Tuple2<A, B>>
+}
+
+@JvmName("zipWith")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated("@extension projected functions are deprecated", ReplaceWith("zip(arg1, arg2)"))
+fun <A, B, C> Kind<ForListK, A>.zipWith(arg1: Kind<ForListK, B>, arg2: Function2<A, B, C>): ListK<C> =
+    arrow.core.ListK.zip().run {
+  this@zipWith.zipWith<A, B, C>(arg1, arg2) as arrow.core.ListK<C>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated("Zip typeclasses is deprecated. Use concrete methods on Iterable")
+inline fun Companion.zip(): ListKZip = zip_singleton