diff --git a/modules/core/arrow-annotations-processor/src/main/java/arrow/higherkinds/HigherKindsFileGenerator.kt b/modules/core/arrow-annotations-processor/src/main/java/arrow/higherkinds/HigherKindsFileGenerator.kt
index 6f64a0eb7b3..2409179e4c6 100644
--- a/modules/core/arrow-annotations-processor/src/main/java/arrow/higherkinds/HigherKindsFileGenerator.kt
+++ b/modules/core/arrow-annotations-processor/src/main/java/arrow/higherkinds/HigherKindsFileGenerator.kt
@@ -61,7 +61,7 @@ class HigherKindsFileGenerator(
     val appliedTypeArgs = hk.typeArgs.dropLast(1)
     val expandedAppliedTypeArgs = appliedTypeArgs.joinToString(", ")
     val hkimpl = if (appliedTypeArgs.size == 1) "arrow.Kind" else "arrow.Kind${appliedTypeArgs.size}"
-    return "typealias ${hk.name.replace("Of$".toRegex(), { "PartialOf" })}<$expandedAppliedTypeArgs> = $hkimpl<${hk.markerName}, $expandedAppliedTypeArgs>"
+    return "typealias ${hk.name.replace("Of$".toRegex()) { "PartialOf" }}<$expandedAppliedTypeArgs> = $hkimpl<${hk.markerName}, $expandedAppliedTypeArgs>"
   }
 
   private fun genKindedJTypeAliases(hk: HigherKind): String =
diff --git a/modules/core/arrow-core/src/main/kotlin/arrow/core/PartialFunction.kt b/modules/core/arrow-core/src/main/kotlin/arrow/core/PartialFunction.kt
index e0ee204e1df..f20838dabc1 100644
--- a/modules/core/arrow-core/src/main/kotlin/arrow/core/PartialFunction.kt
+++ b/modules/core/arrow-core/src/main/kotlin/arrow/core/PartialFunction.kt
@@ -56,7 +56,7 @@ fun <A, B, C> PartialFunction<A, B>.andThen(f: (B) -> C): PartialFunction<A, C>
   }
 
 private class Lifted<A, B>(val pf: PartialFunction<A, B>) : (A) -> Option<B> {
-  override fun invoke(x: A): Option<B> = pf.andThen { Some(it) }.invokeOrElse(x, { None })
+  override fun invoke(x: A): Option<B> = pf.andThen { Some(it) }.invokeOrElse(x) { None }
 }
 
 fun <A, B> ((A) -> B).toPartialFunction(definedAt: (A) -> Boolean): PartialFunction<A, B> = PartialFunction(definedAt, this)
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/Cokleisli.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/Cokleisli.kt
index 7fbfa1455c1..847510f197a 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/Cokleisli.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/Cokleisli.kt
@@ -11,28 +11,28 @@ typealias CoreaderT<F, A, B> = Cokleisli<F, A, B>
 @higherkind
 data class Cokleisli<F, A, B>(val MM: Comonad<F>, val run: CokleisliFun<F, A, B>) : CokleisliOf<F, A, B>, CokleisliKindedJ<F, A, B>, Comonad<F> by MM {
 
-  inline fun <C, D> bimap(noinline g: (D) -> A, crossinline f: (B) -> C): Cokleisli<F, D, C> = Cokleisli(MM, { f(run(it.map(g))) })
+  inline fun <C, D> bimap(noinline g: (D) -> A, crossinline f: (B) -> C): Cokleisli<F, D, C> = Cokleisli(MM) { f(run(it.map(g))) }
 
-  fun <D> lmap(g: (D) -> A): Cokleisli<F, D, B> = Cokleisli(MM, { run(it.map(g)) })
+  fun <D> lmap(g: (D) -> A): Cokleisli<F, D, B> = Cokleisli(MM) { run(it.map(g)) }
 
-  inline fun <C> map(crossinline f: (B) -> C): Cokleisli<F, A, C> = Cokleisli(MM, { f(run(it)) })
+  inline fun <C> map(crossinline f: (B) -> C): Cokleisli<F, A, C> = Cokleisli(MM) { f(run(it)) }
 
-  inline fun <C> contramapValue(crossinline f: (Kind<F, C>) -> Kind<F, A>): Cokleisli<F, C, B> = Cokleisli(MM, { run(f(it)) })
+  inline fun <C> contramapValue(crossinline f: (Kind<F, C>) -> Kind<F, A>): Cokleisli<F, C, B> = Cokleisli(MM) { run(f(it)) }
 
-  fun <D> compose(a: Cokleisli<F, D, A>): Cokleisli<F, D, B> = Cokleisli(MM, { run(it.coflatMap(a.run)) })
+  fun <D> compose(a: Cokleisli<F, D, A>): Cokleisli<F, D, B> = Cokleisli(MM) { run(it.coflatMap(a.run)) }
 
   @JvmName("andThenK")
-  fun <C> andThen(a: Kind<F, C>): Cokleisli<F, A, C> = Cokleisli(MM, { run { a.extract() } })
+  fun <C> andThen(a: Kind<F, C>): Cokleisli<F, A, C> = Cokleisli(MM) { run { a.extract() } }
 
   fun <C> andThen(a: Cokleisli<F, B, C>): Cokleisli<F, A, C> = a.compose(this)
 
-  inline fun <C> flatMap(crossinline f: (B) -> Cokleisli<F, A, C>): Cokleisli<F, A, C> = Cokleisli(MM, { f(run(it)).run(it) })
+  inline fun <C> flatMap(crossinline f: (B) -> Cokleisli<F, A, C>): Cokleisli<F, A, C> = Cokleisli(MM) { f(run(it)).run(it) }
 
   companion object {
     inline operator fun <F, A, B> invoke(MF: Comonad<F>, noinline run: (Kind<F, A>) -> B): Cokleisli<F, A, B> = Cokleisli(MF, run)
 
-    inline fun <F, A, B> just(MF: Comonad<F>, b: B): Cokleisli<F, A, B> = Cokleisli(MF, { b })
+    inline fun <F, A, B> just(MF: Comonad<F>, b: B): Cokleisli<F, A, B> = Cokleisli(MF) { b }
 
-    inline fun <F, B> ask(MF: Comonad<F>): Cokleisli<F, B, B> = Cokleisli(MF, { MF.run { it.extract() } })
+    inline fun <F, B> ask(MF: Comonad<F>): Cokleisli<F, B, B> = Cokleisli(MF) { MF.run { it.extract() } }
   }
 }
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/Coproduct.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/Coproduct.kt
index 4d7d8115dd0..9217da13116 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/Coproduct.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/Coproduct.kt
@@ -13,8 +13,8 @@ data class Coproduct<F, G, A>(val run: Either<Kind<F, A>, Kind<G, A>>) : Coprodu
 
   fun <B> coflatMap(CF: Comonad<F>, CG: Comonad<G>, f: (Coproduct<F, G, A>) -> B): Coproduct<F, G, B> =
     Coproduct(run.bimap(
-      { CF.run { it.coflatMap({ f(Coproduct(Left(it))) }) } },
-      { CG.run { it.coflatMap({ f(Coproduct(Right(it))) }) } }
+      { CF.run { it.coflatMap { f(Coproduct(Left(it))) } } },
+      { CG.run { it.coflatMap { f(Coproduct(Right(it))) } } }
     ))
 
   fun extract(CF: Comonad<F>, CG: Comonad<G>): A =
@@ -31,9 +31,9 @@ data class Coproduct<F, G, A>(val run: Either<Kind<F, A>, Kind<G, A>>) : Coprodu
 
   fun <H, B> traverse(GA: Applicative<H>, FT: Traverse<F>, GT: Traverse<G>, f: (A) -> Kind<H, B>): Kind<H, Coproduct<F, G, B>> = GA.run {
     run.fold({
-      FT.run { it.traverse(GA, f) }.map({ Coproduct<F, G, B>(Left(it)) })
+      FT.run { it.traverse(GA, f) }.map { Coproduct<F, G, B>(Left(it)) }
     }, {
-      GT.run { it.traverse(GA, f) }.map({ Coproduct<F, G, B>(Right(it)) })
+      GT.run { it.traverse(GA, f) }.map { Coproduct<F, G, B>(Right(it)) }
     })
   }
 
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/EitherT.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/EitherT.kt
index cba340dec20..ce2c6588792 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/EitherT.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/EitherT.kt
@@ -55,44 +55,44 @@ data class EitherT<F, A, B>(val value: Kind<F, Either<A, B>>) : EitherTOf<F, A,
   }
 
   inline fun <C> fold(FF: Functor<F>, crossinline l: (A) -> C, crossinline r: (B) -> C): Kind<F, C> = FF.run {
-    value.map({ either -> either.fold(l, r) })
+    value.map { either -> either.fold(l, r) }
   }
 
   fun <C> flatMap(MF: Monad<F>, f: (B) -> EitherT<F, A, C>): EitherT<F, A, C> =
-    flatMapF(MF, { it -> f(it).value })
+    flatMapF(MF) { it -> f(it).value }
 
   fun <C> flatMapF(MF: Monad<F>, f: (B) -> Kind<F, Either<A, C>>): EitherT<F, A, C> = MF.run {
-    EitherT(value.flatMap({ either -> either.fold({ MF.just(Left(it)) }, { f(it) }) }))
+    EitherT(value.flatMap { either -> either.fold({ MF.just(Left(it)) }, { f(it) }) })
   }
 
   fun <C> cata(FF: Functor<F>, l: (A) -> C, r: (B) -> C): Kind<F, C> = fold(FF, l, r)
 
   fun <C> liftF(FF: Functor<F>, fa: Kind<F, C>): EitherT<F, A, C> = FF.run {
-    EitherT(fa.map({ Right(it) }))
+    EitherT(fa.map { Right(it) })
   }
 
-  fun <C> semiflatMap(MF: Monad<F>, f: (B) -> Kind<F, C>): EitherT<F, A, C> = flatMap(MF, { liftF(MF, f(it)) })
+  fun <C> semiflatMap(MF: Monad<F>, f: (B) -> Kind<F, C>): EitherT<F, A, C> = flatMap(MF) { liftF(MF, f(it)) }
 
   fun <C> map(FF: Functor<F>, f: (B) -> C): EitherT<F, A, C> = FF.run {
-    EitherT(value.map({ it.map(f) }))
+    EitherT(value.map { it.map(f) })
   }
 
   fun <C> mapLeft(FF: Functor<F>, f: (A) -> C): EitherT<F, C, B> = FF.run {
-    EitherT(value.map({ it.mapLeft(f) }))
+    EitherT(value.map { it.mapLeft(f) })
   }
 
   fun exists(FF: Functor<F>, p: (B) -> Boolean): Kind<F, Boolean> = FF.run {
-    value.map({ it.exists(p) })
+    value.map { it.exists(p) }
   }
 
   fun <C, D> transform(FF: Functor<F>, f: (Either<A, B>) -> Either<C, D>): EitherT<F, C, D> = FF.run {
-    EitherT(value.map({ f(it) }))
+    EitherT(value.map { f(it) })
   }
 
-  fun <C> subflatMap(FF: Functor<F>, f: (B) -> Either<A, C>): EitherT<F, A, C> = transform(FF, { it.flatMap(f = f) })
+  fun <C> subflatMap(FF: Functor<F>, f: (B) -> Either<A, C>): EitherT<F, A, C> = transform(FF) { it.flatMap(f = f) }
 
   fun toOptionT(FF: Functor<F>): OptionT<F, B> = FF.run {
-    OptionT(value.map({ it.toOption() }))
+    OptionT(value.map { it.toOption() })
   }
 
   fun combineK(MF: Monad<F>, y: EitherTOf<F, A, B>): EitherT<F, A, B> = MF.run {
@@ -104,5 +104,5 @@ data class EitherT<F, A, B>(val value: Kind<F, Either<A, B>>) : EitherTOf<F, A,
     })
   }
 
-  fun <C> ap(MF: Monad<F>, ff: EitherTOf<F, A, (B) -> C>): EitherT<F, A, C> = ff.fix().flatMap(MF, { f -> map(MF, f) })
+  fun <C> ap(MF: Monad<F>, ff: EitherTOf<F, A, (B) -> C>): EitherT<F, A, C> = ff.fix().flatMap(MF) { f -> map(MF, f) }
 }
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/Ior.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/Ior.kt
index e9d7c654fa0..0ef313d7511 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/Ior.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/Ior.kt
@@ -145,7 +145,7 @@ sealed class Ior<out A, out B> : IorOf<A, B> {
     fold({ lc }, { f(it, lc) }, { _, b -> f(b, lc) })
 
   fun <G, C> traverse(GA: Applicative<G>, f: (B) -> Kind<G, C>): Kind<G, Ior<A, C>> = GA.run {
-    fold({ just(Left(it)) }, { f(it).map({ Right<A, C>(it) }) }, { _, b -> f(b).map({ Right<A, C>(it) }) })
+    fold({ just(Left(it)) }, { f(it).map { Right<A, C>(it) } }, { _, b -> f(b).map { Right<A, C>(it) } })
   }
 
   /**
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/Kleisli.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/Kleisli.kt
index fa6de79c86a..d1ec1d22f29 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/Kleisli.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/Kleisli.kt
@@ -64,9 +64,9 @@ class Kleisli<F, D, A>(val run: KleisliFun<F, D, A>) : KleisliOf<F, D, A>, Kleis
    * @param MF [Monad] for the context [F].
    */
   fun <B> zip(MF: Monad<F>, o: Kleisli<F, D, B>): Kleisli<F, D, Tuple2<A, B>> =
-    flatMap(MF, { a ->
-      o.map(MF, { b -> Tuple2(a, b) })
-    })
+    flatMap(MF) { a ->
+      o.map(MF) { b -> Tuple2(a, b) }
+    }
 
   /**
    * Compose this arrow with another function to transform the input of the arrow.
@@ -99,7 +99,7 @@ class Kleisli<F, D, A>(val run: KleisliFun<F, D, A>) : KleisliOf<F, D, A>, Kleis
    * @param fb the new end of the arrow.
    * @param MF [Monad] for the context [F].
    */
-  fun <B> andThen(MF: Monad<F>, fb: Kind<F, B>): Kleisli<F, D, B> = andThen(MF, { fb })
+  fun <B> andThen(MF: Monad<F>, fb: Kind<F, B>): Kleisli<F, D, B> = andThen(MF) { fb }
 
   /**
    * Handle error within context of [F] given a [MonadError] is defined for [F].
@@ -108,7 +108,7 @@ class Kleisli<F, D, A>(val run: KleisliFun<F, D, A>) : KleisliOf<F, D, A>, Kleis
    * @param ME [MonadError] for the context [F].
    */
   fun <E> handleErrorWith(ME: MonadError<F, E>, f: (E) -> KleisliOf<F, D, A>): Kleisli<F, D, A> = Kleisli {
-    ME.run { run(it).handleErrorWith({ e: E -> f(e).fix().run(it) }) }
+    ME.run { run(it).handleErrorWith { e: E -> f(e).fix().run(it) } }
   }
 
   companion object {
@@ -128,7 +128,7 @@ class Kleisli<F, D, A>(val run: KleisliFun<F, D, A>) : KleisliOf<F, D, A>, Kleis
      * @param MF [Monad] for the context [F].
      */
     fun <F, D, A, B> tailRecM(MF: Monad<F>, a: A, f: (A) -> KleisliOf<F, D, Either<A, B>>): Kleisli<F, D, B> =
-      Kleisli { b -> MF.tailRecM(a, { f(it).fix().run(b) }) }
+      Kleisli { b -> MF.tailRecM(a) { f(it).fix().run(b) } }
 
     /**
      * Create an arrow for a value of [A].
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/ListK.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/ListK.kt
index 3a28ae15fb9..3db9383c188 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/ListK.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/ListK.kt
@@ -37,7 +37,7 @@ data class ListK<out A>(val list: List<A>) : ListKOf<A>, List<A> by list {
     }.fix()
 
   fun <B> mapFilter(f: (A) -> Option<B>): ListK<B> =
-    flatMap({ a -> f(a).fold({ empty<B>() }, { just(it) }) })
+    flatMap { a -> f(a).fold({ empty<B>() }, { just(it) }) }
 
   companion object {
 
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/MapK.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/MapK.kt
index 1c31a8ea6d8..eb9aed963e8 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/MapK.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/MapK.kt
@@ -43,9 +43,9 @@ data class MapK<K, out A>(val map: Map<K, A>) : MapKOf<K, A>, Map<K, A> by map {
     this.map.foldLeft(b) { m, (k, v) -> f(m.k(), Tuple2(k, v)) }.k()
 
   fun <G, B> traverse(GA: Applicative<G>, f: (A) -> Kind<G, B>): Kind<G, MapK<K, B>> = GA.run {
-    (Foldable.iterateRight(map.iterator(), Eval.always { just(emptyMap<K, B>().k()) }))({ kv, lbuf ->
+    (Foldable.iterateRight(map.iterator(), Eval.always { just(emptyMap<K, B>().k()) })) { kv, lbuf ->
       f(kv.value).map2Eval(lbuf) { (mapOf(kv.key to it.a).k() + it.b).k() }
-    }).value()
+    }.value()
   }
 
   companion object
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/NonEmptyList.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/NonEmptyList.kt
index fb3b788c691..f116e5964ba 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/NonEmptyList.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/NonEmptyList.kt
@@ -47,9 +47,9 @@ class NonEmptyList<out A> private constructor(
   fun <G, B> traverse(AG: Applicative<G>, f: (A) -> Kind<G, B>): Kind<G, NonEmptyList<B>> = with(AG) {
     f(fix().head).map2Eval(Eval.always {
       tail.k().traverse(AG, f)
-    }, {
+    }) {
       NonEmptyList(it.a, it.b.fix().list)
-    }).value()
+    }.value()
   }
 
   fun <B> coflatMap(f: (NonEmptyListOf<A>) -> B): NonEmptyList<B> {
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/OptionT.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/OptionT.kt
index 1ae88e86908..95ba91bf6a5 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/OptionT.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/OptionT.kt
@@ -44,52 +44,52 @@ data class OptionT<F, A>(val value: Kind<F, Option<A>>) : OptionTOf<F, A>, Optio
   }
 
   inline fun <B> fold(FF: Functor<F>, crossinline default: () -> B, crossinline f: (A) -> B): Kind<F, B> = FF.run {
-    value.map({ option -> option.fold(default, f) })
+    value.map { option -> option.fold(default, f) }
   }
 
   fun <B> cata(FF: Functor<F>, default: () -> B, f: (A) -> B): Kind<F, B> = fold(FF, default, f)
 
-  fun <B> ap(MF: Monad<F>, ff: OptionTOf<F, (A) -> B>): OptionT<F, B> = ff.fix().flatMap(MF, { f -> map(MF, f) })
+  fun <B> ap(MF: Monad<F>, ff: OptionTOf<F, (A) -> B>): OptionT<F, B> = ff.fix().flatMap(MF) { f -> map(MF, f) }
 
-  fun <B> flatMap(MF: Monad<F>, f: (A) -> OptionT<F, B>): OptionT<F, B> = flatMapF(MF, { it -> f(it).value })
+  fun <B> flatMap(MF: Monad<F>, f: (A) -> OptionT<F, B>): OptionT<F, B> = flatMapF(MF) { it -> f(it).value }
 
   fun <B> flatMapF(MF: Monad<F>, f: (A) -> Kind<F, Option<B>>): OptionT<F, B> = MF.run {
-    OptionT(value.flatMap({ option -> option.fold({ just(None) }, f) }))
+    OptionT(value.flatMap { option -> option.fold({ just(None) }, f) })
   }
 
   fun <B> liftF(FF: Functor<F>, fa: Kind<F, B>): OptionT<F, B> = FF.run {
-    OptionT(fa.map({ Some(it) }))
+    OptionT(fa.map { Some(it) })
   }
 
-  fun <B> semiflatMap(MF: Monad<F>, f: (A) -> Kind<F, B>): OptionT<F, B> = flatMap(MF, { option -> liftF(MF, f(option)) })
+  fun <B> semiflatMap(MF: Monad<F>, f: (A) -> Kind<F, B>): OptionT<F, B> = flatMap(MF) { option -> liftF(MF, f(option)) }
 
   fun <B> map(FF: Functor<F>, f: (A) -> B): OptionT<F, B> = FF.run {
-    OptionT(value.map({ it.map(f) }))
+    OptionT(value.map { it.map(f) })
   }
 
-  fun getOrElse(FF: Functor<F>, default: () -> A): Kind<F, A> = FF.run { value.map({ it.getOrElse(default) }) }
+  fun getOrElse(FF: Functor<F>, default: () -> A): Kind<F, A> = FF.run { value.map { it.getOrElse(default) } }
 
   fun getOrElseF(MF: Monad<F>, default: () -> Kind<F, A>): Kind<F, A> = MF.run {
-    value.flatMap({ it.fold(default, { just(it) }) })
+    value.flatMap { it.fold(default) { just(it) } }
   }
 
   fun filter(FF: Functor<F>, p: (A) -> Boolean): OptionT<F, A> = FF.run {
-    OptionT(value.map({ it.filter(p) }))
+    OptionT(value.map { it.filter(p) })
   }
 
   fun forall(FF: Functor<F>, p: (A) -> Boolean): Kind<F, Boolean> = FF.run {
-    value.map({ it.forall(p) })
+    value.map { it.forall(p) }
   }
 
   fun isDefined(FF: Functor<F>): Kind<F, Boolean> = FF.run {
-    value.map({ it.isDefined() })
+    value.map { it.isDefined() }
   }
 
   fun isEmpty(FF: Functor<F>): Kind<F, Boolean> = FF.run {
-    value.map({ it.isEmpty() })
+    value.map { it.isEmpty() }
   }
 
-  fun orElse(MF: Monad<F>, default: () -> OptionT<F, A>): OptionT<F, A> = orElseF(MF, { default().value })
+  fun orElse(MF: Monad<F>, default: () -> OptionT<F, A>): OptionT<F, A> = orElseF(MF) { default().value }
 
   fun orElseF(MF: Monad<F>, default: () -> Kind<F, Option<A>>): OptionT<F, A> = MF.run {
     OptionT(value.flatMap {
@@ -101,10 +101,10 @@ data class OptionT<F, A>(val value: Kind<F, Option<A>>) : OptionTOf<F, A>, Optio
   }
 
   fun <B> transform(FF: Functor<F>, f: (Option<A>) -> Option<B>): OptionT<F, B> = FF.run {
-    OptionT(value.map({ f(it) }))
+    OptionT(value.map { f(it) })
   }
 
-  fun <B> subflatMap(FF: Functor<F>, f: (A) -> Option<B>): OptionT<F, B> = transform(FF, { it.flatMap(f) })
+  fun <B> subflatMap(FF: Functor<F>, f: (A) -> Option<B>): OptionT<F, B> = transform(FF) { it.flatMap(f) }
 
   fun <R> toLeft(FF: Functor<F>, default: () -> R): EitherT<F, A, R> =
     EitherT(cata(FF, { Right(default()) }, { Left(it) }))
@@ -114,7 +114,7 @@ data class OptionT<F, A>(val value: Kind<F, Option<A>>) : OptionTOf<F, A>, Optio
 }
 
 fun <F, A, B> OptionTOf<F, A>.mapFilter(FF: Functor<F>, f: (A) -> Option<B>): OptionT<F, B> = FF.run {
-  OptionT(fix().value.map({ it.flatMap(f) }))
+  OptionT(fix().value.map { it.flatMap(f) })
 }
 
 fun <F, A> OptionTOf<F, A>.value(): Kind<F, Option<A>> = this.fix().value
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/SortedMapK.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/SortedMapK.kt
index ec946c9ab71..5cb7057e02f 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/SortedMapK.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/SortedMapK.kt
@@ -48,9 +48,9 @@ data class SortedMapK<A : Comparable<A>, B>(val map: SortedMap<A, B>) : SortedMa
     this.map.foldLeft(c) { m: SortedMap<A, C>, (a, b) -> f(m.k(), Tuple2(a, b)) }.k()
 
   fun <G, C> traverse(GA: Applicative<G>, f: (B) -> Kind<G, C>): Kind<G, SortedMapK<A, C>> = GA.run {
-    (Foldable.iterateRight(map.iterator(), Eval.always { just(sortedMapOf<A, C>().k()) }))({ kv, lbuf ->
+    (Foldable.iterateRight(map.iterator(), Eval.always { just(sortedMapOf<A, C>().k()) })) { kv, lbuf ->
       f(kv.value).map2Eval(lbuf) { (mapOf(kv.key to it.a).k() + it.b).toSortedMap().k() }
-    }).value()
+    }.value()
   }
 
   companion object
@@ -63,7 +63,7 @@ fun <A : Comparable<A>, B> Option<Tuple2<A, B>>.k(): SortedMapK<A, B> = this.fol
   { mapEntry -> sortedMapOf<A, B>(mapEntry.a to mapEntry.b).k() }
 )
 
-inline fun <K: Comparable<K>, V, G> SortedMapKOf<K, Kind<G, V>>.sequence(GA: Applicative<G>): Kind<G, SortedMapK<K, V>> =
+inline fun <K : Comparable<K>, V, G> SortedMapKOf<K, Kind<G, V>>.sequence(GA: Applicative<G>): Kind<G, SortedMapK<K, V>> =
   fix().traverse(GA, ::identity)
 
 fun <A : Comparable<A>, B> List<Map.Entry<A, B>>.k(): SortedMapK<A, B> =
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/State.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/State.kt
index 1a48f49f314..a79a73e7b6f 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/State.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/State.kt
@@ -56,9 +56,9 @@ fun <S, A> StateFun<S, A>.toState(): State<S, A> = State(IdBimonad, this)
 fun <S, A> StateFunOf<S, A>.toState(): State<S, A> = State(this)
 
 fun <S, T, P1, R> State<S, T>.map(sx: State<S, P1>, f: (T, P1) -> R): State<S, R> =
-  flatMap(IdBimonad, { t -> sx.map { x -> f(t, x) } }).fix()
+  flatMap(IdBimonad) { t -> sx.map { x -> f(t, x) } }.fix()
 
-fun <S, T, R> State<S, T>.map(f: (T) -> R): State<S, R> = flatMap(IdBimonad, { t -> StateApi.just<S, R>(f(t)) }).fix()
+fun <S, T, R> State<S, T>.map(f: (T) -> R): State<S, R> = flatMap(IdBimonad) { t -> StateApi.just<S, R>(f(t)) }.fix()
 
 /**
  * Alias for [StateT.run] `StateT<ForId, S, A>`
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/StateT.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/StateT.kt
index 2db5d7a469d..1ad3102ad30 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/StateT.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/StateT.kt
@@ -157,7 +157,7 @@ class StateT<F, S, A>(
    * @param f the function to apply.
    * @param FF [Functor] for the context [F].
    */
-  fun <B> map(FF: Functor<F>, f: (A) -> B): StateT<F, S, B> = transform(FF, { (s, a) -> Tuple2(s, f(a)) })
+  fun <B> map(FF: Functor<F>, f: (A) -> B): StateT<F, S, B> = transform(FF) { (s, a) -> Tuple2(s, f(a)) }
 
   /**
    * Combine with another [StateT] of same context [F] and state [S].
@@ -201,7 +201,7 @@ class StateT<F, S, A>(
    * @param MF [Monad] for the context [F].
    */
   fun <B> ap(MF: Monad<F>, ff: StateTOf<F, S, (A) -> B>): StateT<F, S, B> =
-    ff.fix().map2(MF, this, { f, a -> f(a) })
+    ff.fix().map2(MF, this) { f, a -> f(a) }
 
   /**
    * Create a product of the value types of [StateT].
@@ -209,7 +209,7 @@ class StateT<F, S, A>(
    * @param sb other stateful computation.
    * @param MF [Monad] for the context [F].
    */
-  fun <B> product(MF: Monad<F>, sb: StateT<F, S, B>): StateT<F, S, Tuple2<A, B>> = map2(MF, sb, { a, b -> Tuple2(a, b) })
+  fun <B> product(MF: Monad<F>, sb: StateT<F, S, B>): StateT<F, S, Tuple2<A, B>> = map2(MF, sb) { a, b -> Tuple2(a, b) }
 
   /**
    * Map the value [A] to another [StateT] object for the same state [S] and context [F] and flatten the structure.
diff --git a/modules/core/arrow-data/src/main/kotlin/arrow/data/Validated.kt b/modules/core/arrow-data/src/main/kotlin/arrow/data/Validated.kt
index 885016331d5..983743f4933 100644
--- a/modules/core/arrow-data/src/main/kotlin/arrow/data/Validated.kt
+++ b/modules/core/arrow-data/src/main/kotlin/arrow/data/Validated.kt
@@ -102,7 +102,7 @@ sealed class Validated<out E, out A> : ValidatedOf<E, A> {
   /**
    * Apply a function to a Valid value, returning a new Valid value
    */
-  fun <B> map(f: (A) -> B): Validated<E, B> = bimap(::identity, { f(it) })
+  fun <B> map(f: (A) -> B): Validated<E, B> = bimap(::identity) { f(it) }
 
   /**
    * Apply a function to an Invalid value, returning a new Invalid value.
@@ -177,7 +177,7 @@ fun <E, A> ValidatedOf<E, A>.orElse(default: () -> Validated<E, A>): Validated<E
 fun <E, A, B> ValidatedOf<E, A>.ap(SE: Semigroup<E>, f: Validated<E, (A) -> B>): Validated<E, B> =
   fix().fold(
     { e -> f.fold({ Invalid(SE.run { it.combine(e) }) }, { Invalid(e) }) },
-    { a -> f.fold(::Invalid, { Valid(it(a)) }) }
+    { a -> f.fold(::Invalid) { Valid(it(a)) } }
   )
 
 fun <E, A> ValidatedOf<E, A>.handleLeftWith(f: (E) -> ValidatedOf<E, A>): Validated<E, A> =
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/ConstTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/ConstTest.kt
index d3f181997ee..bf3893e96be 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/ConstTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/ConstTest.kt
@@ -18,8 +18,8 @@ class ConstTest : UnitSpec() {
       testLaws(
         TraverseFilterLaws.laws(this, this, { Const(it) }, Eq.any()),
         ApplicativeLaws.laws(this, Eq.any()),
-        EqLaws.laws(Const.eq<Int, Int>(Eq.any()), { Const(it) }),
-        ShowLaws.laws(Const.show(), Const.eq<Int, Int>(Eq.any()), { Const(it) })
+        EqLaws.laws(Const.eq<Int, Int>(Eq.any())) { Const(it) },
+        ShowLaws.laws(Const.show(), Const.eq<Int, Int>(Eq.any())) { Const(it) }
       )
     }
   }
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/CoreaderTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/CoreaderTest.kt
index 149fad4b87b..57098018a80 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/CoreaderTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/CoreaderTest.kt
@@ -24,28 +24,28 @@ class CoreaderTest : UnitSpec() {
 
         "flatMap should map over the inner value" {
           forAll { num: Int ->
-            invoke<Int, Int>({ it -> it * 2 }).flatMap { a -> Coreader.just<Int, Int>(this, a * 3) }
+            invoke<Int, Int> { it -> it * 2 }.flatMap { a -> Coreader.just<Int, Int>(this, a * 3) }
               .runId(num) == num * 6
           }
         }
 
         "bimap should map over both sides of the run function" {
           forAll { num: Int ->
-            invoke<Int, Int>({ it -> it * 2 }).bimap({ a: String -> Integer.parseInt(a) }, { it.toString() })
+            invoke<Int, Int> { it -> it * 2 }.bimap({ a: String -> Integer.parseInt(a) }, { it.toString() })
               .runId("$num") == "${num * 2}"
           }
         }
 
         "lmap should map over the left side of the function" {
           forAll { num: Int ->
-            invoke<Int, Int>({ it -> it * 2 }).lmap { a: String -> Integer.parseInt(a) }
+            invoke<Int, Int> { it -> it * 2 }.lmap { a: String -> Integer.parseInt(a) }
               .runId("$num") == num * 2
           }
         }
 
         "contramapValue" {
           forAll { num: Int ->
-            invoke<Int, Int>({ it -> it * 2 }).contramapValue { a: IdOf<Int> -> Id(a.value() * 3) }
+            invoke<Int, Int> { it -> it * 2 }.contramapValue { a: IdOf<Int> -> Id(a.value() * 3) }
               .runId(num) == num * 6
           }
         }
@@ -61,7 +61,7 @@ class CoreaderTest : UnitSpec() {
 
           cokleisli.andThen(Id(3)).run(Id(0)) shouldBe 3
 
-          cokleisli.andThen(invoke<Int, Int>({ it + 1 })).run(Id(0)) shouldBe 1
+          cokleisli.andThen(invoke<Int, Int> { it + 1 }).run(Id(0)) shouldBe 1
         }
       }
     }
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/EitherTTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/EitherTTest.kt
index 509ff1a3c50..60b45495741 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/EitherTTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/EitherTTest.kt
@@ -31,9 +31,9 @@ class EitherTTest : UnitSpec() {
       forAll { i: Int, j: Int ->
         val left: Either<Int, Int> = Left(i)
         val right: Either<Int, Int> = Right(j)
-        EitherT(Option(left)).mapLeft(Option.functor(), { it + 1 }) == EitherT(Option(Left(i + 1))) &&
-          EitherT(Option(right)).mapLeft(Option.functor(), { it + 1 }) == EitherT(Option(right)) &&
-          EitherT(Option.empty<Either<Int, Int>>()).mapLeft(Option.functor(), { it + 1 }) == EitherT(Option.empty<Either<Int, Int>>())
+        EitherT(Option(left)).mapLeft(Option.functor()) { it + 1 } == EitherT(Option(Left(i + 1))) &&
+          EitherT(Option(right)).mapLeft(Option.functor()) { it + 1 } == EitherT(Option(right)) &&
+          EitherT(Option.empty<Either<Int, Int>>()).mapLeft(Option.functor()) { it + 1 } == EitherT(Option.empty<Either<Int, Int>>())
       }
     }
 
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/EitherTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/EitherTest.kt
index 9ab8865dfef..bfc6bc76bcf 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/EitherTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/EitherTest.kt
@@ -30,8 +30,8 @@ class EitherTest : UnitSpec() {
         BifunctorLaws.laws(Either.bifunctor(), { Right(it) }, EQ2),
         SemigroupLaws.laws(Either.semigroup(String.semigroup(), String.semigroup()), Either.right("1"), Either.right("2"), Either.right("3"), Either.eq(String.eq(), String.eq())),
         MonoidLaws.laws(Either.monoid(MOL=String.monoid(), MOR = Int.monoid()), Either.right(1), Either.eq(String.eq(), Int.eq())),
-        EqLaws.laws(Either.eq(String.eq(), Int.eq()), { Right(it) }),
-        ShowLaws.laws(Either.show(), Either.eq(String.eq(), Int.eq()), { Right(it) }),
+        EqLaws.laws(Either.eq(String.eq(), Int.eq())) { Right(it) },
+        ShowLaws.laws(Either.show(), Either.eq(String.eq(), Int.eq())) { Right(it) },
         MonadErrorLaws.laws(this, Eq.any(), Eq.any()),
         TraverseLaws.laws(this, this, { Right(it) }, Eq.any()),
         SemigroupKLaws.laws(Either.semigroupK(), Either.applicative(), EQ)
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/IorTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/IorTest.kt
index 4e7cc4e624e..59ab25792b2 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/IorTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/IorTest.kt
@@ -33,7 +33,7 @@ class IorTest : UnitSpec() {
     ForIor(Int.semigroup()) extensions {
       testLaws(
         BifunctorLaws.laws(Ior.bifunctor(), { Ior.Both(it, it) }, EQ2),
-        EqLaws.laws(EQ, { Right(it) }),
+        EqLaws.laws(EQ) { Right(it) },
         ShowLaws.laws(Ior.show(), EQ) { Right(it) },
         MonadLaws.laws(this, Eq.any()),
         TraverseLaws.laws(Ior.traverse(), this, ::Right, Eq.any())
@@ -130,7 +130,7 @@ class IorTest : UnitSpec() {
 
     "Ior.monad.flatMap should combine left values" {
       val ior1 = Ior.Both(3, "Hello, world!")
-      val iorResult = intIorMonad.run { ior1.flatMap({ Ior.Left<Int, String>(7) }) }
+      val iorResult = intIorMonad.run { ior1.flatMap { Ior.Left<Int, String>(7) } }
       iorResult shouldBe Ior.Left<Int, String>(10)
     }
 
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/KleisliTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/KleisliTest.kt
index c918b2c1994..a2687cd25ff 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/KleisliTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/KleisliTest.kt
@@ -22,11 +22,11 @@ class KleisliTest : UnitSpec() {
     }
 
     "andThen should continue sequence" {
-      val kleisli: Kleisli<ForId, Int, Int> = Kleisli({ a: Int -> Id(a) })
+      val kleisli: Kleisli<ForId, Int, Int> = Kleisli { a: Int -> Id(a) }
 
       kleisli.andThen(Id.monad(), Id(3)).run(0).fix().value shouldBe 3
 
-      kleisli.andThen(Id.monad(), { b -> Id(b + 1) }).run(0).fix().value shouldBe 1
+      kleisli.andThen(Id.monad()) { b -> Id(b + 1) }.run(0).fix().value shouldBe 1
     }
   }
 }
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/OptionTTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/OptionTTest.kt
index b2fae6e1ca9..ae11bd399ba 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/OptionTTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/OptionTTest.kt
@@ -57,25 +57,25 @@ class OptionTTest : UnitSpec() {
 
     "toLeft for Some should build a correct EitherT" {
       forAll { a: Int, b: String ->
-        OptionT.fromOption(this.NELM, Some(a)).toLeft(this.NELM, { b }) == EitherT.left<ForNonEmptyList, Int, String>(this.NELM, a)
+        OptionT.fromOption(this.NELM, Some(a)).toLeft(this.NELM) { b } == EitherT.left<ForNonEmptyList, Int, String>(this.NELM, a)
       }
     }
 
     "toLeft for None should build a correct EitherT" {
       forAll { a: Int, b: String ->
-        OptionT.fromOption<ForNonEmptyList, Int>(this.NELM, None).toLeft(this.NELM, { b }) == EitherT.right<ForNonEmptyList, Int, String>(this.NELM, b)
+        OptionT.fromOption<ForNonEmptyList, Int>(this.NELM, None).toLeft(this.NELM) { b } == EitherT.right<ForNonEmptyList, Int, String>(this.NELM, b)
       }
     }
 
     "toRight for Some should build a correct EitherT" {
       forAll { a: Int, b: String ->
-        OptionT.fromOption(this.NELM, Some(b)).toRight(this.NELM, { a }) == EitherT.right<ForNonEmptyList, Int, String>(this.NELM, b)
+        OptionT.fromOption(this.NELM, Some(b)).toRight(this.NELM) { a } == EitherT.right<ForNonEmptyList, Int, String>(this.NELM, b)
       }
     }
 
     "toRight for None should build a correct EitherT" {
       forAll { a: Int, b: String ->
-        OptionT.fromOption<ForNonEmptyList, String>(this.NELM, None).toRight(this.NELM, { a }) == EitherT.left<ForNonEmptyList, Int, String>(this.NELM, a)
+        OptionT.fromOption<ForNonEmptyList, String>(this.NELM, None).toRight(this.NELM) { a } == EitherT.left<ForNonEmptyList, Int, String>(this.NELM, a)
       }
     }
 
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/OptionTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/OptionTest.kt
index 6e240942f08..f641a1ac0c5 100755
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/OptionTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/OptionTest.kt
@@ -43,8 +43,8 @@ class OptionTest : UnitSpec() {
 
     ForOption extensions {
       testLaws(
-        EqLaws.laws(Option.eq(Int.eq()), { genOption(Gen.int()).generate() }),
-        ShowLaws.laws(Option.show(), Option.eq(Int.eq()), { Some(it) }),
+        EqLaws.laws(Option.eq(Int.eq())) { genOption(Gen.int()).generate() },
+        ShowLaws.laws(Option.show(), Option.eq(Int.eq())) { Some(it) },
         MonoidLaws.laws(Option.monoid(Int.monoid()), Some(1), Option.eq(Int.eq())),
         //testLaws(MonadErrorLaws.laws(monadError<ForOption, Unit>(), Eq.any(), EQ_EITHER)) TODO reenable once the MonadErrorLaws are parametric to `E`
         TraverseFilterLaws.laws(this, this, ::Some, Eq.any()),
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/ReducibleTests.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/ReducibleTests.kt
index f85a7b1b5c8..ed8843302aa 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/ReducibleTests.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/ReducibleTests.kt
@@ -45,15 +45,15 @@ class ReducibleTests : UnitSpec() {
           val tail = (2 to 10).toList()
           val total = 1 + tail.sum()
           val nel = NonEmptyList(1, tail)
-          nel.reduceLeft({ a, b -> a + b }) shouldBe total
-          nel.reduceRight({ x, ly -> ly.map({ x + it }) }).value() shouldBe (total)
+          nel.reduceLeft { a, b -> a + b } shouldBe total
+          nel.reduceRight { x, ly -> ly.map { x + it } }.value() shouldBe (total)
           nel.reduce(this) shouldBe total
 
           // more basic checks
           val names = NonEmptyList.of("Aaron", "Betty", "Calvin", "Deirdra")
-          val totalLength = names.all.map({ it.length }).sum()
+          val totalLength = names.all.map { it.length }.sum()
           names.reduceLeftTo({ it.length }, { sum, s -> s.length + sum }) shouldBe totalLength
-          names.reduceMap(this, { it.length }) shouldBe totalLength
+          names.reduceMap(this) { it.length } shouldBe totalLength
         }
       }
     }
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/StateTests.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/StateTests.kt
index 22c13f4c6a1..afac2dcf58e 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/StateTests.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/StateTests.kt
@@ -22,7 +22,7 @@ class StateTests : UnitSpec() {
     }
 
     "addOne.map(n -> n).run(1) should return same Pair(2, 1)" {
-      addOne.map(Id.functor(), { n -> n }).run(1) shouldBe Tuple2(2, 1)
+      addOne.map(Id.functor()) { n -> n }.run(1) shouldBe Tuple2(2, 1)
     }
 
     "addOne.map(n -> n.toString).run(1) should return same Pair(2, \"1\")" {
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/TryTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/TryTest.kt
index 73563862f0f..99a0af63046 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/TryTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/TryTest.kt
@@ -146,8 +146,8 @@ class TryTest : UnitSpec() {
         map(
           Success("11th"),
           Success("Doctor"),
-          Success("Who"),
-          { (a, b, c) -> "$a $b $c" }) shouldBe Success("11th Doctor Who")
+          Success("Who")
+        ) { (a, b, c) -> "$a $b $c" } shouldBe Success("11th Doctor Who")
       }
     }
 
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/data/ValidatedTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/data/ValidatedTest.kt
index 84f6f3b3e78..b71507d3f86 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/data/ValidatedTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/data/ValidatedTest.kt
@@ -131,9 +131,9 @@ class ValidatedTest : UnitSpec() {
     val plusIntSemigroup: Semigroup<Int> = Int.semigroup()
 
     "findValid should return the first Valid value or combine or Invalid values in otherwise" {
-      Valid(10).findValid(plusIntSemigroup, { fail("None should not be called") }) shouldBe Valid(10)
-      Invalid(10).findValid(plusIntSemigroup, { Valid(5) }) shouldBe Valid(5)
-      Invalid(10).findValid(plusIntSemigroup, { Invalid(5) }) shouldBe Invalid(15)
+      Valid(10).findValid(plusIntSemigroup) { fail("None should not be called") } shouldBe Valid(10)
+      Invalid(10).findValid(plusIntSemigroup) { Valid(5) } shouldBe Valid(5)
+      Invalid(10).findValid(plusIntSemigroup) { Invalid(5) } shouldBe Invalid(15)
     }
 
     "ap should return Valid(f(a)) if both are Valid" {
@@ -183,24 +183,24 @@ class ValidatedTest : UnitSpec() {
         map(
           Valid("11th"),
           Valid("Doctor"),
-          Valid("Who"),
-          { (a, b, c) -> "$a $b $c" }) shouldBe Valid("11th Doctor Who")
+          Valid("Who")
+        ) { (a, b, c) -> "$a $b $c" } shouldBe Valid("11th Doctor Who")
       }
 
       "Cartesian builder should build products over heterogeneous Validated" {
         map(
           Valid(13),
           Valid("Doctor"),
-          Valid(false),
-          { (a, b, c) -> "${a}th $b is $c" }) shouldBe Valid("13th Doctor is false")
+          Valid(false)
+        ) { (a, b, c) -> "${a}th $b is $c" } shouldBe Valid("13th Doctor is false")
       }
 
       "Cartesian builder should build products over Invalid Validated" {
         map(
           Invalid("fail1"),
           Invalid("fail2"),
-          Valid("Who"),
-          { "success!" }) shouldBe Invalid("fail1fail2")
+          Valid("Who")
+        ) { "success!" } shouldBe Invalid("fail1fail2")
       }
     }
 
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/free/CofreeTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/free/CofreeTest.kt
index e3629477dd0..b96622af227 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/free/CofreeTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/free/CofreeTest.kt
@@ -22,10 +22,10 @@ class CofreeTest : UnitSpec() {
     ForCofree<ForOption>() extensions {
       testLaws(ComonadLaws.laws(this, {
         val sideEffect = SideEffect()
-        unfold(Option.functor(), sideEffect.counter, {
+        unfold(Option.functor(), sideEffect.counter) {
           sideEffect.increment()
           if (it % 2 == 0) None else Some(it + 1)
-        })
+        }
       }, Eq { a, b ->
         a.fix().run().fix() == b.fix().run().fix()
       }))
@@ -33,7 +33,7 @@ class CofreeTest : UnitSpec() {
 
     "tailForced should evaluate and return" {
       val sideEffect = SideEffect()
-      val start: Cofree<ForId, Int> = unfold(Id.functor(), sideEffect.counter, { sideEffect.increment(); Id(it + 1) })
+      val start: Cofree<ForId, Int> = unfold(Id.functor(), sideEffect.counter) { sideEffect.increment(); Id(it + 1) }
       sideEffect.counter shouldBe 0
       start.tailForced()
       sideEffect.counter shouldBe 1
@@ -41,7 +41,7 @@ class CofreeTest : UnitSpec() {
 
     "runTail should run once and return" {
       val sideEffect = SideEffect()
-      val start: Cofree<ForId, Int> = unfold(Id.functor(), sideEffect.counter, { sideEffect.increment(); Id(it) })
+      val start: Cofree<ForId, Int> = unfold(Id.functor(), sideEffect.counter) { sideEffect.increment(); Id(it) }
       sideEffect.counter shouldBe 0
       start.runTail()
       sideEffect.counter shouldBe 1
@@ -49,10 +49,10 @@ class CofreeTest : UnitSpec() {
 
     "run should fold until completion" {
       val sideEffect = SideEffect()
-      val start: Cofree<ForOption, Int> = unfold(Option.functor(), sideEffect.counter, {
+      val start: Cofree<ForOption, Int> = unfold(Option.functor(), sideEffect.counter) {
         sideEffect.increment()
         if (it == 5) None else Some(it + 1)
-      })
+      }
       sideEffect.counter shouldBe 0
       start.run()
       sideEffect.counter shouldBe 6
@@ -63,10 +63,10 @@ class CofreeTest : UnitSpec() {
       try {
         val limit = 10000
         val counter = SideEffect()
-        val startThousands: Cofree<ForOption, Int> = unfold(Option.functor(), counter.counter, {
+        val startThousands: Cofree<ForOption, Int> = unfold(Option.functor(), counter.counter) {
           counter.increment()
           if (it == limit) None else Some(it + 1)
-        })
+        }
         startThousands.run()
         throw AssertionError("Run should overflow on a stack-unsafe monad")
       } catch (e: StackOverflowError) {
@@ -76,15 +76,15 @@ class CofreeTest : UnitSpec() {
 
     "run with an stack-safe monad should not blow up the stack" {
       val counter = SideEffect()
-      val startThousands: Cofree<ForEval, Int> = unfold(Eval.functor(), counter.counter, {
+      val startThousands: Cofree<ForEval, Int> = unfold(Eval.functor(), counter.counter) {
         counter.increment()
         Eval.now(it + 1)
-      })
+      }
       startThousands.run()
       counter.counter shouldBe 1
     }
 
-    val startHundred: Cofree<ForOption, Int> = unfold(Option.functor(), 0, { if (it == 100) None else Some(it + 1) })
+    val startHundred: Cofree<ForOption, Int> = unfold(Option.functor(), 0) { if (it == 100) None else Some(it + 1) }
 
     "mapBranchingRoot should modify the value of the functor" {
       val mapped = startHundred.mapBranchingRoot(object : FunctionK<ForOption, ForOption> {
@@ -114,7 +114,7 @@ class CofreeTest : UnitSpec() {
       cata shouldBe expected
     }
 
-    val startTwoThousand: Cofree<ForOption, Int> = unfold(Option.functor(), 0, { if (it == 2000) None else Some(it + 1) })
+    val startTwoThousand: Cofree<ForOption, Int> = unfold(Option.functor(), 0) { if (it == 2000) None else Some(it + 1) }
 
     with(startTwoThousand) {
       "cata with an stack-unsafe monad should blow up the stack" {
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/free/CoyonedaTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/free/CoyonedaTest.kt
index a177a379274..10c68af32b2 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/free/CoyonedaTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/free/CoyonedaTest.kt
@@ -19,7 +19,7 @@ class CoyonedaTest : UnitSpec() {
   init {
 
     ForCoyoneda<ForId, Int>() extensions {
-      testLaws(FunctorLaws.laws(this, { Coyoneda(Id(0), { it }) }, EQ))
+      testLaws(FunctorLaws.laws(this, { Coyoneda(Id(0)) { it } }, EQ))
     }
 
     "map should be stack-safe" {
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/free/FreeApplicativeTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/free/FreeApplicativeTest.kt
index ce95a82a551..e3facb069b2 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/free/FreeApplicativeTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/free/FreeApplicativeTest.kt
@@ -44,7 +44,7 @@ class FreeApplicativeTest : UnitSpec() {
 
     ForFreeApplicative<OpsAp.F>() extensions {
       testLaws(
-        EqLaws.laws(EQ, { OpsAp.value(it) }),
+        EqLaws.laws(EQ) { OpsAp.value(it) },
         ApplicativeLaws.laws(OpsAp, EQ),
         ApplicativeLaws.laws(this, EQ)
       )
@@ -61,9 +61,9 @@ class FreeApplicativeTest : UnitSpec() {
       val loops = 10000
       val start = 333
       val r = FreeApplicative.liftF(NonEmptyList.of(start))
-      val rr = (1..loops).toList().fold(r, { v, _ -> v.ap(FreeApplicative.liftF(NonEmptyList.of({ a: Int -> a + 1 }))) })
+      val rr = (1..loops).toList().fold(r) { v, _ -> v.ap(FreeApplicative.liftF(NonEmptyList.of({ a: Int -> a + 1 }))) }
       rr.foldK(NonEmptyList.applicative()) shouldBe NonEmptyList.of(start + loops)
-      val rx = (1..loops).toList().foldRight(r, { _, v -> v.ap(FreeApplicative.liftF(NonEmptyList.of({ a: Int -> a + 1 }))) })
+      val rx = (1..loops).toList().foldRight(r) { _, v -> v.ap(FreeApplicative.liftF(NonEmptyList.of({ a: Int -> a + 1 }))) }
       rx.foldK(NonEmptyList.applicative()) shouldBe NonEmptyList.of(start + loops)
     }
   }
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/free/FreeTest.kt b/modules/core/arrow-data/src/test/kotlin/arrow/free/FreeTest.kt
index 268cc39a6d3..d3706a3b298 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/free/FreeTest.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/free/FreeTest.kt
@@ -54,7 +54,7 @@ class FreeTest : UnitSpec() {
 
     ForFree<Ops.F>() extensions {
       testLaws(
-        EqLaws.laws(EQ, { Ops.value(it) }),
+        EqLaws.laws(EQ) { Ops.value(it) },
         MonadLaws.laws(Ops, EQ),
         MonadLaws.laws(this, EQ)
       )
diff --git a/modules/core/arrow-data/src/test/kotlin/arrow/free/Interpreters.kt b/modules/core/arrow-data/src/test/kotlin/arrow/free/Interpreters.kt
index 8987b32015c..80e381f6a3e 100644
--- a/modules/core/arrow-data/src/test/kotlin/arrow/free/Interpreters.kt
+++ b/modules/core/arrow-data/src/test/kotlin/arrow/free/Interpreters.kt
@@ -16,7 +16,7 @@ val cofreeListToNel: FunctionK<CofreePartialOf<ForListK>, ForNonEmptyList> = obj
   override fun <A> invoke(fa: Kind<CofreePartialOf<ForListK>, A>): Kind<ForNonEmptyList, A> =
     fa.fix().let { c: Cofree<ForListK, A> ->
       val all: List<Cofree<ForListK, A>> = c.tailForced().fix()
-      val tail: List<A> = all.foldRight(listOf<A>(), { v, acc -> acc + invoke(v).fix().all })
+      val tail: List<A> = all.foldRight(listOf<A>()) { v, acc -> acc + invoke(v).fix().all }
       val headL: List<A> = listOf(c.head)
       NonEmptyList.fromListUnsafe(headL + tail)
     }
diff --git a/modules/core/arrow-free/src/main/kotlin/arrow/free/Cofree.kt b/modules/core/arrow-free/src/main/kotlin/arrow/free/Cofree.kt
index e9d930efb8b..5da08b99e1f 100644
--- a/modules/core/arrow-free/src/main/kotlin/arrow/free/Cofree.kt
+++ b/modules/core/arrow-free/src/main/kotlin/arrow/free/Cofree.kt
@@ -20,25 +20,25 @@ data class Cofree<S, A>(val FS: Functor<S>, val head: A, val tail: Eval<CofreeEv
 
   inline fun <B> transform(f: (A) -> B, noinline g: (Cofree<S, A>) -> Cofree<S, B>): Cofree<S, B> = Cofree(FS, f(head), tail.map { it.map(g) })
 
-  fun <B> map(f: (A) -> B): Cofree<S, B> = transform(f, { it.map(f) })
+  fun <B> map(f: (A) -> B): Cofree<S, B> = transform(f) { it.map(f) }
 
   fun mapBranchingRoot(fk: FunctionK<S, S>): Cofree<S, A> = Cofree(FS, head, tail.map { fk(it) })
 
   // Due to the recursive nature of this function, it cannot be reified for FT to use functor<T>()
-  fun <T> mapBranchingS(fk: FunctionK<S, T>, FT: Functor<T>): Cofree<T, A> = Cofree(FT, head, tail.map { ce -> fk(ce.map({ it.mapBranchingS(fk, FT) })) })
+  fun <T> mapBranchingS(fk: FunctionK<S, T>, FT: Functor<T>): Cofree<T, A> = Cofree(FT, head, tail.map { ce -> fk(ce.map { it.mapBranchingS(fk, FT) }) })
 
   // Due to the recursive nature of this function, it cannot be reified for FT to use functor<T>()
   fun <T> mapBranchingT(fk: FunctionK<S, T>, FT: Functor<T>): Cofree<T, A> = FT.run {
-    Cofree(this, head, tail.map { ce -> fk(ce).map({ it.mapBranchingT(fk, this) }) })
+    Cofree(this, head, tail.map { ce -> fk(ce).map { it.mapBranchingT(fk, this) } })
   }
 
-  fun <B> coflatMap(f: (Cofree<S, A>) -> B): Cofree<S, B> = Cofree(FS, f(this), tail.map { it.map({ coflatMap(f) }) })
+  fun <B> coflatMap(f: (Cofree<S, A>) -> B): Cofree<S, B> = Cofree(FS, f(this), tail.map { it.map { coflatMap(f) } })
 
-  fun duplicate(): Cofree<S, Cofree<S, A>> = Cofree(FS, this, tail.map { it.map({ duplicate() }) })
+  fun duplicate(): Cofree<S, Cofree<S, A>> = Cofree(FS, this, tail.map { it.map { duplicate() } })
 
   fun runTail(): Cofree<S, A> = Cofree(FS, head, Eval.now(tail.value()))
 
-  fun run(): Cofree<S, A> = Cofree(FS, head, Eval.now(tail.map { it.map({ it.run() }) }.value()))
+  fun run(): Cofree<S, A> = Cofree(FS, head, Eval.now(tail.map { it.map { it.run() } }.value()))
 
   fun extract(): A = head
 
@@ -49,7 +49,7 @@ data class Cofree<S, A>(val FS: Functor<S>, val head: A, val tail: Eval<CofreeEv
 
   fun <F, M, A, B> Cofree<F, A>.cataM(MM: Monad<M>, TF: Traverse<F>, inclusion: FunctionK<ForEval, M>, folder: (A, Kind<F, B>) -> Kind<M, B>): Kind<M, B> = MM.run {
     fun loop(ev: Cofree<F, A>): Eval<Kind<M, B>> {
-      val looped: Kind<M, Kind<F, B>> = TF.run { ev.tailForced().traverse(MM, { inclusion(Eval.defer { loop(it) }).flatten() }) }
+      val looped: Kind<M, Kind<F, B>> = TF.run { ev.tailForced().traverse(MM) { inclusion(Eval.defer { loop(it) }).flatten() } }
       val folded: Kind<M, B> = looped.flatMap { fb -> folder(ev.head, fb) }
       return Eval.now(folded)
     }
@@ -60,7 +60,7 @@ data class Cofree<S, A>(val FS: Functor<S>, val head: A, val tail: Eval<CofreeEv
     fun <S, A> unfold(FS: Functor<S>, a: A, f: (A) -> Kind<S, A>): Cofree<S, A> = create(FS, a, f)
 
     fun <S, A> create(FS: Functor<S>, a: A, f: (A) -> Kind<S, A>): Cofree<S, A> = FS.run {
-      Cofree(this, a, Eval.later { f(a).map({ create(this, it, f) }) })
+      Cofree(this, a, Eval.later { f(a).map { create(this, it, f) } })
     }
 
   }
diff --git a/modules/core/arrow-free/src/main/kotlin/arrow/free/Free.kt b/modules/core/arrow-free/src/main/kotlin/arrow/free/Free.kt
index b44daaab0a6..b7ec3c8af54 100644
--- a/modules/core/arrow-free/src/main/kotlin/arrow/free/Free.kt
+++ b/modules/core/arrow-free/src/main/kotlin/arrow/free/Free.kt
@@ -51,7 +51,7 @@ sealed class Free<S, out A> : FreeOf<S, A> {
 
   data class FlatMapped<S, out A, C>(val c: Free<S, C>, val fm: (C) -> Free<S, A>) : Free<S, A>() {
     override fun <O, B> transform(f: (A) -> B, fs: FunctionK<S, O>): Free<O, B> =
-      FlatMapped(c.transform(::identity, fs), { c.flatMap { fm(it) }.transform(f, fs) })
+      FlatMapped(c.transform(::identity, fs)) { c.flatMap { fm(it) }.transform(f, fs) }
   }
 
   override fun toString(): String = "Free(...) : toString is not stack-safe"
diff --git a/modules/core/arrow-generic/src/test/kotlin/arrow/generic/ProductTest.kt b/modules/core/arrow-generic/src/test/kotlin/arrow/generic/ProductTest.kt
index 1525e8d7350..ea0067a3ff1 100644
--- a/modules/core/arrow-generic/src/test/kotlin/arrow/generic/ProductTest.kt
+++ b/modules/core/arrow-generic/src/test/kotlin/arrow/generic/ProductTest.kt
@@ -38,9 +38,9 @@ inline fun <reified F, A> Gen<A>.generateIn(applicative: Applicative<F>): Gen<Ki
   Gen.create { applicative.just(this.generate()) }
 
 inline fun <reified F> Applicative<F>.testPersonApplicative() {
-  forAll(Gen.string(), Gen.int(), personGen(), { a, b, c ->
+  forAll(Gen.string(), Gen.int(), personGen()) { a, b, c ->
     mapToPerson(just(a), just(b), just(c.some())) == just(Person(a, b, c.some()))
-  })
+  }
 }
 
 @RunWith(KTestJUnitRunner::class)
@@ -48,31 +48,31 @@ class ProductTest : UnitSpec() {
   init {
 
     ".tupled()" {
-      forAll(personGen(), {
+      forAll(personGen()) {
         it.tupled() == Tuple3(it.name, it.age, it.related)
-      })
+      }
     }
 
     ".toPerson()" {
-      forAll(tuple3Gen(), {
+      forAll(tuple3Gen()) {
         it.toPerson() == Person(it.a, it.b, it.c)
-      })
+      }
     }
 
     ".tupledLabeled()" {
-      forAll(personGen(), {
+      forAll(personGen()) {
         it.tupledLabeled() == Tuple3(
           "name" toT it.name,
           "age" toT it.age,
           "related" toT it.related
         )
-      })
+      }
     }
 
     "List<@product>.combineAll()" {
-      forAll(Gen.list(personGen()), {
+      forAll(Gen.list(personGen())) {
         it.combineAll() == it.reduce { a, b -> a + b }
-      })
+      }
     }
 
 
@@ -99,7 +99,7 @@ class ProductTest : UnitSpec() {
     }
 
     "Semigroup combine" {
-      forAll(personGen(), personGen(), { a, b ->
+      forAll(personGen(), personGen()) { a, b ->
         with(Person.semigroup()) {
           a.combine(b) == Person(
             a.name + b.name,
@@ -107,34 +107,34 @@ class ProductTest : UnitSpec() {
             Option.monoid(this).combineAll(a.related, b.related)
           )
         }
-      })
+      }
     }
 
     "Semigroup + syntax" {
-      forAll(personGen(), personGen(), { a, b ->
+      forAll(personGen(), personGen()) { a, b ->
         a + b == Person(
           a.name + b.name,
           a.age + b.age,
           Option.monoid(Person.monoid()).combineAll(a.related, b.related)
         )
-      })
+      }
     }
 
     "Monoid empty" {
-      forAll(personGen(), personGen(), { a, b ->
+      forAll(personGen(), personGen()) { a, b ->
         Person.monoid().empty() == Person("", 0, None)
-      })
+      }
     }
 
     "Monoid empty syntax" {
-      forAll(personGen(), personGen(), { a, b ->
+      forAll(personGen(), personGen()) { a, b ->
         emptyPerson() == Person("", 0, None)
-      })
+      }
     }
 
     with(Gen) {
       testLaws(
-        EqLaws.laws(Person.eq(), { personGen().generate().copy(age = it) }),
+        EqLaws.laws(Person.eq()) { personGen().generate().copy(age = it) },
         SemigroupLaws.laws(
           Person.semigroup(),
           personGen().generate(),
diff --git a/modules/core/arrow-instances-core/src/main/kotlin/arrow/instances/option.kt b/modules/core/arrow-instances-core/src/main/kotlin/arrow/instances/option.kt
index f19116eee41..9d3c0e74ad5 100644
--- a/modules/core/arrow-instances-core/src/main/kotlin/arrow/instances/option.kt
+++ b/modules/core/arrow-instances-core/src/main/kotlin/arrow/instances/option.kt
@@ -32,7 +32,7 @@ interface OptionApplicativeErrorInstance : OptionApplicativeInstance, Applicativ
     None
 
   override fun <A> Kind<ForOption, A>.handleErrorWith(f: (Unit) -> Kind<ForOption, A>): Option<A> =
-    fix().orElse({ f(Unit).fix() })
+    fix().orElse { f(Unit).fix() }
 }
 
 @instance(Option::class)
@@ -41,7 +41,7 @@ interface OptionMonadErrorInstance : OptionMonadInstance, MonadError<ForOption,
     None
 
   override fun <A> Kind<ForOption, A>.handleErrorWith(f: (Unit) -> Kind<ForOption, A>): Option<A> =
-    fix().orElse({ f(Unit).fix() })
+    fix().orElse { f(Unit).fix() }
 }
 
 @instance(Option::class)
diff --git a/modules/core/arrow-instances-core/src/main/kotlin/arrow/instances/try.kt b/modules/core/arrow-instances-core/src/main/kotlin/arrow/instances/try.kt
index 41282535291..9bbce998799 100644
--- a/modules/core/arrow-instances-core/src/main/kotlin/arrow/instances/try.kt
+++ b/modules/core/arrow-instances-core/src/main/kotlin/arrow/instances/try.kt
@@ -128,7 +128,7 @@ interface TryFoldableInstance : Foldable<ForTry> {
 }
 
 fun <A, B, G> TryOf<A>.traverse(GA: Applicative<G>, f: (A) -> Kind<G, B>): Kind<G, Try<B>> = GA.run {
-  fix().fold({ just(Try.raise(it)) }, { f(it).map({ Try.just(it) }) })
+  fix().fold({ just(Try.raise(it)) }, { f(it).map { Try.just(it) } })
 }
 
 fun <A, G> TryOf<Kind<G, A>>.sequence(GA: Applicative<G>): Kind<G, Try<A>> =
diff --git a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/eithert.kt b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/eithert.kt
index 555122c14e2..4eac209419e 100644
--- a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/eithert.kt
+++ b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/eithert.kt
@@ -12,7 +12,7 @@ interface EitherTFunctorInstance<F, L> : Functor<EitherTPartialOf<F, L>> {
 
   fun FF(): Functor<F>
 
-  override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.map(f: (A) -> B): EitherT<F, L, B> = fix().map(FF(), { f(it) })
+  override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.map(f: (A) -> B): EitherT<F, L, B> = fix().map(FF()) { f(it) }
 }
 
 interface EitherTApplicativeInstance<F, L> : EitherTFunctorInstance<F, L>, Applicative<EitherTPartialOf<F, L>> {
@@ -21,7 +21,7 @@ interface EitherTApplicativeInstance<F, L> : EitherTFunctorInstance<F, L>, Appli
 
   override fun <A> just(a: A): EitherT<F, L, A> = EitherT.just(MF(), a)
 
-  override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.map(f: (A) -> B): EitherT<F, L, B> = fix().map(MF(), { f(it) })
+  override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.map(f: (A) -> B): EitherT<F, L, B> = fix().map(MF()) { f(it) }
 
   override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.ap(ff: Kind<EitherTPartialOf<F, L>, (A) -> B>): EitherT<F, L, B> =
     fix().ap(MF(), ff)
@@ -29,12 +29,12 @@ interface EitherTApplicativeInstance<F, L> : EitherTFunctorInstance<F, L>, Appli
 
 interface EitherTMonadInstance<F, L> : EitherTApplicativeInstance<F, L>, Monad<EitherTPartialOf<F, L>> {
 
-  override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.map(f: (A) -> B): EitherT<F, L, B> = fix().map(MF(), { f(it) })
+  override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.map(f: (A) -> B): EitherT<F, L, B> = fix().map(MF()) { f(it) }
 
   override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.ap(ff: Kind<EitherTPartialOf<F, L>, (A) -> B>): EitherT<F, L, B> =
     fix().ap(MF(), ff)
 
-  override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.flatMap(f: (A) -> Kind<EitherTPartialOf<F, L>, B>): EitherT<F, L, B> = fix().flatMap(MF(), { f(it).fix() })
+  override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.flatMap(f: (A) -> Kind<EitherTPartialOf<F, L>, B>): EitherT<F, L, B> = fix().flatMap(MF()) { f(it).fix() }
 
   override fun <A, B> tailRecM(a: A, f: (A) -> EitherTOf<F, L, Either<A, B>>): EitherT<F, L, B> =
     EitherT.tailRecM(MF(), a, f)
@@ -70,7 +70,7 @@ interface EitherTTraverseInstance<F, L> : EitherTFunctorInstance<F, L>, EitherTF
 
   fun TF(): Traverse<F>
 
-  override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.map(f: (A) -> B): EitherT<F, L, B> = fix().map(TF(), { f(it) })
+  override fun <A, B> Kind<EitherTPartialOf<F, L>, A>.map(f: (A) -> B): EitherT<F, L, B> = fix().map(TF()) { f(it) }
 
   override fun <G, B, C> Kind<EitherTPartialOf<F, L>, B>.traverse(AP: Applicative<G>, f: (B) -> Kind<G, C>): Kind<G, EitherT<F, L, C>> =
     fix().traverse(TF(), AP, f)
diff --git a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/ior.kt b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/ior.kt
index db7cc9585dc..13f17066923 100644
--- a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/ior.kt
+++ b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/ior.kt
@@ -38,7 +38,7 @@ interface IorMonadInstance<L> : IorApplicativeInstance<L>, Monad<IorPartialOf<L>
   override fun <A, B> Kind<IorPartialOf<L>, A>.map(f: (A) -> B): Ior<L, B> = fix().map(f)
 
   override fun <A, B> Kind<IorPartialOf<L>, A>.flatMap(f: (A) -> Kind<IorPartialOf<L>, B>): Ior<L, B> =
-    fix().flatMap(SL(), { f(it).fix() })
+    fix().flatMap(SL()) { f(it).fix() }
 
   override fun <A, B> Kind<IorPartialOf<L>, A>.ap(ff: Kind<IorPartialOf<L>, (A) -> B>): Ior<L, B> =
     fix().ap(SL(), ff)
diff --git a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/kleisli.kt b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/kleisli.kt
index e2682b9110f..26d6217cfc7 100644
--- a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/kleisli.kt
+++ b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/kleisli.kt
@@ -19,7 +19,7 @@ interface KleisliApplicativeInstance<F, D> : KleisliFunctorInstance<F, D>, Appli
 
   override fun FF(): Applicative<F>
 
-  override fun <A> just(a: A): Kleisli<F, D, A> = Kleisli({ FF().just(a) })
+  override fun <A> just(a: A): Kleisli<F, D, A> = Kleisli { FF().just(a) }
 
   override fun <A, B> Kind<KleisliPartialOf<F, D>, A>.map(f: (A) -> B): Kleisli<F, D, B> =
     fix().map(FF(), f)
@@ -28,7 +28,7 @@ interface KleisliApplicativeInstance<F, D> : KleisliFunctorInstance<F, D>, Appli
     fix().ap(FF(), ff)
 
   override fun <A, B> Kind<KleisliPartialOf<F, D>, A>.product(fb: Kind<KleisliPartialOf<F, D>, B>): Kleisli<F, D, Tuple2<A, B>> =
-    Kleisli({ FF().run { fix().run(it).product(fb.fix().run(it)) } })
+    Kleisli { FF().run { fix().run(it).product(fb.fix().run(it)) } }
 }
 
 @instance(Kleisli::class)
diff --git a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/mapk.kt b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/mapk.kt
index 2294d00bef1..9db7a807642 100644
--- a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/mapk.kt
+++ b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/mapk.kt
@@ -33,8 +33,8 @@ interface MapKSemigroupInstance<K, A> : Semigroup<MapK<K, A>> {
   fun SG(): Semigroup<A>
 
   override fun MapK<K, A>.combine(b: MapK<K, A>): MapK<K, A> = with(SG()) {
-    if (fix().size < b.fix().size) fix().foldLeft<A>(b.fix(), { my, (k, b) -> my.updated(k, b.maybeCombine(my[k])) })
-    else b.fix().foldLeft<A>(fix(), { my, (k, a) -> my.updated(k, a.maybeCombine(my[k])) })
+    if (fix().size < b.fix().size) fix().foldLeft<A>(b.fix()) { my, (k, b) -> my.updated(k, b.maybeCombine(my[k])) }
+    else b.fix().foldLeft<A>(fix()) { my, (k, a) -> my.updated(k, a.maybeCombine(my[k])) }
   }
 
 }
diff --git a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/optiont.kt b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/optiont.kt
index 79aacc673ac..f24bc679892 100644
--- a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/optiont.kt
+++ b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/optiont.kt
@@ -36,7 +36,7 @@ interface OptionTMonadInstance<F> : OptionTApplicativeInstance<F>, Monad<OptionT
 
   override fun <A, B> Kind<OptionTPartialOf<F>, A>.map(f: (A) -> B): OptionT<F, B> = fix().map(FF(), f)
 
-  override fun <A, B> Kind<OptionTPartialOf<F>, A>.flatMap(f: (A) -> Kind<OptionTPartialOf<F>, B>): OptionT<F, B> = fix().flatMap(FF(), { f(it).fix() })
+  override fun <A, B> Kind<OptionTPartialOf<F>, A>.flatMap(f: (A) -> Kind<OptionTPartialOf<F>, B>): OptionT<F, B> = fix().flatMap(FF()) { f(it).fix() }
 
   override fun <A, B> Kind<OptionTPartialOf<F>, A>.ap(ff: Kind<OptionTPartialOf<F>, (A) -> B>): OptionT<F, B> =
     fix().ap(FF(), ff)
@@ -89,7 +89,7 @@ interface OptionTSemigroupKInstance<F> : SemigroupK<OptionTPartialOf<F>> {
 
   fun FF(): Monad<F>
 
-  override fun <A> Kind<OptionTPartialOf<F>, A>.combineK(y: Kind<OptionTPartialOf<F>, A>): OptionT<F, A> = fix().orElse(FF(), { y.fix() })
+  override fun <A> Kind<OptionTPartialOf<F>, A>.combineK(y: Kind<OptionTPartialOf<F>, A>): OptionT<F, A> = fix().orElse(FF()) { y.fix() }
 }
 
 @instance(OptionT::class)
diff --git a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/sortedmap.kt b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/sortedmap.kt
index a464c01cadf..819703e0ed1 100644
--- a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/sortedmap.kt
+++ b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/sortedmap.kt
@@ -32,10 +32,10 @@ interface SortedMapKSemigroupInstance<A : Comparable<A>, B> : Semigroup<SortedMa
   fun SG(): Semigroup<B>
 
   override fun SortedMapKOf<A, B>.combine(b: SortedMapKOf<A, B>): SortedMapKOf<A, B> =
-    if (this.fix().size < b.fix().size) this.fix().foldLeft<B>(b.fix(), { my, (k, b) ->
+    if (this.fix().size < b.fix().size) this.fix().foldLeft<B>(b.fix()) { my, (k, b) ->
       my.updated(k, SG().run { b.maybeCombine(my[k]) })
-    })
-    else b.fix().foldLeft<B>(this.fix(), { my: SortedMapK<A, B>, (k, a) -> my.updated(k, SG().run { a.maybeCombine(my[k]) }) })
+    }
+    else b.fix().foldLeft<B>(this.fix()) { my: SortedMapK<A, B>, (k, a) -> my.updated(k, SG().run { a.maybeCombine(my[k]) }) }
 }
 
 @instance(SortedMapK::class)
diff --git a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/statet.kt b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/statet.kt
index 7eb0573d491..9ed6dd09bae 100644
--- a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/statet.kt
+++ b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/statet.kt
@@ -48,7 +48,7 @@ interface StateTMonadInstance<F, S> : StateTApplicativeInstance<F, S>, Monad<Sta
     StateT.tailRecM(FF(), a, f)
 
   override fun <A, B> Kind<StateTPartialOf<F, S>, A>.ap(ff: Kind<StateTPartialOf<F, S>, (A) -> B>): StateT<F, S, B> =
-    ff.fix().map2(FF(), fix(), { f, a -> f(a) })
+    ff.fix().map2(FF(), fix()) { f, a -> f(a) }
 
 }
 
@@ -71,7 +71,7 @@ interface StateTApplicativeErrorInstance<F, S, E> : StateTApplicativeInstance<F,
   override fun <A> raiseError(e: E): Kind<StateTPartialOf<F, S>, A> = StateT.lift(FF(), FF().raiseError(e))
 
   override fun <A> Kind<StateTPartialOf<F, S>, A>.handleErrorWith(f: (E) -> Kind<StateTPartialOf<F, S>, A>): StateT<F, S, A> =
-    StateT(FF().just({ s -> FF().run { runM(FF(), s).handleErrorWith({ e -> f(e).runM(FF(), s) }) } }))
+    StateT(FF().just({ s -> FF().run { runM(FF(), s).handleErrorWith { e -> f(e).runM(FF(), s) } } }))
 }
 
 @instance(StateT::class)
diff --git a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/writert.kt b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/writert.kt
index 9c5c22972e2..7bc38fd7590 100644
--- a/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/writert.kt
+++ b/modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/writert.kt
@@ -14,7 +14,7 @@ import arrow.typeclasses.*
 interface WriterTFunctorInstance<F, W> : Functor<WriterTPartialOf<F, W>> {
   fun FF(): Functor<F>
 
-  override fun <A, B> Kind<WriterTPartialOf<F, W>, A>.map(f: (A) -> B): WriterT<F, W, B> = fix().map(FF(), { f(it) })
+  override fun <A, B> Kind<WriterTPartialOf<F, W>, A>.map(f: (A) -> B): WriterT<F, W, B> = fix().map(FF()) { f(it) }
 }
 
 @instance(WriterT::class)
@@ -31,17 +31,17 @@ interface WriterTApplicativeInstance<F, W> : Applicative<WriterTPartialOf<F, W>>
     fix().ap(FF(), MM(), ff)
 
   override fun <A, B> Kind<WriterTPartialOf<F, W>, A>.map(f: (A) -> B): WriterT<F, W, B> =
-    fix().map(FF(), { f(it) })
+    fix().map(FF()) { f(it) }
 }
 
 @instance(WriterT::class)
 interface WriterTMonadInstance<F, W> : WriterTApplicativeInstance<F, W>, Monad<WriterTPartialOf<F, W>> {
 
   override fun <A, B> Kind<WriterTPartialOf<F, W>, A>.map(f: (A) -> B): WriterT<F, W, B> =
-    fix().map(FF(), { f(it) })
+    fix().map(FF()) { f(it) }
 
   override fun <A, B> Kind<WriterTPartialOf<F, W>, A>.flatMap(f: (A) -> Kind<WriterTPartialOf<F, W>, B>): WriterT<F, W, B> =
-    fix().flatMap(FF(), MM(), { f(it).fix() })
+    fix().flatMap(FF(), MM()) { f(it).fix() }
 
   override fun <A, B> tailRecM(a: A, f: (A) -> Kind<WriterTPartialOf<F, W>, Either<A, B>>): WriterT<F, W, B> =
     WriterT.tailRecM(FF(), a, f)
diff --git a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/composed.kt b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/composed.kt
index d782a44d521..65df210c91f 100644
--- a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/composed.kt
+++ b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/composed.kt
@@ -13,7 +13,7 @@ interface ComposedFunctorFilter<F, G> : FunctorFilter<Nested<F, G>>, ComposedFun
   override fun G(): FunctorFilter<G>
 
   override fun <A, B> Kind<Nested<F, G>, A>.mapFilter(f: (A) -> Option<B>): Kind<Nested<F, G>, B> =
-    F().run { unnest().map({ G().run { it.mapFilter(f) } }).nest() }
+    F().run { unnest().map { G().run { it.mapFilter(f) } }.nest() }
 
   fun <A, B> mapFilterC(fga: Kind<F, Kind<G, A>>, f: (A) -> Option<B>): Kind<F, Kind<G, B>> =
     fga.nest().mapFilter(f).unnest()
@@ -39,7 +39,7 @@ interface ComposedTraverseFilter<F, G> :
   override fun GA(): Applicative<G>
 
   override fun <H, A, B> Kind<Nested<F, G>, A>.traverseFilter(AP: Applicative<H>, f: (A) -> Kind<H, Option<B>>): Kind<H, Kind<Nested<F, G>, B>> = AP.run {
-    FT().run { unnest().traverse(AP, { ga -> GT().run { ga.traverseFilter(AP, f) } }) }.map({ it.nest() })
+    FT().run { unnest().traverse(AP) { ga -> GT().run { ga.traverseFilter(AP, f) } } }.map { it.nest() }
   }
 
   fun <H, A, B> traverseFilterC(fa: Kind<F, Kind<G, A>>, f: (A) -> Kind<H, Option<B>>, HA: Applicative<H>): Kind<H, Kind<Nested<F, G>, B>> =
diff --git a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/kleisli.kt b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/kleisli.kt
index 327cb69a370..8bd698585ec 100644
--- a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/kleisli.kt
+++ b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/kleisli.kt
@@ -13,7 +13,7 @@ import arrow.typeclasses.MonadError
 @instance(Kleisli::class)
 interface KleisliMonadReaderInstance<F, D> : KleisliMonadInstance<F, D>, MonadReader<KleisliPartialOf<F, D>, D> {
 
-  override fun ask(): Kleisli<F, D, D> = Kleisli({ FF().just(it) })
+  override fun ask(): Kleisli<F, D, D> = Kleisli { FF().just(it) }
 
   override fun <A> Kind<KleisliPartialOf<F, D>, A>.local(f: (D) -> D): Kleisli<F, D, A> = fix().local(f)
 
diff --git a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/statet.kt b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/statet.kt
index cb78bd9c987..0c3c7f42baf 100644
--- a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/statet.kt
+++ b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/statet.kt
@@ -35,7 +35,7 @@ interface StateTMonadCombineInstance<F, S> : MonadCombine<StateTPartialOf<F, S>>
   override fun <A> empty(): Kind<StateTPartialOf<F, S>, A> = liftT(MC().empty())
 
   fun <A> liftT(ma: Kind<F, A>): StateT<F, S, A> = FF().run {
-    StateT(just({ s: S -> ma.map({ a: A -> s toT a }) }))
+    StateT(just({ s: S -> ma.map { a: A -> s toT a } }))
   }
 }
 
diff --git a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/writert.kt b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/writert.kt
index 7bc1c71b632..25b0f8f477f 100644
--- a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/writert.kt
+++ b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/instances/writert.kt
@@ -24,11 +24,11 @@ interface WriterTMonadFilterInstance<F, W> : WriterTMonadInstance<F, W>, MonadFi
 interface WriterTMonadWriterInstance<F, W> : MonadWriter<WriterTPartialOf<F, W>, W>, WriterTMonadInstance<F, W> {
 
   override fun <A> Kind<WriterTPartialOf<F, W>, A>.listen(): Kind<WriterTPartialOf<F, W>, Tuple2<W, A>> = FF().run {
-    WriterT(fix().content(this).flatMap({ a -> fix().write(this).map({ l -> Tuple2(l, Tuple2(l, a)) }) }))
+    WriterT(fix().content(this).flatMap { a -> fix().write(this).map { l -> Tuple2(l, Tuple2(l, a)) } })
   }
 
   override fun <A> Kind<WriterTPartialOf<F, W>, Tuple2<(W) -> W, A>>.pass(): WriterT<F, W, A> = FF().run {
-    WriterT(fix().content(this).flatMap({ tuple2FA -> fix().write(this).map({ l -> Tuple2(tuple2FA.a(l), tuple2FA.b) }) }))
+    WriterT(fix().content(this).flatMap { tuple2FA -> fix().write(this).map { l -> Tuple2(tuple2FA.a(l), tuple2FA.b) } })
   }
 
   override fun <A> writer(aw: Tuple2<W, A>): WriterT<F, W, A> = WriterT.put2(FF(), aw.b, aw.a)
diff --git a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/FunctorFilter.kt b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/FunctorFilter.kt
index cecc58bb0d5..a811041f4fe 100644
--- a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/FunctorFilter.kt
+++ b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/FunctorFilter.kt
@@ -27,5 +27,5 @@ interface FunctorFilter<F> : Functor<F> {
    * that don't.
    */
   fun <A> Kind<F, A>.filter(f: (A) -> Boolean): Kind<F, A> =
-    mapFilter({ a -> if (f(a)) Some(a) else None })
+    mapFilter { a -> if (f(a)) Some(a) else None }
 }
diff --git a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadCombine.kt b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadCombine.kt
index e041eb546b0..297436f4f1b 100644
--- a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadCombine.kt
+++ b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadCombine.kt
@@ -13,12 +13,12 @@ import arrow.typeclasses.Foldable
 interface MonadCombine<F> : MonadFilter<F>, Alternative<F> {
 
   fun <G, A> Kind<F, Kind<G, A>>.unite(FG: Foldable<G>): Kind<F, A> = FG.run {
-    flatMap({ ga -> ga.foldLeft(empty<A>(), { acc, a -> acc.combineK(just(a)) }) })
+    flatMap { ga -> ga.foldLeft(empty<A>()) { acc, a -> acc.combineK(just(a)) } }
   }
 
   fun <G, A, B> Kind<F, Kind2<G, A, B>>.separate(BFG: Bifoldable<G>): Tuple2<Kind<F, A>, Kind<F, B>> = BFG.run {
-    val asep = flatMap({ gab -> run { gab.bifoldMap(algebra<A>(), { just(it) }, { _ -> empty() }) } })
-    val bsep = flatMap({ gab -> run { gab.bifoldMap(algebra<B>(), { _ -> empty() }, { just(it) }) } })
+    val asep = flatMap { gab -> run { gab.bifoldMap(algebra<A>(), { just(it) }, { _ -> empty() }) } }
+    val bsep = flatMap { gab -> run { gab.bifoldMap(algebra<B>(), { _ -> empty() }, { just(it) }) } }
     return Tuple2(asep, bsep)
   }
 }
diff --git a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadFilter.kt b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadFilter.kt
index f6961ccd3d0..ff76ba76764 100644
--- a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadFilter.kt
+++ b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadFilter.kt
@@ -10,7 +10,7 @@ interface MonadFilter<F> : Monad<F>, FunctorFilter<F> {
   fun <A> empty(): Kind<F, A>
 
   override fun <A, B> Kind<F, A>.mapFilter(f: (A) -> Option<B>): Kind<F, B> =
-    this.flatMap({ a -> f(a).fold({ empty<B>() }, { just(it) }) })
+    this.flatMap { a -> f(a).fold({ empty<B>() }, { just(it) }) }
 }
 
 /**
diff --git a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadState.kt b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadState.kt
index 03fe7282036..22e0949ad7b 100644
--- a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadState.kt
+++ b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadState.kt
@@ -6,13 +6,13 @@ import arrow.typeclasses.Monad
 
 interface MonadState<F, S> : Monad<F> {
 
-  fun <A> state(f: (S) -> Tuple2<S, A>): Kind<F, A> = get().flatMap({ s -> f(s).let { (a, b) -> set(a).map({ b }) } })
+  fun <A> state(f: (S) -> Tuple2<S, A>): Kind<F, A> = get().flatMap { s -> f(s).let { (a, b) -> set(a).map { b } } }
 
   fun get(): Kind<F, S>
 
   fun set(s: S): Kind<F, Unit>
 
-  fun modify(f: (S) -> S): Kind<F, Unit> = get().flatMap({ s -> set(f(s)) })
+  fun modify(f: (S) -> S): Kind<F, Unit> = get().flatMap { s -> set(f(s)) }
 
   fun <A> inspect(f: (S) -> A): Kind<F, A> = get().map(f)
 }
\ No newline at end of file
diff --git a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/TraverseFilter.kt b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/TraverseFilter.kt
index 83cc273784a..9ef4924330a 100644
--- a/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/TraverseFilter.kt
+++ b/modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/TraverseFilter.kt
@@ -10,10 +10,10 @@ interface TraverseFilter<F> : Traverse<F>, FunctorFilter<F> {
   fun <G, A, B> Kind<F, A>.traverseFilter(AP: Applicative<G>, f: (A) -> Kind<G, Option<B>>): Kind<G, Kind<F, B>>
 
   override fun <A, B> Kind<F, A>.mapFilter(f: (A) -> Option<B>): Kind<F, B> =
-    traverseFilter(Id.applicative(), { Id(f(it)) }).value()
+    traverseFilter(Id.applicative()) { Id(f(it)) }.value()
 
   fun <G, A> Kind<F, A>.filterA(f: (A) -> Kind<G, Boolean>, GA: Applicative<G>): Kind<G, Kind<F, A>> = GA.run {
-    traverseFilter(this, { a -> f(a).map({ b -> if (b) Some(a) else None }) })
+    traverseFilter(this) { a -> f(a).map { b -> if (b) Some(a) else None } }
   }
 
   override fun <A> Kind<F, A>.filter(f: (A) -> Boolean): Kind<F, A> =
diff --git a/modules/core/arrow-syntax/src/main/kotlin/arrow/syntax/collections/iterable.kt b/modules/core/arrow-syntax/src/main/kotlin/arrow/syntax/collections/iterable.kt
index e726be3a92e..34dc4ec7829 100644
--- a/modules/core/arrow-syntax/src/main/kotlin/arrow/syntax/collections/iterable.kt
+++ b/modules/core/arrow-syntax/src/main/kotlin/arrow/syntax/collections/iterable.kt
@@ -8,7 +8,7 @@ fun <T> Iterable<T>.firstOption(predicate: Predicate<T>): Option<T> = firstOrNul
 
 fun <A : Any, B> Iterable<A>.collect(vararg cases: PartialFunction<A, B>): List<B> =
   flatMap { value: A ->
-    val f: PartialFunction<A, B> = cases.reduce({ a, b -> a.orElse(b) })
+    val f: PartialFunction<A, B> = cases.reduce { a, b -> a.orElse(b) }
     if (f.isDefinedAt(value)) listOf(f(value))
     else emptyList()
   }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/AlternativeLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/AlternativeLaws.kt
index 2ec3a71557c..46af9230733 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/AlternativeLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/AlternativeLaws.kt
@@ -16,26 +16,26 @@ object AlternativeLaws {
                       noinline cff: (Int) -> Kind<F, (Int) -> Int>,
                       EQ: Eq<Kind<F, Int>>): List<Law> =
     ApplicativeLaws.laws(AF, EQ) + MonoidKLaws.laws(AF, AF, EQ) + listOf(
-      Law("Alternative Laws: Right Absorption", { AF.alternativeRightAbsorption(cff, EQ) }),
-      Law("Alternative Laws: Left Distributivity", { AF.alternativeLeftDistributivity(cf, EQ) }),
-      Law("Alternative Laws: Right Distributivity", { AF.alternativeRightDistributivity(cf, cff, EQ) }))
+      Law("Alternative Laws: Right Absorption") { AF.alternativeRightAbsorption(cff, EQ) },
+      Law("Alternative Laws: Left Distributivity") { AF.alternativeLeftDistributivity(cf, EQ) },
+      Law("Alternative Laws: Right Distributivity") { AF.alternativeRightDistributivity(cf, cff, EQ) })
 
   fun <F> Alternative<F>.alternativeRightAbsorption(cff: (Int) -> Kind<F, (Int) -> Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor2(Gen.int(), cff), { fa: Kind<F, (Int) -> Int> ->
+    forAll(genConstructor2(Gen.int(), cff)) { fa: Kind<F, (Int) -> Int> ->
       empty<Int>().ap(fa).equalUnderTheLaw(empty(), EQ)
-    })
+    }
 
   fun <F> Alternative<F>.alternativeLeftDistributivity(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), cf), genConstructor(Gen.int(), cf), genFunctionAToB<Int, Int>(Gen.int()),
-      { fa: Kind<F, Int>, fa2: Kind<F, Int>, f: (Int) -> Int ->
-        fa.combineK(fa2).map(f).equalUnderTheLaw(fa.map(f).combineK(fa2.map(f)), EQ)
-      })
+    forAll(genConstructor(Gen.int(), cf), genConstructor(Gen.int(), cf), genFunctionAToB<Int, Int>(Gen.int())
+    ) { fa: Kind<F, Int>, fa2: Kind<F, Int>, f: (Int) -> Int ->
+      fa.combineK(fa2).map(f).equalUnderTheLaw(fa.map(f).combineK(fa2.map(f)), EQ)
+    }
 
   fun <F> Alternative<F>.alternativeRightDistributivity(cf: (Int) -> Kind<F, Int>,
                                                         cff: (Int) -> Kind<F, (Int) -> Int>,
                                                         EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), cf), genConstructor2(Gen.int(), cff), genConstructor2(Gen.int(), cff),
-      { fa: Kind<F, Int>, ff: Kind<F, (Int) -> Int>, fg: Kind<F, (Int) -> Int> ->
-        fa.ap(ff.combineK(fg)).equalUnderTheLaw(fa.ap(ff).combineK(fa.ap(fg)), EQ)
-      })
+    forAll(genConstructor(Gen.int(), cf), genConstructor2(Gen.int(), cff), genConstructor2(Gen.int(), cff)
+    ) { fa: Kind<F, Int>, ff: Kind<F, (Int) -> Int>, fg: Kind<F, (Int) -> Int> ->
+      fa.ap(ff.combineK(fg)).equalUnderTheLaw(fa.ap(ff).combineK(fa.ap(fg)), EQ)
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ApplicativeErrorLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ApplicativeErrorLaws.kt
index c4fb46e1807..d7e229ba519 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ApplicativeErrorLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ApplicativeErrorLaws.kt
@@ -18,47 +18,47 @@ object ApplicativeErrorLaws {
 
   inline fun <F> laws(AE: ApplicativeError<F, Throwable>, EQERR: Eq<Kind<F, Int>>, EQ_EITHER: Eq<Kind<F, Either<Throwable, Int>>>, EQ: Eq<Kind<F, Int>> = EQERR): List<Law> =
     ApplicativeLaws.laws(AE, EQ) + listOf(
-      Law("Applicative Error Laws: handle", { AE.applicativeErrorHandle(EQERR) }),
-      Law("Applicative Error Laws: handle with for error", { AE.applicativeErrorHandleWith(EQERR) }),
-      Law("Applicative Error Laws: handle with for success", { AE.applicativeErrorHandleWithPure(EQERR) }),
-      Law("Applicative Error Laws: attempt for error", { AE.applicativeErrorAttemptError(EQ_EITHER) }),
-      Law("Applicative Error Laws: attempt for success", { AE.applicativeErrorAttemptSuccess(EQ_EITHER) }),
-      Law("Applicative Error Laws: attempt fromEither consistent with pure", { AE.applicativeErrorAttemptFromEitherConsistentWithPure(EQ_EITHER) }),
-      Law("Applicative Error Laws: catch captures errors", { AE.applicativeErrorCatch(EQERR) })
+      Law("Applicative Error Laws: handle") { AE.applicativeErrorHandle(EQERR) },
+      Law("Applicative Error Laws: handle with for error") { AE.applicativeErrorHandleWith(EQERR) },
+      Law("Applicative Error Laws: handle with for success") { AE.applicativeErrorHandleWithPure(EQERR) },
+      Law("Applicative Error Laws: attempt for error") { AE.applicativeErrorAttemptError(EQ_EITHER) },
+      Law("Applicative Error Laws: attempt for success") { AE.applicativeErrorAttemptSuccess(EQ_EITHER) },
+      Law("Applicative Error Laws: attempt fromEither consistent with pure") { AE.applicativeErrorAttemptFromEitherConsistentWithPure(EQ_EITHER) },
+      Law("Applicative Error Laws: catch captures errors") { AE.applicativeErrorCatch(EQERR) }
     )
 
   fun <F> ApplicativeError<F, Throwable>.applicativeErrorHandle(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genFunctionAToB<Throwable, Int>(Gen.int()), genThrowable(), { f: (Throwable) -> Int, e: Throwable ->
+    forAll(genFunctionAToB<Throwable, Int>(Gen.int()), genThrowable()) { f: (Throwable) -> Int, e: Throwable ->
       raiseError<Int>(e).handleError(f).equalUnderTheLaw(just(f(e)), EQ)
-    })
+    }
 
   fun <F> ApplicativeError<F, Throwable>.applicativeErrorHandleWith(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genFunctionAToB<Throwable, Kind<F, Int>>(genApplicative(Gen.int(), this)), genThrowable(), { f: (Throwable) -> Kind<F, Int>, e: Throwable ->
+    forAll(genFunctionAToB<Throwable, Kind<F, Int>>(genApplicative(Gen.int(), this)), genThrowable()) { f: (Throwable) -> Kind<F, Int>, e: Throwable ->
       raiseError<Int>(e).handleErrorWith(f).equalUnderTheLaw(f(e), EQ)
-    })
+    }
 
   fun <F> ApplicativeError<F, Throwable>.applicativeErrorHandleWithPure(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genFunctionAToB<Throwable, Kind<F, Int>>(genApplicative(Gen.int(), this)), Gen.int(), { f: (Throwable) -> Kind<F, Int>, a: Int ->
+    forAll(genFunctionAToB<Throwable, Kind<F, Int>>(genApplicative(Gen.int(), this)), Gen.int()) { f: (Throwable) -> Kind<F, Int>, a: Int ->
       just(a).handleErrorWith(f).equalUnderTheLaw(just(a), EQ)
-    })
+    }
 
   fun <F> ApplicativeError<F, Throwable>.applicativeErrorAttemptError(EQ: Eq<Kind<F, Either<Throwable, Int>>>): Unit =
-    forAll(genThrowable(), { e: Throwable ->
+    forAll(genThrowable()) { e: Throwable ->
       raiseError<Int>(e).attempt().equalUnderTheLaw(just(Left(e)), EQ)
-    })
+    }
 
   fun <F> ApplicativeError<F, Throwable>.applicativeErrorAttemptSuccess(EQ: Eq<Kind<F, Either<Throwable, Int>>>): Unit =
-    forAll(Gen.int(), { a: Int ->
+    forAll(Gen.int()) { a: Int ->
       just(a).attempt().equalUnderTheLaw(just(Right(a)), EQ)
-    })
+    }
 
   fun <F> ApplicativeError<F, Throwable>.applicativeErrorAttemptFromEitherConsistentWithPure(EQ: Eq<Kind<F, Either<Throwable, Int>>>): Unit =
-    forAll(genEither(genThrowable(), Gen.int()), { either: Either<Throwable, Int> ->
+    forAll(genEither(genThrowable(), Gen.int())) { either: Either<Throwable, Int> ->
       fromEither(either).attempt().equalUnderTheLaw(just(either), EQ)
-    })
+    }
 
   fun <F> ApplicativeError<F, Throwable>.applicativeErrorCatch(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genEither(genThrowable(), Gen.int()), { either: Either<Throwable, Int> ->
-      catch({ either.fold({ throw it }, ::identity) }).equalUnderTheLaw(either.fold({ raiseError<Int>(it) }, { just(it) }), EQ)
-    })
+    forAll(genEither(genThrowable(), Gen.int())) { either: Either<Throwable, Int> ->
+      catch { either.fold({ throw it }, ::identity) }.equalUnderTheLaw(either.fold({ raiseError<Int>(it) }, { just(it) }), EQ)
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ApplicativeLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ApplicativeLaws.kt
index 2f785906642..0309beb328f 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ApplicativeLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ApplicativeLaws.kt
@@ -13,41 +13,41 @@ object ApplicativeLaws {
 
   inline fun <F> laws(A: Applicative<F>, EQ: Eq<Kind<F, Int>>): List<Law> =
     FunctorLaws.laws(A, EQ) + listOf(
-      Law("Applicative Laws: ap identity", { A.apIdentity(EQ) }),
-      Law("Applicative Laws: homomorphism", { A.homomorphism(EQ) }),
-      Law("Applicative Laws: interchange", { A.interchange(EQ) }),
-      Law("Applicative Laws: map derived", { A.mapDerived(EQ) }),
-      Law("Applicative Laws: cartesian builder map", { A.cartesianBuilderMap(EQ) }),
-      Law("Applicative Laws: cartesian builder tupled", { A.cartesianBuilderTupled(EQ) })
+      Law("Applicative Laws: ap identity") { A.apIdentity(EQ) },
+      Law("Applicative Laws: homomorphism") { A.homomorphism(EQ) },
+      Law("Applicative Laws: interchange") { A.interchange(EQ) },
+      Law("Applicative Laws: map derived") { A.mapDerived(EQ) },
+      Law("Applicative Laws: cartesian builder map") { A.cartesianBuilderMap(EQ) },
+      Law("Applicative Laws: cartesian builder tupled") { A.cartesianBuilderTupled(EQ) }
     )
 
   fun <F> Applicative<F>.apIdentity(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genApplicative(Gen.int(), this), { fa: Kind<F, Int> ->
+    forAll(genApplicative(Gen.int(), this)) { fa: Kind<F, Int> ->
       fa.ap(just({ n: Int -> n })).equalUnderTheLaw(fa, EQ)
-    })
+    }
 
   fun <F> Applicative<F>.homomorphism(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genFunctionAToB<Int, Int>(Gen.int()), Gen.int(), { ab: (Int) -> Int, a: Int ->
+    forAll(genFunctionAToB<Int, Int>(Gen.int()), Gen.int()) { ab: (Int) -> Int, a: Int ->
       just(a).ap(just(ab)).equalUnderTheLaw(just(ab(a)), EQ)
-    })
+    }
 
   fun <F> Applicative<F>.interchange(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genApplicative(genFunctionAToB<Int, Int>(Gen.int()), this), Gen.int(), { fa: Kind<F, (Int) -> Int>, a: Int ->
+    forAll(genApplicative(genFunctionAToB<Int, Int>(Gen.int()), this), Gen.int()) { fa: Kind<F, (Int) -> Int>, a: Int ->
       just(a).ap(fa).equalUnderTheLaw(fa.ap(just({ x: (Int) -> Int -> x(a) })), EQ)
-    })
+    }
 
   fun <F> Applicative<F>.mapDerived(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genApplicative(Gen.int(), this), genFunctionAToB<Int, Int>(Gen.int()), { fa: Kind<F, Int>, f: (Int) -> Int ->
+    forAll(genApplicative(Gen.int(), this), genFunctionAToB<Int, Int>(Gen.int())) { fa: Kind<F, Int>, f: (Int) -> Int ->
       fa.map(f).equalUnderTheLaw(fa.ap(just(f)), EQ)
-    })
+    }
 
   fun <F> Applicative<F>.cartesianBuilderMap(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall(), { a: Int, b: Int, c: Int, d: Int, e: Int, f: Int ->
-      map(just(a), just(b), just(c), just(d), just(e), just(f), { (x, y, z, u, v, w) -> x + y + z - u - v - w }).equalUnderTheLaw(just(a + b + c - d - e - f), EQ)
-    })
+    forAll(genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall()) { a: Int, b: Int, c: Int, d: Int, e: Int, f: Int ->
+      map(just(a), just(b), just(c), just(d), just(e), just(f)) { (x, y, z, u, v, w) -> x + y + z - u - v - w }.equalUnderTheLaw(just(a + b + c - d - e - f), EQ)
+    }
 
   fun <F> Applicative<F>.cartesianBuilderTupled(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall(), { a: Int, b: Int, c: Int, d: Int, e: Int, f: Int ->
-      tupled(just(a), just(b), just(c), just(d), just(e), just(f)).map({ (x, y, z, u, v, w) -> x + y + z - u - v - w }).equalUnderTheLaw(just(a + b + c - d - e - f), EQ)
-    })
+    forAll(genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall(), genIntSmall()) { a: Int, b: Int, c: Int, d: Int, e: Int, f: Int ->
+      tupled(just(a), just(b), just(c), just(d), just(e), just(f)).map { (x, y, z, u, v, w) -> x + y + z - u - v - w }.equalUnderTheLaw(just(a + b + c - d - e - f), EQ)
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/AsyncLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/AsyncLaws.kt
index 7281d50a85a..21d795eec30 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/AsyncLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/AsyncLaws.kt
@@ -16,51 +16,51 @@ import kotlinx.coroutines.experimental.newSingleThreadContext
 object AsyncLaws {
   inline fun <F> laws(AC: Async<F>, EQ: Eq<Kind<F, Int>>, EQ_EITHER: Eq<Kind<F, Either<Throwable, Int>>>, EQERR: Eq<Kind<F, Int>> = EQ): List<Law> =
     MonadSuspendLaws.laws(AC, EQERR, EQ_EITHER, EQ) + listOf(
-      Law("Async Laws: success equivalence", { AC.asyncSuccess(EQ) }),
-      Law("Async Laws: error equivalence", { AC.asyncError(EQERR) }),
-      Law("Async Laws: continueOn jumps threads", { AC.continueOn(EQ) }),
-      Law("Async Laws: async constructor", { AC.asyncConstructor(EQ) }),
-      Law("Async Laws: continueOn on comprehensions", { AC.continueOnComprehension(EQ) })
+      Law("Async Laws: success equivalence") { AC.asyncSuccess(EQ) },
+      Law("Async Laws: error equivalence") { AC.asyncError(EQERR) },
+      Law("Async Laws: continueOn jumps threads") { AC.continueOn(EQ) },
+      Law("Async Laws: async constructor") { AC.asyncConstructor(EQ) },
+      Law("Async Laws: continueOn on comprehensions") { AC.continueOnComprehension(EQ) }
     )
 
   fun <F> Async<F>.asyncSuccess(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(Gen.int(), { num: Int ->
+    forAll(Gen.int()) { num: Int ->
       async { ff: (Either<Throwable, Int>) -> Unit -> ff(Right(num)) }.equalUnderTheLaw(just<Int>(num), EQ)
-    })
+    }
 
   fun <F> Async<F>.asyncError(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genThrowable(), { e: Throwable ->
+    forAll(genThrowable()) { e: Throwable ->
       async { ff: (Either<Throwable, Int>) -> Unit -> ff(Left(e)) }.equalUnderTheLaw(raiseError<Int>(e), EQ)
-    })
+    }
 
   fun <F> Async<F>.continueOn(EQ: Eq<Kind<F, Int>>): Unit =
-    forFew(5, genIntSmall(), genIntSmall(), { threadId1: Int, threadId2: Int ->
+    forFew(5, genIntSmall(), genIntSmall()) { threadId1: Int, threadId2: Int ->
       Unit.just()
         .continueOn(newSingleThreadContext(threadId1.toString()))
         .map { getCurrentThread() }
         .continueOn(newSingleThreadContext(threadId2.toString()))
         .map { it + getCurrentThread() }
         .equalUnderTheLaw(just(threadId1 + threadId2), EQ)
-    })
+    }
 
   fun <F> Async<F>.asyncConstructor(EQ: Eq<Kind<F, Int>>): Unit =
-    forFew(5, genIntSmall(), genIntSmall(), { threadId1: Int, threadId2: Int ->
+    forFew(5, genIntSmall(), genIntSmall()) { threadId1: Int, threadId2: Int ->
       invoke(newSingleThreadContext(threadId1.toString())) { getCurrentThread() }
         .flatMap {
           invoke(newSingleThreadContext(threadId2.toString())) { it + getCurrentThread() }
         }
         .equalUnderTheLaw(just(threadId1 + threadId2), EQ)
-    })
+    }
 
   fun <F> Async<F>.continueOnComprehension(EQ: Eq<Kind<F, Int>>): Unit =
-    forFew(5, genIntSmall(), genIntSmall(), { threadId1: Int, threadId2: Int ->
+    forFew(5, genIntSmall(), genIntSmall()) { threadId1: Int, threadId2: Int ->
       binding {
         continueOn(newSingleThreadContext(threadId1.toString()))
         val t1: Int = getCurrentThread()
         continueOn(newSingleThreadContext(threadId2.toString()))
         t1 + getCurrentThread()
       }.equalUnderTheLaw(just(threadId1 + threadId2), EQ)
-    })
+    }
 
   // Turns out that kotlinx.coroutines decides to rewrite thread names
   private fun getCurrentThread() =
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/BifoldableLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/BifoldableLaws.kt
index 02153b28f10..e270794a567 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/BifoldableLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/BifoldableLaws.kt
@@ -14,27 +14,27 @@ import io.kotlintest.properties.forAll
 object BifoldableLaws {
   inline fun <F> laws(BF: Bifoldable<F>, noinline cf: (Int) -> Kind2<F, Int, Int>, EQ: Eq<Int>): List<Law> =
     listOf(
-      Law("Bifoldable Laws: Left bifold consistent with BifoldMap", { BF.bifoldLeftConsistentWithBifoldMap(cf, EQ) }),
-      Law("Bifoldable Laws: Right bifold consistent with BifoldMap", { BF.bifoldRightConsistentWithBifoldMap(cf, EQ) })
+      Law("Bifoldable Laws: Left bifold consistent with BifoldMap") { BF.bifoldLeftConsistentWithBifoldMap(cf, EQ) },
+      Law("Bifoldable Laws: Right bifold consistent with BifoldMap") { BF.bifoldRightConsistentWithBifoldMap(cf, EQ) }
     )
 
   fun <F> Bifoldable<F>.bifoldLeftConsistentWithBifoldMap(cf: (Int) -> Kind2<F, Int, Int>, EQ: Eq<Int>) =
-    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf),
-      { f: (Int) -> Int, g: (Int) -> Int, fab: Kind2<F, Int, Int> ->
-        with(Int.monoid()) {
-          val expected = fab.bifoldLeft(Int.monoid().empty(), { c: Int, a: Int -> c.combine(f(a)) },
-            { c: Int, b: Int -> c.combine(g(b)) })
-          expected.equalUnderTheLaw(fab.bifoldMap(this, f, g), EQ)
-        }
-      })
+    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf)
+    ) { f: (Int) -> Int, g: (Int) -> Int, fab: Kind2<F, Int, Int> ->
+      with(Int.monoid()) {
+        val expected = fab.bifoldLeft(Int.monoid().empty(), { c: Int, a: Int -> c.combine(f(a)) },
+          { c: Int, b: Int -> c.combine(g(b)) })
+        expected.equalUnderTheLaw(fab.bifoldMap(this, f, g), EQ)
+      }
+    }
 
   fun <F> Bifoldable<F>.bifoldRightConsistentWithBifoldMap(cf: (Int) -> Kind2<F, Int, Int>, EQ: Eq<Int>) =
-    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf),
-      { f: (Int) -> Int, g: (Int) -> Int, fab: Kind2<F, Int, Int> ->
-        with(Int.monoid()) {
-          val expected = fab.bifoldRight(Eval.Later({ Int.monoid().empty() }), { a: Int, ec: Eval<Int> -> ec.map({ c -> f(a).combine(c) }) },
-            { b: Int, ec: Eval<Int> -> ec.map({ c -> g(b).combine(c) }) })
-          expected.value().equalUnderTheLaw(fab.bifoldMap(this, f, g), EQ)
-        }
-      })
+    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf)
+    ) { f: (Int) -> Int, g: (Int) -> Int, fab: Kind2<F, Int, Int> ->
+      with(Int.monoid()) {
+        val expected = fab.bifoldRight(Eval.Later { Int.monoid().empty() }, { a: Int, ec: Eval<Int> -> ec.map { c -> f(a).combine(c) } },
+          { b: Int, ec: Eval<Int> -> ec.map { c -> g(b).combine(c) } })
+        expected.value().equalUnderTheLaw(fab.bifoldMap(this, f, g), EQ)
+      }
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ComonadLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ComonadLaws.kt
index eb391c86d78..654556c6382 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ComonadLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ComonadLaws.kt
@@ -14,57 +14,57 @@ object ComonadLaws {
 
   inline fun <F> laws(CM: Comonad<F>, noinline cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): List<Law> =
     FunctorLaws.laws(CM, cf, EQ) + listOf(
-      Law("Comonad Laws: duplicate then extract is identity", { CM.duplicateThenExtractIsId(cf, EQ) }),
-      Law("Comonad Laws: duplicate then map into extract is identity", { CM.duplicateThenMapExtractIsId(cf, EQ) }),
-      Law("Comonad Laws: map and coflatmap are coherent", { CM.mapAndCoflatmapCoherence(cf, EQ) }),
-      Law("Comonad Laws: left identity", { CM.comonadLeftIdentity(cf, EQ) }),
-      Law("Comonad Laws: right identity", { CM.comonadRightIdentity(cf, EQ) }),
-      Law("Comonad Laws: cokleisli left identity", { CM.cokleisliLeftIdentity(cf, EQ) }),
-      Law("Comonad Laws: cokleisli right identity", { CM.cokleisliRightIdentity(cf, EQ) }),
-      Law("Comonad Laws: cobinding", { CM.cobinding(cf, EQ) })
+      Law("Comonad Laws: duplicate then extract is identity") { CM.duplicateThenExtractIsId(cf, EQ) },
+      Law("Comonad Laws: duplicate then map into extract is identity") { CM.duplicateThenMapExtractIsId(cf, EQ) },
+      Law("Comonad Laws: map and coflatmap are coherent") { CM.mapAndCoflatmapCoherence(cf, EQ) },
+      Law("Comonad Laws: left identity") { CM.comonadLeftIdentity(cf, EQ) },
+      Law("Comonad Laws: right identity") { CM.comonadRightIdentity(cf, EQ) },
+      Law("Comonad Laws: cokleisli left identity") { CM.cokleisliLeftIdentity(cf, EQ) },
+      Law("Comonad Laws: cokleisli right identity") { CM.cokleisliRightIdentity(cf, EQ) },
+      Law("Comonad Laws: cobinding") { CM.cobinding(cf, EQ) }
     )
 
   fun <F> Comonad<F>.duplicateThenExtractIsId(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), cf), { fa: Kind<F, Int> ->
+    forAll(genConstructor(Gen.int(), cf)) { fa: Kind<F, Int> ->
       fa.duplicate().extract().equalUnderTheLaw(fa, EQ)
-    })
+    }
 
   fun <F> Comonad<F>.duplicateThenMapExtractIsId(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), cf), { fa: Kind<F, Int> ->
+    forAll(genConstructor(Gen.int(), cf)) { fa: Kind<F, Int> ->
       fa.duplicate().map() { it.extract() }.equalUnderTheLaw(fa, EQ)
-    })
+    }
 
   fun <F> Comonad<F>.mapAndCoflatmapCoherence(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), cf), genFunctionAToB(Gen.int()), { fa: Kind<F, Int>, f: (Int) -> Int ->
-      fa.map(f).equalUnderTheLaw(fa.coflatMap({ f(it.extract()) }), EQ)
-    })
+    forAll(genConstructor(Gen.int(), cf), genFunctionAToB(Gen.int())) { fa: Kind<F, Int>, f: (Int) -> Int ->
+      fa.map(f).equalUnderTheLaw(fa.coflatMap { f(it.extract()) }, EQ)
+    }
 
   fun <F> Comonad<F>.comonadLeftIdentity(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), cf), { fa: Kind<F, Int> ->
-      fa.coflatMap({ it.extract() }).equalUnderTheLaw(fa, EQ)
-    })
+    forAll(genConstructor(Gen.int(), cf)) { fa: Kind<F, Int> ->
+      fa.coflatMap { it.extract() }.equalUnderTheLaw(fa, EQ)
+    }
 
   fun <F> Comonad<F>.comonadRightIdentity(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), cf), genFunctionAToB(genConstructor(Gen.int(), cf)), { fa: Kind<F, Int>, f: (Kind<F, Int>) -> Kind<F, Int> ->
+    forAll(genConstructor(Gen.int(), cf), genFunctionAToB(genConstructor(Gen.int(), cf))) { fa: Kind<F, Int>, f: (Kind<F, Int>) -> Kind<F, Int> ->
       fa.coflatMap(f).extract().equalUnderTheLaw(f(fa), EQ)
-    })
+    }
 
   fun <F> Comonad<F>.cokleisliLeftIdentity(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), cf), genFunctionAToB(genConstructor(Gen.int(), cf)), { fa: Kind<F, Int>, f: (Kind<F, Int>) -> Kind<F, Int> ->
-      Cokleisli(this, { hk: Kind<F, Int> -> hk.extract() }).andThen(Cokleisli(this, f)).run(fa).equalUnderTheLaw(f(fa), EQ)
-    })
+    forAll(genConstructor(Gen.int(), cf), genFunctionAToB(genConstructor(Gen.int(), cf))) { fa: Kind<F, Int>, f: (Kind<F, Int>) -> Kind<F, Int> ->
+      Cokleisli(this) { hk: Kind<F, Int> -> hk.extract() }.andThen(Cokleisli(this, f)).run(fa).equalUnderTheLaw(f(fa), EQ)
+    }
 
   fun <F> Comonad<F>.cokleisliRightIdentity(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), cf), genFunctionAToB(genConstructor(Gen.int(), cf)), { fa: Kind<F, Int>, f: (Kind<F, Int>) -> Kind<F, Int> ->
-      Cokleisli(this, f).andThen(Cokleisli(this, { hk: Kind<F, Kind<F, Int>> -> hk.extract() })).run(fa).equalUnderTheLaw(f(fa), EQ)
-    })
+    forAll(genConstructor(Gen.int(), cf), genFunctionAToB(genConstructor(Gen.int(), cf))) { fa: Kind<F, Int>, f: (Kind<F, Int>) -> Kind<F, Int> ->
+      Cokleisli(this, f).andThen(Cokleisli(this) { hk: Kind<F, Kind<F, Int>> -> hk.extract() }).run(fa).equalUnderTheLaw(f(fa), EQ)
+    }
 
   fun <F> Comonad<F>.cobinding(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), cf), { fa: Kind<F, Int> ->
+    forAll(genConstructor(Gen.int(), cf)) { fa: Kind<F, Int> ->
       cobinding {
         val x = fa.extract()
-        val y = extract { fa.map({ it + x }) }
-        fa.map({ x + y })
-      }.equalUnderTheLaw(fa.map({ it * 3 }), EQ)
-    })
+        val y = extract { fa.map { it + x } }
+        fa.map { x + y }
+      }.equalUnderTheLaw(fa.map { it * 3 }, EQ)
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/EqLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/EqLaws.kt
index 9a9d219f644..d567cd7b03c 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/EqLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/EqLaws.kt
@@ -8,20 +8,20 @@ object EqLaws {
 
   inline fun <F> laws(EQ: Eq<F>, noinline cf: (Int) -> F): List<Law> =
     listOf(
-      Law("Eq Laws: identity", { EQ.identityEquality(cf) }),
-      Law("Eq Laws: commutativity", { EQ.commutativeEquality(cf) })
+      Law("Eq Laws: identity") { EQ.identityEquality(cf) },
+      Law("Eq Laws: commutativity") { EQ.commutativeEquality(cf) }
     )
 
   fun <F> Eq<F>.identityEquality(cf: (Int) -> F): Unit =
-    forAll(Gen.int(), { int: Int ->
+    forAll(Gen.int()) { int: Int ->
       val a = cf(int)
       a.eqv(a) == a.eqv(a)
-    })
+    }
 
   fun <F> Eq<F>.commutativeEquality(cf: (Int) -> F): Unit =
-    forAll(Gen.int(), { int: Int ->
+    forAll(Gen.int()) { int: Int ->
       val a = cf(int)
       val b = cf(int)
       a.eqv(b) == b.eqv(a)
-    })
+    }
 }
\ No newline at end of file
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FoldableLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FoldableLaws.kt
index 866d3f046dd..9442195e4d7 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FoldableLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FoldableLaws.kt
@@ -19,37 +19,37 @@ import io.kotlintest.properties.forAll
 object FoldableLaws {
   inline fun <F> laws(FF: Foldable<F>, noinline cf: (Int) -> Kind<F, Int>, EQ: Eq<Int>): List<Law> =
     listOf(
-      Law("Foldable Laws: Left fold consistent with foldMap", { FF.leftFoldConsistentWithFoldMap(cf, EQ) }),
-      Law("Foldable Laws: Right fold consistent with foldMap", { FF.rightFoldConsistentWithFoldMap(cf, EQ) }),
-      Law("Foldable Laws: Exists is consistent with find", { FF.existsConsistentWithFind(cf) }),
-      Law("Foldable Laws: Exists is lazy", { FF.existsIsLazy(cf, EQ) }),
-      Law("Foldable Laws: ForAll is lazy", { FF.forAllIsLazy(cf, EQ) }),
-      Law("Foldable Laws: ForAll consistent with exists", { FF.forallConsistentWithExists(cf) }),
-      Law("Foldable Laws: ForAll returns true if isEmpty", { FF.forallReturnsTrueIfEmpty(cf) }),
-      Law("Foldable Laws: FoldM for Id is equivalent to fold left", { FF.foldMIdIsFoldL(cf, EQ) })
+      Law("Foldable Laws: Left fold consistent with foldMap") { FF.leftFoldConsistentWithFoldMap(cf, EQ) },
+      Law("Foldable Laws: Right fold consistent with foldMap") { FF.rightFoldConsistentWithFoldMap(cf, EQ) },
+      Law("Foldable Laws: Exists is consistent with find") { FF.existsConsistentWithFind(cf) },
+      Law("Foldable Laws: Exists is lazy") { FF.existsIsLazy(cf, EQ) },
+      Law("Foldable Laws: ForAll is lazy") { FF.forAllIsLazy(cf, EQ) },
+      Law("Foldable Laws: ForAll consistent with exists") { FF.forallConsistentWithExists(cf) },
+      Law("Foldable Laws: ForAll returns true if isEmpty") { FF.forallReturnsTrueIfEmpty(cf) },
+      Law("Foldable Laws: FoldM for Id is equivalent to fold left") { FF.foldMIdIsFoldL(cf, EQ) }
     )
 
   fun <F> Foldable<F>.leftFoldConsistentWithFoldMap(cf: (Int) -> Kind<F, Int>, EQ: Eq<Int>) =
-    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf), { f: (Int) -> Int, fa: Kind<F, Int> ->
+    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf)) { f: (Int) -> Int, fa: Kind<F, Int> ->
       with(Int.monoid()) {
-        fa.foldMap(this, f).equalUnderTheLaw(fa.foldLeft(empty(), { acc, a -> acc.combine(f(a)) }), EQ)
+        fa.foldMap(this, f).equalUnderTheLaw(fa.foldLeft(empty()) { acc, a -> acc.combine(f(a)) }, EQ)
       }
-    })
+    }
 
   fun <F> Foldable<F>.rightFoldConsistentWithFoldMap(cf: (Int) -> Kind<F, Int>, EQ: Eq<Int>) =
-    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf), { f: (Int) -> Int, fa: Kind<F, Int> ->
+    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf)) { f: (Int) -> Int, fa: Kind<F, Int> ->
       with(Int.monoid()) {
-        fa.foldMap(this, f).equalUnderTheLaw(fa.foldRight(Eval.later { empty() }, { a, lb: Eval<Int> -> lb.map { f(a).combine(it) } }).value(), EQ)
+        fa.foldMap(this, f).equalUnderTheLaw(fa.foldRight(Eval.later { empty() }) { a, lb: Eval<Int> -> lb.map { f(a).combine(it) } }.value(), EQ)
       }
-    })
+    }
 
   fun <F> Foldable<F>.existsConsistentWithFind(cf: (Int) -> Kind<F, Int>) =
-    forAll(genIntPredicate(), genConstructor(Gen.int(), cf), { f: (Int) -> Boolean, fa: Kind<F, Int> ->
+    forAll(genIntPredicate(), genConstructor(Gen.int(), cf)) { f: (Int) -> Boolean, fa: Kind<F, Int> ->
       fa.exists(f).equalUnderTheLaw(fa.find(f).fold({ false }, { true }), Eq.any())
-    })
+    }
 
   fun <F> Foldable<F>.existsIsLazy(cf: (Int) -> Kind<F, Int>, EQ: Eq<Int>) =
-    forAll(genConstructor(Gen.int(), cf), { fa: Kind<F, Int> ->
+    forAll(genConstructor(Gen.int(), cf)) { fa: Kind<F, Int> ->
       val sideEffect = SideEffect()
       fa.exists { _ ->
         sideEffect.increment()
@@ -57,10 +57,10 @@ object FoldableLaws {
       }
       val expected = if (fa.isEmpty()) 0 else 1
       sideEffect.counter.equalUnderTheLaw(expected, EQ)
-    })
+    }
 
   fun <F> Foldable<F>.forAllIsLazy(cf: (Int) -> Kind<F, Int>, EQ: Eq<Int>) =
-    forAll(genConstructor(Gen.int(), cf), { fa: Kind<F, Int> ->
+    forAll(genConstructor(Gen.int(), cf)) { fa: Kind<F, Int> ->
       val sideEffect = SideEffect()
       fa.forAll { _ ->
         sideEffect.increment()
@@ -68,10 +68,10 @@ object FoldableLaws {
       }
       val expected = if (fa.isEmpty()) 0 else 1
       sideEffect.counter.equalUnderTheLaw(expected, EQ)
-    })
+    }
 
   fun <F> Foldable<F>.forallConsistentWithExists(cf: (Int) -> Kind<F, Int>) =
-    forAll(genIntPredicate(), genConstructor(Gen.int(), cf), { f: (Int) -> Boolean, fa: Kind<F, Int> ->
+    forAll(genIntPredicate(), genConstructor(Gen.int(), cf)) { f: (Int) -> Boolean, fa: Kind<F, Int> ->
       if (fa.forAll(f)) {
         val negationExists = fa.exists { a -> !(f(a)) }
         // if p is true for all elements, then there cannot be an element for which
@@ -81,19 +81,19 @@ object FoldableLaws {
           // or there must exist an element for which it is true.
           (fa.isEmpty() || fa.exists(f))
       } else true
-    })
+    }
 
   fun <F> Foldable<F>.forallReturnsTrueIfEmpty(cf: (Int) -> Kind<F, Int>) =
-    forAll(genIntPredicate(), genConstructor(Gen.int(), cf), { f: (Int) -> Boolean, fa: Kind<F, Int> ->
+    forAll(genIntPredicate(), genConstructor(Gen.int(), cf)) { f: (Int) -> Boolean, fa: Kind<F, Int> ->
       !fa.isEmpty() || fa.forAll(f)
-    })
+    }
 
   fun <F> Foldable<F>.foldMIdIsFoldL(cf: (Int) -> Kind<F, Int>, EQ: Eq<Int>) =
-    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf), { f: (Int) -> Int, fa: Kind<F, Int> ->
+    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf)) { f: (Int) -> Int, fa: Kind<F, Int> ->
       with(Int.monoid()) {
-        val foldL: Int = fa.foldLeft(empty(), { acc, a -> acc.combine(f(a)) })
-        val foldM: Int = fa.foldM(Id.monad(), empty(), { acc, a -> Id(acc.combine(f(a))) }).value()
+        val foldL: Int = fa.foldLeft(empty()) { acc, a -> acc.combine(f(a)) }
+        val foldM: Int = fa.foldM(Id.monad(), empty()) { acc, a -> Id(acc.combine(f(a))) }.value()
         foldM.equalUnderTheLaw(foldL, EQ)
       }
-    })
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FunctorFilterLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FunctorFilterLaws.kt
index b0f9bf3600f..0c3be10bf61 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FunctorFilterLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FunctorFilterLaws.kt
@@ -16,24 +16,24 @@ object FunctorFilterLaws {
 
   inline fun <F> laws(FFF: FunctorFilter<F>, noinline cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): List<Law> =
     FunctorLaws.laws(FFF, cf, EQ) + listOf(
-      Law("Functor Filter: mapFilter composition", { FFF.mapFilterComposition(cf, EQ) }),
-      Law("Functor Filter: mapFilter map consistency", { FFF.mapFilterMapConsistency(cf, EQ) })
+      Law("Functor Filter: mapFilter composition") { FFF.mapFilterComposition(cf, EQ) },
+      Law("Functor Filter: mapFilter map consistency") { FFF.mapFilterMapConsistency(cf, EQ) }
     )
 
   fun <F> FunctorFilter<F>.mapFilterComposition(ff: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
     forAll(
       genConstructor(Gen.int(), ff),
       genFunctionAToB<Int, Option<Int>>(genOption(genIntSmall())),
-      genFunctionAToB<Int, Option<Int>>(genOption(genIntSmall())),
-      { fa: Kind<F, Int>, f, g ->
-        fa.mapFilter(f).mapFilter(g).equalUnderTheLaw(fa.mapFilter({ a -> f(a).flatMap(g) }), EQ)
-      })
+      genFunctionAToB<Int, Option<Int>>(genOption(genIntSmall()))
+    ) { fa: Kind<F, Int>, f, g ->
+      fa.mapFilter(f).mapFilter(g).equalUnderTheLaw(fa.mapFilter { a -> f(a).flatMap(g) }, EQ)
+    }
 
   fun <F> FunctorFilter<F>.mapFilterMapConsistency(ff: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
     forAll(
       genConstructor(Gen.int(), ff),
-      genFunctionAToB<Int, Int>(Gen.int()),
-      { fa: Kind<F, Int>, f ->
-        fa.mapFilter({ Some(f(it)) }).equalUnderTheLaw(fa.map(f), EQ)
-      })
+      genFunctionAToB<Int, Int>(Gen.int())
+    ) { fa: Kind<F, Int>, f ->
+      fa.mapFilter { Some(f(it)) }.equalUnderTheLaw(fa.map(f), EQ)
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FunctorLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FunctorLaws.kt
index 7fe70cc4f28..ff1bb6f63e9 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FunctorLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/FunctorLaws.kt
@@ -15,28 +15,27 @@ object FunctorLaws {
 
   inline fun <F> laws(AP: Applicative<F>, EQ: Eq<Kind<F, Int>>): List<Law> =
     listOf(
-      Law("Functor Laws: Covariant Identity", { AP.covariantIdentity(AP::just, EQ) }),
-      Law("Functor Laws: Covariant Composition", { AP.covariantComposition(AP::just, EQ) })
+      Law("Functor Laws: Covariant Identity") { AP.covariantIdentity(AP::just, EQ) },
+      Law("Functor Laws: Covariant Composition") { AP.covariantComposition(AP::just, EQ) }
     )
 
   fun <F> laws(FF: Functor<F>, f: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): List<Law> =
     listOf(
-      Law("Functor Laws: Covariant Identity", { FF.covariantIdentity(f, EQ) }),
-      Law("Functor Laws: Covariant Composition", { FF.covariantComposition(f, EQ) })
+      Law("Functor Laws: Covariant Identity") { FF.covariantIdentity(f, EQ) },
+      Law("Functor Laws: Covariant Composition") { FF.covariantComposition(f, EQ) }
     )
 
   fun <F> Functor<F>.covariantIdentity(f: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), f), { fa: Kind<F, Int> ->
+    forAll(genConstructor(Gen.int(), f)) { fa: Kind<F, Int> ->
       fa.map(::identity).equalUnderTheLaw(fa, EQ)
-    })
+    }
 
   fun <F> Functor<F>.covariantComposition(ff: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
     forAll(
       genConstructor(Gen.int(), ff),
       genFunctionAToB<Int, Int>(Gen.int()),
-      genFunctionAToB<Int, Int>(Gen.int()),
-      { fa: Kind<F, Int>, f, g ->
-        fa.map(f).map(g).equalUnderTheLaw(fa.map(f andThen g), EQ)
-      }
-    )
+      genFunctionAToB<Int, Int>(Gen.int())
+    ) { fa: Kind<F, Int>, f, g ->
+      fa.map(f).map(g).equalUnderTheLaw(fa.map(f andThen g), EQ)
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/IsoLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/IsoLaws.kt
index c2beb339ea3..69a51168bc6 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/IsoLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/IsoLaws.kt
@@ -10,47 +10,47 @@ object IsoLaws {
 
   inline fun <A, B> laws(iso: Iso<A, B>, aGen: Gen<A>, bGen: Gen<B>, funcGen: Gen<(B) -> B>, EQA: Eq<A>, EQB: Eq<B>, bMonoid: Monoid<B>): List<Law> =
     listOf(
-      Law("Iso Law: round trip one way", { iso.roundTripOneWay(aGen, EQA) }),
-      Law("Iso Law: round trip other way", { iso.roundTripOtherWay(bGen, EQB) }),
-      Law("Iso Law: modify identity is identity", { iso.modifyIdentity(aGen, EQA) }),
-      Law("Iso Law: compose modify", { iso.composeModify(aGen, funcGen, EQA) }),
-      Law("Iso Law: consitent set with modify", { iso.consistentSetModify(aGen, bGen, EQA) }),
-      Law("Iso Law: consistent modify with modify identity", { iso.consistentModifyModifyId(aGen, funcGen, EQA) }),
-      Law("Iso Law: consitent get with modify identity", { iso.consitentGetModifyId(aGen, EQB, bMonoid) })
+      Law("Iso Law: round trip one way") { iso.roundTripOneWay(aGen, EQA) },
+      Law("Iso Law: round trip other way") { iso.roundTripOtherWay(bGen, EQB) },
+      Law("Iso Law: modify identity is identity") { iso.modifyIdentity(aGen, EQA) },
+      Law("Iso Law: compose modify") { iso.composeModify(aGen, funcGen, EQA) },
+      Law("Iso Law: consitent set with modify") { iso.consistentSetModify(aGen, bGen, EQA) },
+      Law("Iso Law: consistent modify with modify identity") { iso.consistentModifyModifyId(aGen, funcGen, EQA) },
+      Law("Iso Law: consitent get with modify identity") { iso.consitentGetModifyId(aGen, EQB, bMonoid) }
     )
 
   fun <A, B> Iso<A, B>.roundTripOneWay(aGen: Gen<A>, EQA: Eq<A>): Unit =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       reverseGet(get(a)).equalUnderTheLaw(a, EQA)
-    })
+    }
 
   fun <A, B> Iso<A, B>.roundTripOtherWay(bGen: Gen<B>, EQB: Eq<B>): Unit =
-    forAll(bGen, { b ->
+    forAll(bGen) { b ->
       get(reverseGet(b)).equalUnderTheLaw(b, EQB)
-    })
+    }
 
   fun <A, B> Iso<A, B>.modifyIdentity(aGen: Gen<A>, EQA: Eq<A>): Unit =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       modify(a, ::identity).equalUnderTheLaw(a, EQA)
-    })
+    }
 
   fun <A, B> Iso<A, B>.composeModify(aGen: Gen<A>, funcGen: Gen<(B) -> B>, EQA: Eq<A>): Unit =
-    forAll(aGen, funcGen, funcGen, { a, f, g ->
+    forAll(aGen, funcGen, funcGen) { a, f, g ->
       modify(modify(a, f), g).equalUnderTheLaw(modify(a, g compose f), EQA)
-    })
+    }
 
   fun <A, B> Iso<A, B>.consistentSetModify(aGen: Gen<A>, bGen: Gen<B>, EQA: Eq<A>): Unit =
-    forAll(aGen, bGen, { a, b ->
+    forAll(aGen, bGen) { a, b ->
       set(b).equalUnderTheLaw(modify(a) { b }, EQA)
-    })
+    }
 
   fun <A, B> Iso<A, B>.consistentModifyModifyId(aGen: Gen<A>, funcGen: Gen<(B) -> B>, EQA: Eq<A>): Unit =
-    forAll(aGen, funcGen, { a, f ->
-      modify(a, f).equalUnderTheLaw(modifyF(Id.functor(), a, { Id.just(f(it)) }).value(), EQA)
-    })
+    forAll(aGen, funcGen) { a, f ->
+      modify(a, f).equalUnderTheLaw(modifyF(Id.functor(), a) { Id.just(f(it)) }.value(), EQA)
+    }
 
   fun <A, B> Iso<A, B>.consitentGetModifyId(aGen: Gen<A>, EQB: Eq<B>, bMonoid: Monoid<B>): Unit =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       get(a).equalUnderTheLaw(modifyF(Const.applicative(bMonoid), a, ::Const).value(), EQB)
-    })
+    }
 }
\ No newline at end of file
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/LensLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/LensLaws.kt
index cfdb269af8e..f1c6f3d3c62 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/LensLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/LensLaws.kt
@@ -10,56 +10,56 @@ object LensLaws {
 
   inline fun <A, B> laws(lens: Lens<A, B>, aGen: Gen<A>, bGen: Gen<B>, funcGen: Gen<(B) -> B>, EQA: Eq<A>, EQB: Eq<B>, MB: Monoid<B>) =
     listOf(
-      Law("Lens law: get set", { lens.lensGetSet(aGen, EQA) }),
-      Law("Lens law: set get", { lens.lensSetGet(aGen, bGen, EQB) }),
-      Law("Lens law: is set idempotent", { lens.lensSetIdempotent(aGen, bGen, EQA) }),
-      Law("Lens law: modify identity", { lens.lensModifyIdentity(aGen, EQA) }),
-      Law("Lens law: compose modify", { lens.lensComposeModify(aGen, funcGen, EQA) }),
-      Law("Lens law: consistent set modify", { lens.lensConsistentSetModify(aGen, bGen, EQA) }),
-      Law("Lens law: consistent modify modify id", { lens.lensConsistentModifyModifyId(aGen, funcGen, EQA) }),
-      Law("Lens law: consistent get modify id", { lens.lensConsistentGetModifyid(aGen, EQB, MB) })
+      Law("Lens law: get set") { lens.lensGetSet(aGen, EQA) },
+      Law("Lens law: set get") { lens.lensSetGet(aGen, bGen, EQB) },
+      Law("Lens law: is set idempotent") { lens.lensSetIdempotent(aGen, bGen, EQA) },
+      Law("Lens law: modify identity") { lens.lensModifyIdentity(aGen, EQA) },
+      Law("Lens law: compose modify") { lens.lensComposeModify(aGen, funcGen, EQA) },
+      Law("Lens law: consistent set modify") { lens.lensConsistentSetModify(aGen, bGen, EQA) },
+      Law("Lens law: consistent modify modify id") { lens.lensConsistentModifyModifyId(aGen, funcGen, EQA) },
+      Law("Lens law: consistent get modify id") { lens.lensConsistentGetModifyid(aGen, EQB, MB) }
     )
 
   fun <A, B> Lens<A, B>.lensGetSet(aGen: Gen<A>, EQA: Eq<A>) =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       set(a, get(a)).equalUnderTheLaw(a, EQA)
-    })
+    }
 
   fun <A, B> Lens<A, B>.lensSetGet(aGen: Gen<A>, bGen: Gen<B>, EQB: Eq<B>) =
-    forAll(aGen, bGen, { a, b ->
+    forAll(aGen, bGen) { a, b ->
       get(set(a, b)).equalUnderTheLaw(b, EQB)
-    })
+    }
 
   fun <A, B> Lens<A, B>.lensSetIdempotent(aGen: Gen<A>, bGen: Gen<B>, EQA: Eq<A>) =
-    forAll(aGen, bGen, { a, b ->
+    forAll(aGen, bGen) { a, b ->
       set(set(a, b), b).equalUnderTheLaw(set(a, b), EQA)
-    })
+    }
 
   fun <A, B> Lens<A, B>.lensModifyIdentity(aGen: Gen<A>, EQA: Eq<A>) =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       modify(a, ::identity).equalUnderTheLaw(a, EQA)
-    })
+    }
 
   fun <A, B> Lens<A, B>.lensComposeModify(aGen: Gen<A>, funcGen: Gen<(B) -> B>, EQA: Eq<A>) =
-    forAll(aGen, funcGen, funcGen, { a, f, g ->
+    forAll(aGen, funcGen, funcGen) { a, f, g ->
       modify(modify(a, f), g).equalUnderTheLaw(modify(a, g compose f), EQA)
-    })
+    }
 
   fun <A, B> Lens<A, B>.lensConsistentSetModify(aGen: Gen<A>, bGen: Gen<B>, EQA: Eq<A>) =
-    forAll(aGen, bGen, { a, b ->
+    forAll(aGen, bGen) { a, b ->
       set(a, b).equalUnderTheLaw(modify(a) { b }, EQA)
-    })
+    }
 
   fun <A, B> Lens<A, B>.lensConsistentModifyModifyId(aGen: Gen<A>, funcGen: Gen<(B) -> B>, EQA: Eq<A>) =
-    forAll(aGen, funcGen, { a, f ->
+    forAll(aGen, funcGen) { a, f ->
       modify(a, f)
-        .equalUnderTheLaw(modifyF(Id.functor(), a, { Id.just(f(it)) }).value(), EQA)
-    })
+        .equalUnderTheLaw(modifyF(Id.functor(), a) { Id.just(f(it)) }.value(), EQA)
+    }
 
   fun <A, B> Lens<A, B>.lensConsistentGetModifyid(aGen: Gen<A>, EQB: Eq<B>, MA: Monoid<B>) =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       get(a)
         .equalUnderTheLaw(modifyF(Const.applicative(MA), a, ::Const).value(), EQB)
-    })
+    }
 
 }
\ No newline at end of file
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadErrorLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadErrorLaws.kt
index 418c6a191ea..8c6184301fb 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadErrorLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadErrorLaws.kt
@@ -14,17 +14,17 @@ object MonadErrorLaws {
 
   inline fun <F> laws(M: MonadError<F, Throwable>, EQERR: Eq<Kind<F, Int>>, EQ_EITHER: Eq<Kind<F, Either<Throwable, Int>>>, EQ: Eq<Kind<F, Int>> = EQERR): List<Law> =
     MonadLaws.laws(M, EQ) + ApplicativeErrorLaws.laws(M, EQERR, EQ_EITHER, EQ) + listOf(
-      Law("Monad Error Laws: left zero", { M.monadErrorLeftZero(EQERR) }),
-      Law("Monad Error Laws: ensure consistency", { M.monadErrorEnsureConsistency(EQERR) })
+      Law("Monad Error Laws: left zero") { M.monadErrorLeftZero(EQERR) },
+      Law("Monad Error Laws: ensure consistency") { M.monadErrorEnsureConsistency(EQERR) }
     )
 
   fun <F> MonadError<F, Throwable>.monadErrorLeftZero(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genFunctionAToB<Int, Kind<F, Int>>(genApplicative(Gen.int(), this)), genThrowable(), { f: (Int) -> Kind<F, Int>, e: Throwable ->
+    forAll(genFunctionAToB<Int, Kind<F, Int>>(genApplicative(Gen.int(), this)), genThrowable()) { f: (Int) -> Kind<F, Int>, e: Throwable ->
       raiseError<Int>(e).flatMap(f).equalUnderTheLaw(raiseError<Int>(e), EQ)
-    })
+    }
 
   fun <F> MonadError<F, Throwable>.monadErrorEnsureConsistency(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genApplicative(Gen.int(), this), genThrowable(), genFunctionAToB<Int, Boolean>(Gen.bool()), { fa: Kind<F, Int>, e: Throwable, p: (Int) -> Boolean ->
-      fa.ensure({ e }, p).equalUnderTheLaw(fa.flatMap({ a -> if (p(a)) just(a) else raiseError(e) }), EQ)
-    })
+    forAll(genApplicative(Gen.int(), this), genThrowable(), genFunctionAToB<Int, Boolean>(Gen.bool())) { fa: Kind<F, Int>, e: Throwable, p: (Int) -> Boolean ->
+      fa.ensure({ e }, p).equalUnderTheLaw(fa.flatMap { a -> if (p(a)) just(a) else raiseError(e) }, EQ)
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadFilterLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadFilterLaws.kt
index 5148fbec885..60252c33a47 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadFilterLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadFilterLaws.kt
@@ -14,41 +14,41 @@ object MonadFilterLaws {
 
   inline fun <F> laws(MF: MonadFilter<F>, noinline cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): List<Law> =
     MonadLaws.laws(MF, EQ) + FunctorFilterLaws.laws(MF, cf, EQ) + listOf(
-      Law("MonadFilter Laws: Left Empty", { MF.monadFilterLeftEmpty(EQ) }),
-      Law("MonadFilter Laws: Right Empty", { MF.monadFilterRightEmpty(EQ) }),
-      Law("MonadFilter Laws: Consistency", { MF.monadFilterConsistency(cf, EQ) }),
-      Law("MonadFilter Laws: Comprehension Guards", { MF.monadFilterEmptyComprehensions(EQ) }),
-      Law("MonadFilter Laws: Comprehension bindWithFilter Guards", { MF.monadFilterBindWithFilterComprehensions(EQ) }))
+      Law("MonadFilter Laws: Left Empty") { MF.monadFilterLeftEmpty(EQ) },
+      Law("MonadFilter Laws: Right Empty") { MF.monadFilterRightEmpty(EQ) },
+      Law("MonadFilter Laws: Consistency") { MF.monadFilterConsistency(cf, EQ) },
+      Law("MonadFilter Laws: Comprehension Guards") { MF.monadFilterEmptyComprehensions(EQ) },
+      Law("MonadFilter Laws: Comprehension bindWithFilter Guards") { MF.monadFilterBindWithFilterComprehensions(EQ) })
 
   fun <F> MonadFilter<F>.monadFilterLeftEmpty(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genFunctionAToB(genApplicative(Gen.int(), this)), { f: (Int) -> Kind<F, Int> ->
+    forAll(genFunctionAToB(genApplicative(Gen.int(), this))) { f: (Int) -> Kind<F, Int> ->
       empty<Int>().flatMap(f).equalUnderTheLaw(empty(), EQ)
-    })
+    }
 
   fun <F> MonadFilter<F>.monadFilterRightEmpty(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genApplicative(Gen.int(), this), { fa: Kind<F, Int> ->
-      fa.flatMap({ empty<Int>() }).equalUnderTheLaw(empty(), EQ)
-    })
+    forAll(genApplicative(Gen.int(), this)) { fa: Kind<F, Int> ->
+      fa.flatMap { empty<Int>() }.equalUnderTheLaw(empty(), EQ)
+    }
 
   fun <F> MonadFilter<F>.monadFilterConsistency(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genFunctionAToB(Gen.bool()), genConstructor(Gen.int(), cf), { f: (Int) -> Boolean, fa: Kind<F, Int> ->
-      fa.filter(f).equalUnderTheLaw(fa.flatMap({ a -> if (f(a)) just(a) else empty() }), EQ)
-    })
+    forAll(genFunctionAToB(Gen.bool()), genConstructor(Gen.int(), cf)) { f: (Int) -> Boolean, fa: Kind<F, Int> ->
+      fa.filter(f).equalUnderTheLaw(fa.flatMap { a -> if (f(a)) just(a) else empty() }, EQ)
+    }
 
   fun <F> MonadFilter<F>.monadFilterEmptyComprehensions(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(Gen.bool(), Gen.int(), { guard: Boolean, n: Int ->
+    forAll(Gen.bool(), Gen.int()) { guard: Boolean, n: Int ->
       bindingFilter {
         continueIf(guard)
         n
       }.equalUnderTheLaw(if (!guard) empty() else just(n), EQ)
-    })
+    }
 
   fun <F> MonadFilter<F>.monadFilterBindWithFilterComprehensions(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(Gen.bool(), Gen.int(), { guard: Boolean, n: Int ->
+    forAll(Gen.bool(), Gen.int()) { guard: Boolean, n: Int ->
       bindingFilter {
         val x = just(n).bindWithFilter { _ -> guard }
         x
       }.equalUnderTheLaw(if (!guard) empty() else just(n), EQ)
-    })
+    }
 
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadLaws.kt
index abd102665eb..6a890afec59 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadLaws.kt
@@ -21,46 +21,46 @@ object MonadLaws {
 
   inline fun <F> laws(M: Monad<F>, EQ: Eq<Kind<F, Int>>): List<Law> =
     ApplicativeLaws.laws(M, EQ) + listOf(
-      Law("Monad Laws: left identity", { M.leftIdentity(EQ) }),
-      Law("Monad Laws: right identity", { M.rightIdentity(EQ) }),
-      Law("Monad Laws: kleisli left identity", { M.kleisliLeftIdentity(EQ) }),
-      Law("Monad Laws: kleisli right identity", { M.kleisliRightIdentity(EQ) }),
-      Law("Monad Laws: map / flatMap coherence", { M.mapFlatMapCoherence(EQ) }),
-      Law("Monad Laws: monad comprehensions", { M.monadComprehensions(EQ) }),
-      Law("Monad Laws: monad comprehensions binding in other threads", { M.monadComprehensionsBindInContext(EQ) }),
-      Law("Monad Laws: stack-safe//unsafe monad comprehensions equivalence", { M.equivalentComprehensions(EQ) }),
-      Law("Monad Laws: stack safe", { M.stackSafety(5000, EQ) }),
-      Law("Monad Laws: stack safe comprehensions", { M.stackSafetyComprehensions(5000, EQ) })
+      Law("Monad Laws: left identity") { M.leftIdentity(EQ) },
+      Law("Monad Laws: right identity") { M.rightIdentity(EQ) },
+      Law("Monad Laws: kleisli left identity") { M.kleisliLeftIdentity(EQ) },
+      Law("Monad Laws: kleisli right identity") { M.kleisliRightIdentity(EQ) },
+      Law("Monad Laws: map / flatMap coherence") { M.mapFlatMapCoherence(EQ) },
+      Law("Monad Laws: monad comprehensions") { M.monadComprehensions(EQ) },
+      Law("Monad Laws: monad comprehensions binding in other threads") { M.monadComprehensionsBindInContext(EQ) },
+      Law("Monad Laws: stack-safe//unsafe monad comprehensions equivalence") { M.equivalentComprehensions(EQ) },
+      Law("Monad Laws: stack safe") { M.stackSafety(5000, EQ) },
+      Law("Monad Laws: stack safe comprehensions") { M.stackSafetyComprehensions(5000, EQ) }
     )
 
   fun <F> Monad<F>.leftIdentity(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genFunctionAToB<Int, Kind<F, Int>>(genApplicative(Gen.int(), this)), Gen.int(), { f: (Int) -> Kind<F, Int>, a: Int ->
+    forAll(genFunctionAToB<Int, Kind<F, Int>>(genApplicative(Gen.int(), this)), Gen.int()) { f: (Int) -> Kind<F, Int>, a: Int ->
       just(a).flatMap(f).equalUnderTheLaw(f(a), EQ)
-    })
+    }
 
   fun <F> Monad<F>.rightIdentity(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genApplicative(Gen.int(), this), { fa: Kind<F, Int> ->
-      fa.flatMap({ just(it) }).equalUnderTheLaw(fa, EQ)
-    })
+    forAll(genApplicative(Gen.int(), this)) { fa: Kind<F, Int> ->
+      fa.flatMap { just(it) }.equalUnderTheLaw(fa, EQ)
+    }
 
   fun <F> Monad<F>.kleisliLeftIdentity(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genFunctionAToB<Int, Kind<F, Int>>(genApplicative(Gen.int(), this)), Gen.int(), { f: (Int) -> Kind<F, Int>, a: Int ->
-      (Kleisli({ n: Int -> just(n) }).andThen(this, Kleisli(f)).run(a).equalUnderTheLaw(f(a), EQ))
-    })
+    forAll(genFunctionAToB<Int, Kind<F, Int>>(genApplicative(Gen.int(), this)), Gen.int()) { f: (Int) -> Kind<F, Int>, a: Int ->
+      (Kleisli { n: Int -> just(n) }.andThen(this, Kleisli(f)).run(a).equalUnderTheLaw(f(a), EQ))
+    }
 
   fun <F> Monad<F>.kleisliRightIdentity(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genFunctionAToB<Int, Kind<F, Int>>(genApplicative(Gen.int(), this)), Gen.int(), { f: (Int) -> Kind<F, Int>, a: Int ->
-      (Kleisli(f).andThen(this, Kleisli({ n: Int -> just(n) })).run(a).equalUnderTheLaw(f(a), EQ))
-    })
+    forAll(genFunctionAToB<Int, Kind<F, Int>>(genApplicative(Gen.int(), this)), Gen.int()) { f: (Int) -> Kind<F, Int>, a: Int ->
+      (Kleisli(f).andThen(this, Kleisli { n: Int -> just(n) }).run(a).equalUnderTheLaw(f(a), EQ))
+    }
 
   fun <F> Monad<F>.mapFlatMapCoherence(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genFunctionAToB<Int, Int>(Gen.int()), genApplicative(Gen.int(), this), { f: (Int) -> Int, fa: Kind<F, Int> ->
-      fa.flatMap({ just(f(it)) }).equalUnderTheLaw(fa.map(f), EQ)
-    })
+    forAll(genFunctionAToB<Int, Int>(Gen.int()), genApplicative(Gen.int(), this)) { f: (Int) -> Int, fa: Kind<F, Int> ->
+      fa.flatMap { just(f(it)) }.equalUnderTheLaw(fa.map(f), EQ)
+    }
 
   fun <F> Monad<F>.stackSafety(iterations: Int = 5000, EQ: Eq<Kind<F, Int>>): Unit =
     forFew(1, Gen.oneOf(listOf(iterations))) { iter ->
-      val res = tailRecM(0, { i -> just(if (i < iter) Left(i + 1) else Right(i)) })
+      val res = tailRecM(0) { i -> just(if (i < iter) Left(i + 1) else Right(i)) }
       res.equalUnderTheLaw(just(iter), EQ)
     }
 
@@ -71,7 +71,7 @@ object MonadLaws {
     }
 
   fun <F> Monad<F>.equivalentComprehensions(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(Gen.int(), { num: Int ->
+    forAll(Gen.int()) { num: Int ->
       val aa = binding {
         val a = just(num).bind()
         val b = just(a + 1).bind()
@@ -86,26 +86,26 @@ object MonadLaws {
       }.run(this)
       aa.equalUnderTheLaw(bb, EQ) &&
         aa.equalUnderTheLaw(just(num + 2), EQ)
-    })
+    }
 
   fun <F> Monad<F>.monadComprehensions(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(Gen.int(), { num: Int ->
+    forAll(Gen.int()) { num: Int ->
       binding {
         val a = just(num).bind()
         val b = just(a + 1).bind()
         val c = just(b + 1).bind()
         c
       }.equalUnderTheLaw(just(num + 2), EQ)
-    })
+    }
 
   fun <F> Monad<F>.monadComprehensionsBindInContext(EQ: Eq<Kind<F, Int>>): Unit =
-    forFew(5, genIntSmall(), { num: Int ->
+    forFew(5, genIntSmall()) { num: Int ->
       binding {
         val a = bindIn(newSingleThreadContext("$num")) { num + 1 }
         val b = bindIn(newSingleThreadContext("$a")) { a + 1 }
         b
       }.equalUnderTheLaw(just(num + 2), EQ)
-    })
+    }
 
   fun <F> arrow.typeclasses.Monad<F>.stackSafeTestProgram(n: kotlin.Int, stopAt: kotlin.Int): Free<F, Int> = bindingStackSafe {
     val v = this.just(n + 1).bind()
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadStateLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadStateLaws.kt
index c6e6202c144..469ba7bd9a2 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadStateLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadStateLaws.kt
@@ -10,29 +10,29 @@ object MonadStateLaws {
 
   inline fun <F> laws(M: MonadState<F, Int>, EQ: Eq<Kind<F, Int>>, EQUnit: Eq<Kind<F, Unit>>): List<Law> =
     MonadLaws.laws(M, EQ) + listOf(
-      Law("Monad State Laws: idempotence", { M.monadStateGetIdempotent(EQ) }),
-      Law("Monad State Laws: set twice eq to set once the last element", { M.monadStateSetTwice(EQUnit) }),
-      Law("Monad State Laws: set get", { M.monadStateSetGet(EQ) }),
-      Law("Monad State Laws: get set", { M.monadStateGetSet(EQUnit) })
+      Law("Monad State Laws: idempotence") { M.monadStateGetIdempotent(EQ) },
+      Law("Monad State Laws: set twice eq to set once the last element") { M.monadStateSetTwice(EQUnit) },
+      Law("Monad State Laws: set get") { M.monadStateSetGet(EQ) },
+      Law("Monad State Laws: get set") { M.monadStateGetSet(EQUnit) }
     )
 
   fun <F> MonadState<F, Int>.monadStateGetIdempotent(EQ: Eq<Kind<F, Int>>) {
-    get().flatMap({ get() }).equalUnderTheLaw(get(), EQ)
+    get().flatMap { get() }.equalUnderTheLaw(get(), EQ)
   }
 
   fun <F> MonadState<F, Int>.monadStateSetTwice(EQ: Eq<Kind<F, Unit>>) {
-    forAll(genIntSmall(), genIntSmall(), { s: Int, t: Int ->
-      set(s).flatMap({ set(t) }).equalUnderTheLaw(set(t), EQ)
-    })
+    forAll(genIntSmall(), genIntSmall()) { s: Int, t: Int ->
+      set(s).flatMap { set(t) }.equalUnderTheLaw(set(t), EQ)
+    }
   }
 
   fun <F> MonadState<F, Int>.monadStateSetGet(EQ: Eq<Kind<F, Int>>) {
-    forAll(genIntSmall(), { s: Int ->
-      set(s).flatMap({ get() }).equalUnderTheLaw(set(s).flatMap({ just(s) }), EQ)
-    })
+    forAll(genIntSmall()) { s: Int ->
+      set(s).flatMap { get() }.equalUnderTheLaw(set(s).flatMap { just(s) }, EQ)
+    }
   }
 
   fun <F> MonadState<F, Int>.monadStateGetSet(EQ: Eq<Kind<F, Unit>>) {
-    get().flatMap({ set(it) }).equalUnderTheLaw(just(Unit), EQ)
+    get().flatMap { set(it) }.equalUnderTheLaw(just(Unit), EQ)
   }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadSuspendLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadSuspendLaws.kt
index d2647f9e18d..2fa5fdfc0b6 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadSuspendLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadSuspendLaws.kt
@@ -16,21 +16,21 @@ import kotlinx.coroutines.experimental.newSingleThreadContext
 object MonadSuspendLaws {
   inline fun <F> laws(SC: MonadDefer<F>, EQ: Eq<Kind<F, Int>>, EQ_EITHER: Eq<Kind<F, Either<Throwable, Int>>>, EQERR: Eq<Kind<F, Int>> = EQ): List<Law> =
     MonadErrorLaws.laws(SC, EQERR, EQ_EITHER, EQ) + listOf(
-      Law("Sync bind: binding blocks", { SC.asyncBind(EQ) }),
-      Law("Sync bind: binding failure", { SC.asyncBindError(EQERR) }),
-      Law("Sync bind: unsafe binding", { SC.asyncBindUnsafe(EQ) }),
-      Law("Sync bind: unsafe binding failure", { SC.asyncBindUnsafeError(EQERR) }),
-      Law("Sync bind: binding in parallel", { SC.asyncParallelBind(EQ) }),
-      Law("Sync bind: binding cancellation before flatMap", { SC.asyncCancellationBefore(EQ) }),
-      Law("Sync bind: binding cancellation after flatMap", { SC.asyncCancellationAfter(EQ) }),
-      Law("Sync bind: bindingInContext cancellation before flatMap", { SC.inContextCancellationBefore(EQ) }),
-      Law("Sync bind: bindingInContext cancellation after flatMap", { SC.inContextCancellationAfter(EQ) }),
-      Law("Sync bind: bindingInContext throw equivalent to raiseError", { SC.inContextErrorThrow(EQERR) }),
-      Law("Sync bind: monad comprehensions binding in other threads equivalence", { SC.monadComprehensionsBindInContextEquivalent(EQ) })
+      Law("Sync bind: binding blocks") { SC.asyncBind(EQ) },
+      Law("Sync bind: binding failure") { SC.asyncBindError(EQERR) },
+      Law("Sync bind: unsafe binding") { SC.asyncBindUnsafe(EQ) },
+      Law("Sync bind: unsafe binding failure") { SC.asyncBindUnsafeError(EQERR) },
+      Law("Sync bind: binding in parallel") { SC.asyncParallelBind(EQ) },
+      Law("Sync bind: binding cancellation before flatMap") { SC.asyncCancellationBefore(EQ) },
+      Law("Sync bind: binding cancellation after flatMap") { SC.asyncCancellationAfter(EQ) },
+      Law("Sync bind: bindingInContext cancellation before flatMap") { SC.inContextCancellationBefore(EQ) },
+      Law("Sync bind: bindingInContext cancellation after flatMap") { SC.inContextCancellationAfter(EQ) },
+      Law("Sync bind: bindingInContext throw equivalent to raiseError") { SC.inContextErrorThrow(EQERR) },
+      Law("Sync bind: monad comprehensions binding in other threads equivalence") { SC.monadComprehensionsBindInContextEquivalent(EQ) }
     )
 
   fun <F> MonadDefer<F>.asyncBind(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genIntSmall(), genIntSmall(), genIntSmall(), { x: Int, y: Int, z: Int ->
+    forAll(genIntSmall(), genIntSmall(), genIntSmall()) { x: Int, y: Int, z: Int ->
       val (bound, dispose) = bindingCancellable {
         val a = bindDefer { x }
         val b = bindDefer { a + y }
@@ -38,18 +38,18 @@ object MonadSuspendLaws {
         c
       }
       bound.equalUnderTheLaw(just<Int>(x + y + z), EQ)
-    })
+    }
 
   fun <F> MonadDefer<F>.asyncBindError(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genThrowable(), { e: Throwable ->
+    forAll(genThrowable()) { e: Throwable ->
       val (bound: Kind<F, Int>, cancel) = bindingCancellable<F, Int> {
         bindDefer { throw e }
       }
       bound.equalUnderTheLaw(raiseError<Int>(e), EQ)
-    })
+    }
 
   fun <F> MonadDefer<F>.asyncBindUnsafe(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genIntSmall(), genIntSmall(), genIntSmall(), { x: Int, y: Int, z: Int ->
+    forAll(genIntSmall(), genIntSmall(), genIntSmall()) { x: Int, y: Int, z: Int ->
       val (bound, dispose) = bindingCancellable {
         val a = bindDeferUnsafe { Right(x) }
         val b = bindDeferUnsafe { Right(a + y) }
@@ -57,27 +57,27 @@ object MonadSuspendLaws {
         c
       }
       bound.equalUnderTheLaw(just<Int>(x + y + z), EQ)
-    })
+    }
 
   fun <F> MonadDefer<F>.asyncBindUnsafeError(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genThrowable(), { e: Throwable ->
+    forAll(genThrowable()) { e: Throwable ->
       val (bound: Kind<F, Int>, dispose) = bindingCancellable<F, Int> {
         bindDeferUnsafe { Left(e) }
       }
       bound.equalUnderTheLaw(raiseError<Int>(e), EQ)
-    })
+    }
 
   fun <F> MonadDefer<F>.asyncParallelBind(EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genIntSmall(), genIntSmall(), genIntSmall(), { x: Int, y: Int, z: Int ->
+    forAll(genIntSmall(), genIntSmall(), genIntSmall()) { x: Int, y: Int, z: Int ->
       val (bound, dispose) = bindingCancellable {
         val value = bind { tupled(invoke { x }, invoke { y }, invoke { z }) }
         value.a + value.b + value.c
       }
       bound.equalUnderTheLaw(just<Int>(x + y + z), EQ)
-    })
+    }
 
   fun <F> MonadDefer<F>.asyncCancellationBefore(EQ: Eq<Kind<F, Int>>): Unit =
-    forFew(5, genIntSmall(), { num: Int ->
+    forFew(5, genIntSmall()) { num: Int ->
       val sideEffect = SideEffect()
       val (binding, dispose) = bindingCancellable {
         val a = bindDefer { Thread.sleep(500); num }
@@ -88,10 +88,10 @@ object MonadSuspendLaws {
       }
       Try { Thread.sleep(250); dispose() }.recover { throw it }
       binding.equalUnderTheLaw(raiseError(BindingCancellationException()), EQ) && sideEffect.counter == 0
-    })
+    }
 
   fun <F> MonadDefer<F>.asyncCancellationAfter(EQ: Eq<Kind<F, Int>>): Unit =
-    forFew(5, genIntSmall(), { num: Int ->
+    forFew(5, genIntSmall()) { num: Int ->
       val sideEffect = SideEffect()
       val (binding, dispose) = bindingCancellable {
         val a = bindDefer { num }
@@ -102,10 +102,10 @@ object MonadSuspendLaws {
       Try { Thread.sleep(250); dispose() }.recover { throw it }
       binding.equalUnderTheLaw(raiseError(BindingCancellationException()), EQ)
         && sideEffect.counter == 0
-    })
+    }
 
   fun <F> MonadDefer<F>.inContextCancellationBefore(EQ: Eq<Kind<F, Int>>): Unit =
-    forFew(5, genIntSmall(), { num: Int ->
+    forFew(5, genIntSmall()) { num: Int ->
       val sideEffect = SideEffect()
       val (binding, dispose) = bindingCancellable {
         val a = bindIn(CommonPool) { Thread.sleep(500); num }
@@ -116,10 +116,10 @@ object MonadSuspendLaws {
       }
       Try { Thread.sleep(250); dispose() }.recover { throw it }
       binding.equalUnderTheLaw(raiseError(BindingCancellationException()), EQ) && sideEffect.counter == 0
-    })
+    }
 
   fun <F> MonadDefer<F>.inContextCancellationAfter(EQ: Eq<Kind<F, Int>>): Unit =
-    forFew(5, genIntSmall(), { num: Int ->
+    forFew(5, genIntSmall()) { num: Int ->
       val sideEffect = SideEffect()
       val (binding, dispose) = bindingCancellable {
         val a = bindIn(CommonPool) { num }
@@ -130,18 +130,18 @@ object MonadSuspendLaws {
       Try { Thread.sleep(250); dispose() }.recover { throw it }
       binding.equalUnderTheLaw(raiseError(BindingCancellationException()), EQ)
         && sideEffect.counter == 0
-    })
+    }
 
   fun <F> MonadDefer<F>.inContextErrorThrow(EQ: Eq<Kind<F, Int>>): Unit =
-    forFew(5, genThrowable(), { throwable: Throwable ->
+    forFew(5, genThrowable()) { throwable: Throwable ->
       bindingCancellable {
         val a: Int = bindIn(newSingleThreadContext("1")) { throw throwable }
         a
       }.a.equalUnderTheLaw(raiseError(throwable), EQ)
-    })
+    }
 
   fun <F> MonadDefer<F>.monadComprehensionsBindInContextEquivalent(EQ: Eq<Kind<F, Int>>): Unit =
-    forFew(5, genIntSmall(), { num: Int ->
+    forFew(5, genIntSmall()) { num: Int ->
       val bindM = bindingCancellable {
         val a = bindDeferIn(newSingleThreadContext("$num")) { num + 1 }
         val b = bindDeferIn(newSingleThreadContext("$a")) { a + 1 }
@@ -153,5 +153,5 @@ object MonadSuspendLaws {
         b
       }
       bindM.a.equalUnderTheLaw(bind.a, EQ)
-    })
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadWriterLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadWriterLaws.kt
index f164c753d33..dba88c2897e 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadWriterLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonadWriterLaws.kt
@@ -19,36 +19,36 @@ object MonadWriterLaws {
                          EqInt: Eq<Kind<F, Int>>,
                          EqTupleWA: Eq<Kind<F, Tuple2<W, Int>>>): List<Law> =
     MonadLaws.laws(MF, EqInt) + listOf(
-      Law("Monad Writer Laws: writer just", { MW.monadWriterWriterJust(MOW, EqInt) }),
-      Law("Monad Writer Laws: tell fusion", { MW.monadWriterTellFusion(genW, MOW) }),
-      Law("Monad Writer Laws: listen just", { MW.monadWriterListenJust(MOW, EqTupleWA) }),
-      Law("Monad Writer Laws: listen writer", { MW.monadWriterListenWriter(genTupleWA, EqTupleWA) }))
+      Law("Monad Writer Laws: writer just") { MW.monadWriterWriterJust(MOW, EqInt) },
+      Law("Monad Writer Laws: tell fusion") { MW.monadWriterTellFusion(genW, MOW) },
+      Law("Monad Writer Laws: listen just") { MW.monadWriterListenJust(MOW, EqTupleWA) },
+      Law("Monad Writer Laws: listen writer") { MW.monadWriterListenWriter(genTupleWA, EqTupleWA) })
 
   fun <F, W> MonadWriter<F, W>.monadWriterWriterJust(MOW: Monoid<W>,
                                                      EQ: Eq<Kind<F, Int>>): Unit {
-    forAll(Gen.int(), { a: Int ->
+    forAll(Gen.int()) { a: Int ->
       writer(Tuple2(MOW.empty(), a)).equalUnderTheLaw(just(a), EQ)
-    })
+    }
   }
 
   fun <F, W> MonadWriter<F, W>.monadWriterTellFusion(genW: Gen<W>,
                                                      MOW: Monoid<W>): Unit {
-    forAll(genW, genW, { x: W, y: W ->
-      tell(x).flatMap({ tell(y) }).equalUnderTheLaw(tell(MOW.run { x.combine(y) }), Eq.any())
-    })
+    forAll(genW, genW) { x: W, y: W ->
+      tell(x).flatMap { tell(y) }.equalUnderTheLaw(tell(MOW.run { x.combine(y) }), Eq.any())
+    }
   }
 
   fun <F, W> MonadWriter<F, W>.monadWriterListenJust(MOW: Monoid<W>,
                                                      EqTupleWA: Eq<Kind<F, Tuple2<W, Int>>>): Unit {
-    forAll(Gen.int(), { a: Int ->
+    forAll(Gen.int()) { a: Int ->
       just(a).listen().equalUnderTheLaw(just(Tuple2(MOW.empty(), a)), EqTupleWA)
-    })
+    }
   }
 
   fun <F, W> MonadWriter<F, W>.monadWriterListenWriter(genTupleWA: Gen<Tuple2<W, Int>>,
                                                        EqTupleWA: Eq<Kind<F, Tuple2<W, Int>>>): Unit {
-    forAll(genTupleWA, { tupleWA: Tuple2<W, Int> ->
-      writer(tupleWA).listen().equalUnderTheLaw(tell(tupleWA.a).map({ tupleWA }), EqTupleWA)
-    })
+    forAll(genTupleWA) { tupleWA: Tuple2<W, Int> ->
+      writer(tupleWA).listen().equalUnderTheLaw(tell(tupleWA.a).map { tupleWA }, EqTupleWA)
+    }
   }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonoidKLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonoidKLaws.kt
index c36b7cf8579..7def58e345f 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonoidKLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonoidKLaws.kt
@@ -12,21 +12,21 @@ object MonoidKLaws {
 
   inline fun <F> laws(SGK: MonoidK<F>, AP: Applicative<F>, EQ: Eq<Kind<F, Int>>): List<Law> =
     SemigroupKLaws.laws(SGK, AP, EQ) + listOf(
-      Law("MonoidK Laws: Left identity", { SGK.monoidKLeftIdentity(AP::just, EQ) }),
-      Law("MonoidK Laws: Right identity", { SGK.monoidKRightIdentity(AP::just, EQ) }))
+      Law("MonoidK Laws: Left identity") { SGK.monoidKLeftIdentity(AP::just, EQ) },
+      Law("MonoidK Laws: Right identity") { SGK.monoidKRightIdentity(AP::just, EQ) })
 
   inline fun <F> laws(SGK: MonoidK<F>, noinline f: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): List<Law> =
     SemigroupKLaws.laws(SGK, f, EQ) + listOf(
-      Law("MonoidK Laws: Left identity", { SGK.monoidKLeftIdentity(f, EQ) }),
-      Law("MonoidK Laws: Right identity", { SGK.monoidKRightIdentity(f, EQ) }))
+      Law("MonoidK Laws: Left identity") { SGK.monoidKLeftIdentity(f, EQ) },
+      Law("MonoidK Laws: Right identity") { SGK.monoidKRightIdentity(f, EQ) })
 
   fun <F> MonoidK<F>.monoidKLeftIdentity(f: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), f), { fa: Kind<F, Int> ->
+    forAll(genConstructor(Gen.int(), f)) { fa: Kind<F, Int> ->
       empty<Int>().combineK(fa).equalUnderTheLaw(fa, EQ)
-    })
+    }
 
   fun <F> MonoidK<F>.monoidKRightIdentity(f: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), f), { fa: Kind<F, Int> ->
+    forAll(genConstructor(Gen.int(), f)) { fa: Kind<F, Int> ->
       fa.combineK(empty<Int>()).equalUnderTheLaw(fa, EQ)
-    })
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonoidLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonoidLaws.kt
index 731101c7f59..04d5f1e28bc 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonoidLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/MonoidLaws.kt
@@ -7,8 +7,8 @@ object MonoidLaws {
 
   inline fun <F> laws(M: Monoid<F>, A: F, EQ: Eq<F>): List<Law> =
     listOf(
-      Law("Monoid Laws: Left identity", { M.monoidLeftIdentity(A, EQ) }),
-      Law("Monoid Laws: Right identity", { M.monoidRightIdentity(A, EQ) })
+      Law("Monoid Laws: Left identity") { M.monoidLeftIdentity(A, EQ) },
+      Law("Monoid Laws: Right identity") { M.monoidRightIdentity(A, EQ) }
     )
 
   fun <F> Monoid<F>.monoidLeftIdentity(A: F, EQ: Eq<F>): Boolean =
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/OptionalLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/OptionalLaws.kt
index 51f1ca5aac7..1391bd6559b 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/OptionalLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/OptionalLaws.kt
@@ -11,57 +11,57 @@ import io.kotlintest.properties.forAll
 object OptionalLaws {
 
   inline fun <A, B> laws(optional: Optional<A, B>, aGen: Gen<A>, bGen: Gen<B>, funcGen: Gen<(B) -> B>, EQA: Eq<A>, EQOptionB: Eq<Option<B>>): List<Law> = listOf(
-    Law("Optional Law: set what you get", { optional.getOptionSet(aGen, EQA) }),
-    Law("Optional Law: set what you get", { optional.setGetOption(aGen, bGen, EQOptionB) }),
-    Law("Optional Law: set is idempotent", { optional.setIdempotent(aGen, bGen, EQA) }),
-    Law("Optional Law: modify identity = identity", { optional.modifyIdentity(aGen, EQA) }),
-    Law("Optional Law: compose modify", { optional.composeModify(aGen, funcGen, EQA) }),
-    Law("Optional Law: consistent set with modify", { optional.consistentSetModify(aGen, bGen, EQA) }),
-    Law("Optional Law: consistent modify with modify identity", { optional.consistentModifyModifyId(aGen, funcGen, EQA) }),
-    Law("Optional Law: consistent getOption with modify identity", { optional.consistentGetOptionModifyId(aGen, EQOptionB) })
+    Law("Optional Law: set what you get") { optional.getOptionSet(aGen, EQA) },
+    Law("Optional Law: set what you get") { optional.setGetOption(aGen, bGen, EQOptionB) },
+    Law("Optional Law: set is idempotent") { optional.setIdempotent(aGen, bGen, EQA) },
+    Law("Optional Law: modify identity = identity") { optional.modifyIdentity(aGen, EQA) },
+    Law("Optional Law: compose modify") { optional.composeModify(aGen, funcGen, EQA) },
+    Law("Optional Law: consistent set with modify") { optional.consistentSetModify(aGen, bGen, EQA) },
+    Law("Optional Law: consistent modify with modify identity") { optional.consistentModifyModifyId(aGen, funcGen, EQA) },
+    Law("Optional Law: consistent getOption with modify identity") { optional.consistentGetOptionModifyId(aGen, EQOptionB) }
   )
 
   fun <A, B> Optional<A, B>.getOptionSet(aGen: Gen<A>, EQA: Eq<A>): Unit =
-    forAll(aGen, { a ->
-      getOrModify(a).fold(::identity, { set(a, it) })
+    forAll(aGen) { a ->
+      getOrModify(a).fold(::identity) { set(a, it) }
         .equalUnderTheLaw(a, EQA)
-    })
+    }
 
   fun <A, B> Optional<A, B>.setGetOption(aGen: Gen<A>, bGen: Gen<B>, EQOptionB: Eq<Option<B>>): Unit =
-    forAll(aGen, bGen, { a, b ->
+    forAll(aGen, bGen) { a, b ->
       getOption(set(a, b))
         .equalUnderTheLaw(getOption(a).map { _ -> b }, EQOptionB)
-    })
+    }
 
   fun <A, B> Optional<A, B>.setIdempotent(aGen: Gen<A>, bGen: Gen<B>, EQA: Eq<A>): Unit =
-    forAll(aGen, bGen, { a, b ->
+    forAll(aGen, bGen) { a, b ->
       set(set(a, b), b)
         .equalUnderTheLaw(set(a, b), EQA)
-    })
+    }
 
   fun <A, B> Optional<A, B>.modifyIdentity(aGen: Gen<A>, EQA: Eq<A>): Unit =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       modify(a, ::identity)
         .equalUnderTheLaw(a, EQA)
-    })
+    }
 
   fun <A, B> Optional<A, B>.composeModify(aGen: Gen<A>, funcGen: Gen<(B) -> B>, EQA: Eq<A>): Unit =
-    forAll(aGen, funcGen, funcGen, { a, f, g ->
+    forAll(aGen, funcGen, funcGen) { a, f, g ->
       modify(modify(a, f), g)
         .equalUnderTheLaw(modify(a, g compose f), EQA)
-    })
+    }
 
   fun <A, B> Optional<A, B>.consistentSetModify(aGen: Gen<A>, bGen: Gen<B>, EQA: Eq<A>): Unit =
-    forAll(aGen, bGen, { a, b ->
+    forAll(aGen, bGen) { a, b ->
       set(a, b)
         .equalUnderTheLaw(modify(a) { b }, EQA)
-    })
+    }
 
   fun <A, B> Optional<A, B>.consistentModifyModifyId(aGen: Gen<A>, funcGen: Gen<(B) -> B>, EQA: Eq<A>): Unit =
-    forAll(aGen, funcGen, { a, f ->
+    forAll(aGen, funcGen) { a, f ->
       modify(a, f)
-        .equalUnderTheLaw(modifyF(Id.applicative(), a, { Id.just(f(it)) }).value(), EQA)
-    })
+        .equalUnderTheLaw(modifyF(Id.applicative(), a) { Id.just(f(it)) }.value(), EQA)
+    }
 
   fun <A, B> Optional<A, B>.consistentGetOptionModifyId(aGen: Gen<A>, EQOptionB: Eq<Option<B>>): Unit {
     val firstMonoid = object : Monoid<FirstOption<B>> {
@@ -69,11 +69,11 @@ object OptionalLaws {
       override fun FirstOption<B>.combine(b: FirstOption<B>): FirstOption<B> = if (option.fold({ false }, { true })) this else b
     }
 
-    forAll(aGen, { a ->
-      modifyF(Const.applicative(firstMonoid), a, { b ->
+    forAll(aGen) { a ->
+      modifyF(Const.applicative(firstMonoid), a) { b ->
         Const(FirstOption(Some(b)))
-      }).value().option.equalUnderTheLaw(getOption(a), EQOptionB)
-    })
+      }.value().option.equalUnderTheLaw(getOption(a), EQOptionB)
+    }
   }
 
   @PublishedApi
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/OrderLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/OrderLaws.kt
index 87c16f0fcb8..da392d574c6 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/OrderLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/OrderLaws.kt
@@ -8,99 +8,99 @@ import io.kotlintest.properties.forAll
 object OrderLaws {
 
   inline fun <F> laws(O: Order<F>, fGen: Gen<F>, funcGen: Gen<(F) -> F>): List<Law> =
-    EqLaws.laws(O, { fGen.generate() }) + listOf(
-      Law("Order law: reflexivity equality", { O.reflexitivityEq(fGen) }),
-      Law("Order law: symmetry equality", { O.symmetryEq(fGen) }),
-      Law("Order law: antisymmetry equality", { O.antisymmetryEq(fGen, funcGen) }),
-      Law("Order law: transitivity equality", { O.transitivityEq(fGen) }),
-      Law("Order law: reflexivity partial order", { O.reflexivityPartialOrder(fGen) }),
-      Law("Order law: antisymmetry partial order", { O.antisymmetryPartialOrder(fGen) }),
-      Law("Order law: transitivity partial order", { O.transitivityPartialOrder(fGen) }),
-      Law("Order law: greater than or equal partial order", { O.greaterThanOrEqualPartialOrder(fGen) }),
-      Law("Order law: lesser than partial order", { O.lesserThanPartialOrder(fGen) }),
-      Law("Order law: greater than partial order", { O.greaterThanPartialOrder(fGen) }),
-      Law("Order law: totality order", { O.totalityOrder(fGen) }),
-      Law("Order law: compare order", { O.compareOrder(fGen) }),
-      Law("Order law: min order", { O.minOrder(fGen) }),
-      Law("Order law: max order", { O.maxOrder(fGen) })
+    EqLaws.laws(O) { fGen.generate() } + listOf(
+      Law("Order law: reflexivity equality") { O.reflexitivityEq(fGen) },
+      Law("Order law: symmetry equality") { O.symmetryEq(fGen) },
+      Law("Order law: antisymmetry equality") { O.antisymmetryEq(fGen, funcGen) },
+      Law("Order law: transitivity equality") { O.transitivityEq(fGen) },
+      Law("Order law: reflexivity partial order") { O.reflexivityPartialOrder(fGen) },
+      Law("Order law: antisymmetry partial order") { O.antisymmetryPartialOrder(fGen) },
+      Law("Order law: transitivity partial order") { O.transitivityPartialOrder(fGen) },
+      Law("Order law: greater than or equal partial order") { O.greaterThanOrEqualPartialOrder(fGen) },
+      Law("Order law: lesser than partial order") { O.lesserThanPartialOrder(fGen) },
+      Law("Order law: greater than partial order") { O.greaterThanPartialOrder(fGen) },
+      Law("Order law: totality order") { O.totalityOrder(fGen) },
+      Law("Order law: compare order") { O.compareOrder(fGen) },
+      Law("Order law: min order") { O.minOrder(fGen) },
+      Law("Order law: max order") { O.maxOrder(fGen) }
     )
 
   fun <F> Order<F>.reflexitivityEq(fGen: Gen<F>) =
-    forAll(fGen, { x ->
+    forAll(fGen) { x ->
       x.equalUnderTheLaw(x, this)
-    })
+    }
 
   fun <F> Order<F>.symmetryEq(fGen: Gen<F>) =
-    forAll(fGen, fGen, { x, y ->
+    forAll(fGen, fGen) { x, y ->
       x.eqv(y).equalUnderTheLaw(y.eqv(x), Eq.any())
-    })
+    }
 
   fun <F> Order<F>.antisymmetryEq(fGen: Gen<F>, funcGen: Gen<(F) -> F>) =
-    forAll(fGen, fGen, funcGen, { x, y, f ->
+    forAll(fGen, fGen, funcGen) { x, y, f ->
       !x.eqv(y) || f(x).eqv(f(y))
-    })
+    }
 
   fun <F> Order<F>.transitivityEq(fGen: Gen<F>) =
-    forAll(fGen, fGen, fGen, { x, y, z ->
+    forAll(fGen, fGen, fGen) { x, y, z ->
       !(x.eqv(y) && y.eqv(z)) || x.eqv(z)
-    })
+    }
 
   fun <F> Order<F>.reflexivityPartialOrder(fGen: Gen<F>) =
-    forAll(fGen, { x ->
+    forAll(fGen) { x ->
       x.lte(x)
-    })
+    }
 
   fun <F> Order<F>.antisymmetryPartialOrder(fGen: Gen<F>) =
-    forAll(fGen, fGen, { x, y ->
+    forAll(fGen, fGen) { x, y ->
       !(x.lte(y) && y.lte(x)) || x.eqv(y)
-    })
+    }
 
   fun <F> Order<F>.transitivityPartialOrder(fGen: Gen<F>) =
-    forAll(fGen, fGen, fGen, { x, y, z ->
+    forAll(fGen, fGen, fGen) { x, y, z ->
       !(x.lte(y) && y.lte(x)) || x.lte(z)
-    })
+    }
 
   fun <F> Order<F>.greaterThanOrEqualPartialOrder(fGen: Gen<F>) =
-    forAll(fGen, fGen, { x, y ->
+    forAll(fGen, fGen) { x, y ->
       x.lte(y) == y.gte(x)
-    })
+    }
 
   fun <F> Order<F>.lesserThanPartialOrder(fGen: Gen<F>) =
-    forAll(fGen, fGen, { x, y ->
+    forAll(fGen, fGen) { x, y ->
       x.lt(y) == (x.lte(y) && x.neqv(y))
-    })
+    }
 
   fun <F> Order<F>.greaterThanPartialOrder(fGen: Gen<F>) =
-    forAll(fGen, fGen, { x, y ->
+    forAll(fGen, fGen) { x, y ->
       x.lt(y) == y.gt(x)
-    })
+    }
 
   fun <F> Order<F>.totalityOrder(fGen: Gen<F>) =
-    forAll(fGen, fGen, { x, y ->
+    forAll(fGen, fGen) { x, y ->
       x.lte(y) || y.lte(x)
-    })
+    }
 
   fun <F> Order<F>.compareOrder(fGen: Gen<F>) =
-    forAll(fGen, fGen, { x, y ->
+    forAll(fGen, fGen) { x, y ->
       val c = x.compare(y)
       ((c < 0) == x.lt(y)) && ((c == 0) == x.eqv(y)) && ((c > 0) == x.gt(y))
-    })
+    }
 
   fun <F> Order<F>.minOrder(fGen: Gen<F>) =
-    forAll(fGen, fGen, { x, y ->
+    forAll(fGen, fGen) { x, y ->
       val c = x.compare(y)
       val m = x.min(y)
       if (c < 0) m == x
       else if (c == 0) (m == x) && (m == y)
       else m == y
-    })
+    }
 
   fun <F> Order<F>.maxOrder(fGen: Gen<F>) =
-    forAll(fGen, fGen, { x, y ->
+    forAll(fGen, fGen) { x, y ->
       val c = x.compare(y)
       val m = x.max(y)
       if (c < 0) m == y
       else if (c == 0) (m == x) && (m == y)
       else m == x
-    })
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/PrismLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/PrismLaws.kt
index 89d7d9d6960..25419418355 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/PrismLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/PrismLaws.kt
@@ -10,54 +10,54 @@ import io.kotlintest.properties.forAll
 object PrismLaws {
 
   inline fun <A, B> laws(prism: Prism<A, B>, aGen: Gen<A>, bGen: Gen<B>, funcGen: Gen<(B) -> B>, EQA: Eq<A>, EQOptionB: Eq<Option<B>>): List<Law> = listOf(
-    Law("Prism law: partial round trip one way", { prism.partialRoundTripOneWay(aGen, EQA) }),
-    Law("Prism law: round trip other way", { prism.roundTripOtherWay(bGen, EQOptionB) }),
-    Law("Prism law: modify identity", { prism.modifyIdentity(aGen, EQA) }),
-    Law("Prism law: compose modify", { prism.composeModify(aGen, funcGen, EQA) }),
-    Law("Prism law: consistent set modify", { prism.consistentSetModify(aGen, bGen, EQA) }),
-    Law("Prism law: consistent modify with modifyF Id", { prism.consistentModifyModifyFId(aGen, funcGen, EQA) }),
-    Law("Prism law: consistent get option modify id", { prism.consistentGetOptionModifyId(aGen, EQOptionB) })
+    Law("Prism law: partial round trip one way") { prism.partialRoundTripOneWay(aGen, EQA) },
+    Law("Prism law: round trip other way") { prism.roundTripOtherWay(bGen, EQOptionB) },
+    Law("Prism law: modify identity") { prism.modifyIdentity(aGen, EQA) },
+    Law("Prism law: compose modify") { prism.composeModify(aGen, funcGen, EQA) },
+    Law("Prism law: consistent set modify") { prism.consistentSetModify(aGen, bGen, EQA) },
+    Law("Prism law: consistent modify with modifyF Id") { prism.consistentModifyModifyFId(aGen, funcGen, EQA) },
+    Law("Prism law: consistent get option modify id") { prism.consistentGetOptionModifyId(aGen, EQOptionB) }
   )
 
   fun <A, B> Prism<A, B>.partialRoundTripOneWay(aGen: Gen<A>, EQA: Eq<A>): Unit =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       getOrModify(a).fold(::identity, this::reverseGet)
         .equalUnderTheLaw(a, EQA)
-    })
+    }
 
   fun <A, B> Prism<A, B>.roundTripOtherWay(bGen: Gen<B>, EQOptionB: Eq<Option<B>>): Unit =
-    forAll(bGen, { b ->
+    forAll(bGen) { b ->
       getOption(reverseGet(b))
         .equalUnderTheLaw(Some(b), EQOptionB)
-    })
+    }
 
   fun <A, B> Prism<A, B>.modifyIdentity(aGen: Gen<A>, EQA: Eq<A>): Unit =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       modify(a, ::identity).equalUnderTheLaw(a, EQA)
-    })
+    }
 
   fun <A, B> Prism<A, B>.composeModify(aGen: Gen<A>, funcGen: Gen<(B) -> B>, EQA: Eq<A>): Unit =
-    forAll(aGen, funcGen, funcGen, { a, f, g ->
+    forAll(aGen, funcGen, funcGen) { a, f, g ->
       modify(modify(a, f), g).equalUnderTheLaw(modify(a, g compose f), EQA)
-    })
+    }
 
   fun <A, B> Prism<A, B>.consistentSetModify(aGen: Gen<A>, bGen: Gen<B>, EQA: Eq<A>): Unit =
-    forAll(aGen, bGen, { a, b ->
+    forAll(aGen, bGen) { a, b ->
       set(a, b).equalUnderTheLaw(modify(a) { b }, EQA)
-    })
+    }
 
   fun <A, B> Prism<A, B>.consistentModifyModifyFId(aGen: Gen<A>, funcGen: Gen<(B) -> B>, EQA: Eq<A>): Unit =
-    forAll(aGen, funcGen, { a, f ->
-      modifyF(Id.applicative(), a, { Id.just(f(it)) }).value().equalUnderTheLaw(modify(a, f), EQA)
-    })
+    forAll(aGen, funcGen) { a, f ->
+      modifyF(Id.applicative(), a) { Id.just(f(it)) }.value().equalUnderTheLaw(modify(a, f), EQA)
+    }
 
   fun <A, B> Prism<A, B>.consistentGetOptionModifyId(aGen: Gen<A>, EQOptionB: Eq<Option<B>>): Unit =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       modifyF(Const.applicative(object : Monoid<Option<B>> {
         override fun Option<B>.combine(b: Option<B>): Option<B> = orElse { b }
 
         override fun empty(): Option<B> = None
-      }), a, { Const(Some(it)) }).value().equalUnderTheLaw(getOption(a), EQOptionB)
-    })
+      }), a) { Const(Some(it)) }.value().equalUnderTheLaw(getOption(a), EQOptionB)
+    }
 
 }
\ No newline at end of file
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ReducibleLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ReducibleLaws.kt
index caba9d7366f..00a0717847b 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ReducibleLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ReducibleLaws.kt
@@ -15,53 +15,53 @@ import io.kotlintest.properties.forAll
 object ReducibleLaws {
   inline fun <F> laws(RF: Reducible<F>, noinline cf: (Int) -> Kind<F, Int>, EQ: Eq<Int>, EQOptionInt: Eq<Option<Int>>, EQLong: Eq<Long>): List<Law> =
     FoldableLaws.laws(RF, cf, EQ) + listOf(
-      Law("Reducible Laws: reduceLeftTo consistent with reduceMap", { RF.reduceLeftToConsistentWithReduceMap(cf, EQ) }),
-      Law("Reducible Laws: reduceRightTo consistent with reduceMap", { RF.reduceRightToConsistentWithReduceMap(cf, EQ) }),
-      Law("Reducible Laws: reduceRightTo consistent with reduceRightToOption", { RF.reduceRightToConsistentWithReduceRightToOption(cf, EQOptionInt) }),
-      Law("Reducible Laws: reduceRight consistent with reduceRightOption", { RF.reduceRightConsistentWithReduceRightOption(cf, EQOptionInt) }),
-      Law("Reducible Laws: reduce reduce left consistent", { RF.reduceReduceLeftConsistent(cf, EQ) }),
-      Law("Reducible Laws: size consistent", { RF.sizeConsistent(cf, EQLong) })
+      Law("Reducible Laws: reduceLeftTo consistent with reduceMap") { RF.reduceLeftToConsistentWithReduceMap(cf, EQ) },
+      Law("Reducible Laws: reduceRightTo consistent with reduceMap") { RF.reduceRightToConsistentWithReduceMap(cf, EQ) },
+      Law("Reducible Laws: reduceRightTo consistent with reduceRightToOption") { RF.reduceRightToConsistentWithReduceRightToOption(cf, EQOptionInt) },
+      Law("Reducible Laws: reduceRight consistent with reduceRightOption") { RF.reduceRightConsistentWithReduceRightOption(cf, EQOptionInt) },
+      Law("Reducible Laws: reduce reduce left consistent") { RF.reduceReduceLeftConsistent(cf, EQ) },
+      Law("Reducible Laws: size consistent") { RF.sizeConsistent(cf, EQLong) }
     )
 
   fun <F> Reducible<F>.reduceLeftToConsistentWithReduceMap(cf: (Int) -> Kind<F, Int>, EQ: Eq<Int>) =
-    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf), { f: (Int) -> Int, fa: Kind<F, Int> ->
+    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf)) { f: (Int) -> Int, fa: Kind<F, Int> ->
       with(Int.monoid()) {
-        fa.reduceMap(this, f).equalUnderTheLaw(fa.reduceLeftTo(f, { b, a -> b.combine(f(a)) }), EQ)
+        fa.reduceMap(this, f).equalUnderTheLaw(fa.reduceLeftTo(f) { b, a -> b.combine(f(a)) }, EQ)
       }
-    })
+    }
 
   fun <F> Reducible<F>.reduceRightToConsistentWithReduceMap(cf: (Int) -> Kind<F, Int>, EQ: Eq<Int>) =
-    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf), { f: (Int) -> Int, fa: Kind<F, Int> ->
+    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf)) { f: (Int) -> Int, fa: Kind<F, Int> ->
       with(Int.monoid()) {
-        fa.reduceMap(this, f).equalUnderTheLaw(fa.reduceRightTo(f, { a, eb -> eb.map({ f(a).combine(it) }) }).value(), EQ)
+        fa.reduceMap(this, f).equalUnderTheLaw(fa.reduceRightTo(f) { a, eb -> eb.map { f(a).combine(it) } }.value(), EQ)
       }
-    })
+    }
 
   fun <F> Reducible<F>.reduceRightToConsistentWithReduceRightToOption(cf: (Int) -> Kind<F, Int>, EQ: Eq<Option<Int>>) =
-    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf), { f: (Int) -> Int, fa: Kind<F, Int> ->
+    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf)) { f: (Int) -> Int, fa: Kind<F, Int> ->
       with(Int.monoid()) {
-        fa.reduceRightToOption(f, { a, eb -> eb.map({ f(a).combine(it) }) }).value()
-          .equalUnderTheLaw(fa.reduceRightTo(f, { a, eb -> eb.map({ f(a).combine(it) }) }).map({ Option(it) }).value(), EQ)
+        fa.reduceRightToOption(f) { a, eb -> eb.map { f(a).combine(it) } }.value()
+          .equalUnderTheLaw(fa.reduceRightTo(f) { a, eb -> eb.map { f(a).combine(it) } }.map { Option(it) }.value(), EQ)
       }
-    })
+    }
 
   fun <F> Reducible<F>.reduceRightConsistentWithReduceRightOption(cf: (Int) -> Kind<F, Int>, EQ: Eq<Option<Int>>) =
-    forAll(genFunctionAAToA(genIntSmall()), genConstructor(genIntSmall(), cf), { f: (Int, Int) -> Int, fa: Kind<F, Int> ->
-      fa.reduceRight({ a1, e2 -> Eval.Now(f(a1, e2.value())) }).map({ Option(it) }).value()
-        .equalUnderTheLaw(fa.reduceRightOption({ a1, e2 -> Eval.Now(f(a1, e2.value())) }).value(), EQ)
-    })
+    forAll(genFunctionAAToA(genIntSmall()), genConstructor(genIntSmall(), cf)) { f: (Int, Int) -> Int, fa: Kind<F, Int> ->
+      fa.reduceRight { a1, e2 -> Eval.Now(f(a1, e2.value())) }.map { Option(it) }.value()
+        .equalUnderTheLaw(fa.reduceRightOption { a1, e2 -> Eval.Now(f(a1, e2.value())) }.value(), EQ)
+    }
 
   fun <F> Reducible<F>.reduceReduceLeftConsistent(cf: (Int) -> Kind<F, Int>, EQ: Eq<Int>) =
-    forAll(genConstructor(genIntSmall(), cf), { fa: Kind<F, Int> ->
+    forAll(genConstructor(genIntSmall(), cf)) { fa: Kind<F, Int> ->
       with(Int.monoid()) {
-        fa.reduce(this).equalUnderTheLaw(fa.reduceLeft({ a1, a2 -> a1.combine(a2) }), EQ)
+        fa.reduce(this).equalUnderTheLaw(fa.reduceLeft { a1, a2 -> a1.combine(a2) }, EQ)
       }
-    })
+    }
 
   fun <F> Reducible<F>.sizeConsistent(cf: (Int) -> Kind<F, Int>, EQ: Eq<Long>) =
-    forAll(genConstructor(genIntSmall(), cf), { fa: Kind<F, Int> ->
+    forAll(genConstructor(genIntSmall(), cf)) { fa: Kind<F, Int> ->
       with(Long.monoid()) {
         fa.size(this).equalUnderTheLaw(fa.reduceMap(this) { 1L }, EQ)
       }
-    })
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SemigroupKlaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SemigroupKlaws.kt
index e4b59edb3a3..cc4e0a2e305 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SemigroupKlaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SemigroupKlaws.kt
@@ -11,13 +11,13 @@ import io.kotlintest.properties.forAll
 object SemigroupKLaws {
 
   inline fun <F> laws(SGK: SemigroupK<F>, AP: Applicative<F>, EQ: Eq<Kind<F, Int>>): List<Law> =
-    listOf(Law("SemigroupK: associativity", { SGK.semigroupKAssociative(AP::just, EQ) }))
+    listOf(Law("SemigroupK: associativity") { SGK.semigroupKAssociative(AP::just, EQ) })
 
   inline fun <F> laws(SGK: SemigroupK<F>, noinline f: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): List<Law> =
-    listOf(Law("SemigroupK: associativity", { SGK.semigroupKAssociative(f, EQ) }))
+    listOf(Law("SemigroupK: associativity") { SGK.semigroupKAssociative(f, EQ) })
 
   fun <F> SemigroupK<F>.semigroupKAssociative(f: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): Unit =
-    forAll(genConstructor(Gen.int(), f), genConstructor(Gen.int(), f), genConstructor(Gen.int(), f), { a, b, c ->
+    forAll(genConstructor(Gen.int(), f), genConstructor(Gen.int(), f), genConstructor(Gen.int(), f)) { a, b, c ->
       a.combineK(b).combineK(c).equalUnderTheLaw(a.combineK(b.combineK(c)), EQ)
-    })
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SemigroupLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SemigroupLaws.kt
index 48c3ee09992..e607c649151 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SemigroupLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SemigroupLaws.kt
@@ -6,7 +6,7 @@ import arrow.typeclasses.Semigroup
 object SemigroupLaws {
 
   inline fun <F> laws(SG: Semigroup<F>, A: F, B: F, C: F, EQ: Eq<F>): List<Law> =
-    listOf(Law("Semigroup: associativity", { SG.semigroupAssociative(A, B, C, EQ) }))
+    listOf(Law("Semigroup: associativity") { SG.semigroupAssociative(A, B, C, EQ) })
 
   fun <F> Semigroup<F>.semigroupAssociative(A: F, B: F, C: F, EQ: Eq<F>): Boolean =
     A.combine(B).combine(C).equalUnderTheLaw(A.combine(B.combine(C)), EQ)
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SetterLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SetterLaws.kt
index 81966ac207b..9782e25f844 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SetterLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SetterLaws.kt
@@ -10,25 +10,25 @@ import io.kotlintest.properties.forAll
 object SetterLaws {
 
   inline fun <A, B> laws(setter: Setter<A, B>, aGen: Gen<A>, bGen: Gen<B>, funcGen: Gen<(B) -> B>, EQA: Eq<A>) = listOf(
-    Law("Setter law: set is idempotent", { setter.setIdempotent(aGen, bGen, EQA) }),
-    Law("Setter law: modify identity", { setter.modifyIdentity(aGen, EQA) }),
-    Law("Setter law: compose modify", { setter.composeModify(aGen, EQA, funcGen) }),
-    Law("Setter law: consistent set modify", { setter.consistentSetModify(aGen, bGen, EQA) })
+    Law("Setter law: set is idempotent") { setter.setIdempotent(aGen, bGen, EQA) },
+    Law("Setter law: modify identity") { setter.modifyIdentity(aGen, EQA) },
+    Law("Setter law: compose modify") { setter.composeModify(aGen, EQA, funcGen) },
+    Law("Setter law: consistent set modify") { setter.consistentSetModify(aGen, bGen, EQA) }
   )
 
-  fun <A, B> Setter<A, B>.setIdempotent(aGen: Gen<A>, bGen: Gen<B>, EQA: Eq<A>): Unit = forAll(aGen, bGen, { a, b ->
+  fun <A, B> Setter<A, B>.setIdempotent(aGen: Gen<A>, bGen: Gen<B>, EQA: Eq<A>): Unit = forAll(aGen, bGen) { a, b ->
     set(set(a, b), b).equalUnderTheLaw(set(a, b), EQA)
-  })
+  }
 
-  fun <A, B> Setter<A, B>.modifyIdentity(aGen: Gen<A>, EQA: Eq<A>): Unit = forAll(aGen, { a ->
+  fun <A, B> Setter<A, B>.modifyIdentity(aGen: Gen<A>, EQA: Eq<A>): Unit = forAll(aGen) { a ->
     modify(a, ::identity).equalUnderTheLaw(a, EQA)
-  })
+  }
 
-  fun <A, B> Setter<A, B>.composeModify(aGen: Gen<A>, EQA: Eq<A>, funcGen: Gen<(B) -> B>): Unit = forAll(aGen, funcGen, funcGen, { a, f, g ->
+  fun <A, B> Setter<A, B>.composeModify(aGen: Gen<A>, EQA: Eq<A>, funcGen: Gen<(B) -> B>): Unit = forAll(aGen, funcGen, funcGen) { a, f, g ->
     modify(modify(a, f), g).equalUnderTheLaw(modify(a, g compose f), EQA)
-  })
+  }
 
-  fun <A, B> Setter<A, B>.consistentSetModify(aGen: Gen<A>, bGen: Gen<B>, EQA: Eq<A>): Unit = forAll(aGen, bGen, { a, b ->
+  fun <A, B> Setter<A, B>.consistentSetModify(aGen: Gen<A>, bGen: Gen<B>, EQA: Eq<A>): Unit = forAll(aGen, bGen) { a, b ->
     modify(a) { b }.equalUnderTheLaw(set(a, b), EQA)
-  })
+  }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ShowLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ShowLaws.kt
index 0c270f9c903..4a0b166e566 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ShowLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/ShowLaws.kt
@@ -9,14 +9,14 @@ object ShowLaws {
 
   inline fun <F> laws(S: Show<F>, EQ: Eq<F>, noinline cf: (Int) -> F): List<Law> =
     EqLaws.laws(EQ, cf) + listOf(
-      Law("Show Laws: equality", { S.equalShow(EQ, cf) })
+      Law("Show Laws: equality") { S.equalShow(EQ, cf) }
     )
 
   fun <F> Show<F>.equalShow(EQ: Eq<F>, cf: (Int) -> F): Unit =
-    forAll(Gen.int(), { int: Int ->
+    forAll(Gen.int()) { int: Int ->
       val a = cf(int)
       val b = cf(int)
       EQ.run { a.eqv(b) } && a.show() == b.show()
-    })
+    }
 
 }
\ No newline at end of file
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraversalLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraversalLaws.kt
index 9457ef59492..1e61e0f36a4 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraversalLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraversalLaws.kt
@@ -13,39 +13,39 @@ import io.kotlintest.properties.forAll
 object TraversalLaws {
 
   inline fun <A, B : Any> laws(traversal: Traversal<A, B>, aGen: Gen<A>, bGen: Gen<B>, funcGen: Gen<(B) -> B>, EQA: Eq<A>, EQOptionB: Eq<Option<B>>, EQListB: Eq<ListK<B>>) = listOf(
-    Law("Traversal law: head option", { traversal.headOption(aGen, EQOptionB) }),
-    Law("Traversal law: modify get all", { traversal.modifyGetAll(aGen, funcGen, EQListB) }),
-    Law("Traversal law: set is idempotent", { traversal.setIdempotent(aGen, bGen, EQA) }),
-    Law("Traversal law: modify identity", { traversal.modifyIdentity(aGen, EQA) }),
-    Law("Traversal law: compose modify", { traversal.composeModify(aGen, funcGen, EQA) })
+    Law("Traversal law: head option") { traversal.headOption(aGen, EQOptionB) },
+    Law("Traversal law: modify get all") { traversal.modifyGetAll(aGen, funcGen, EQListB) },
+    Law("Traversal law: set is idempotent") { traversal.setIdempotent(aGen, bGen, EQA) },
+    Law("Traversal law: modify identity") { traversal.modifyIdentity(aGen, EQA) },
+    Law("Traversal law: compose modify") { traversal.composeModify(aGen, funcGen, EQA) }
   )
 
   fun <A, B : Any> Traversal<A, B>.headOption(aGen: Gen<A>, EQOptionB: Eq<Option<B>>): Unit =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       headOption(a)
         .equalUnderTheLaw(getAll(a).firstOrNull().toOption(), EQOptionB)
-    })
+    }
 
   fun <A, B> Traversal<A, B>.modifyGetAll(aGen: Gen<A>, funcGen: Gen<(B) -> B>, EQListB: Eq<ListK<B>>): Unit =
-    forAll(aGen, funcGen, { a, f ->
+    forAll(aGen, funcGen) { a, f ->
       getAll(modify(a, f))
         .equalUnderTheLaw(getAll(a).map(f), EQListB)
-    })
+    }
 
   fun <A, B> Traversal<A, B>.setIdempotent(aGen: Gen<A>, bGen: Gen<B>, EQA: Eq<A>): Unit =
-    forAll(aGen, bGen, { a, b ->
+    forAll(aGen, bGen) { a, b ->
       set(set(a, b), b)
         .equalUnderTheLaw(set(a, b), EQA)
-    })
+    }
 
   fun <A, B> Traversal<A, B>.modifyIdentity(aGen: Gen<A>, EQA: Eq<A>): Unit =
-    forAll(aGen, { a ->
+    forAll(aGen) { a ->
       modify(a, ::identity).equalUnderTheLaw(a, EQA)
-    })
+    }
 
   fun <A, B> Traversal<A, B>.composeModify(aGen: Gen<A>, funcGen: Gen<(B) -> B>, EQA: Eq<A>): Unit =
-    forAll(aGen, funcGen, funcGen, { a, f, g ->
+    forAll(aGen, funcGen, funcGen) { a, f, g ->
       modify(modify(a, f), g)
         .equalUnderTheLaw(modify(a, g compose f), EQA)
-    })
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraverseFilterLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraverseFilterLaws.kt
index 3c10ccc76d1..c4530339907 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraverseFilterLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraverseFilterLaws.kt
@@ -17,17 +17,17 @@ object TraverseFilterLaws {
   //FIXME(paco): TraverseLaws cannot receive AP::just due to a crash caused by the inliner. Check in TraverseLaws why.
   inline fun <F> laws(TF: TraverseFilter<F>, GA: Applicative<F>, noinline cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>, EQ_NESTED: Eq<Kind<F, Kind<F, Int>>> = Eq.any()): List<Law> =
     TraverseLaws.laws(TF, GA, cf, EQ) + listOf(
-      Law("TraverseFilter Laws: Identity", { TF.identityTraverseFilter(GA, EQ_NESTED) }),
-      Law("TraverseFilter Laws: filterA consistent with TraverseFilter", { TF.filterAconsistentWithTraverseFilter(GA, EQ_NESTED) })
+      Law("TraverseFilter Laws: Identity") { TF.identityTraverseFilter(GA, EQ_NESTED) },
+      Law("TraverseFilter Laws: filterA consistent with TraverseFilter") { TF.filterAconsistentWithTraverseFilter(GA, EQ_NESTED) }
     )
 
   fun <F> TraverseFilter<F>.identityTraverseFilter(GA: Applicative<F>, EQ: Eq<Kind<F, Kind<F, Int>>> = Eq.any()) =
-    forAll(genApplicative(genIntSmall(), GA), { fa: Kind<F, Int> ->
-      fa.traverseFilter(GA, { GA.just(Some(it)) }).equalUnderTheLaw(GA.just(fa), EQ)
-    })
+    forAll(genApplicative(genIntSmall(), GA)) { fa: Kind<F, Int> ->
+      fa.traverseFilter(GA) { GA.just(Some(it)) }.equalUnderTheLaw(GA.just(fa), EQ)
+    }
 
   fun <F> TraverseFilter<F>.filterAconsistentWithTraverseFilter(GA: Applicative<F>, EQ: Eq<Kind<F, Kind<F, Int>>> = Eq.any()) =
-    forAll(genApplicative(genIntSmall(), GA), genFunctionAToB(genApplicative(Gen.bool(), GA)), { fa: Kind<F, Int>, f: (Int) -> Kind<F, Boolean> ->
-      fa.filterA(f, GA).equalUnderTheLaw(fa.traverseFilter(GA, { a -> f(a).map { b: Boolean -> if (b) Some(a) else None } }), EQ)
-    })
+    forAll(genApplicative(genIntSmall(), GA), genFunctionAToB(genApplicative(Gen.bool(), GA))) { fa: Kind<F, Int>, f: (Int) -> Kind<F, Boolean> ->
+      fa.filterA(f, GA).equalUnderTheLaw(fa.traverseFilter(GA) { a -> f(a).map { b: Boolean -> if (b) Some(a) else None } }, EQ)
+    }
 }
diff --git a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraverseLaws.kt b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraverseLaws.kt
index acaa2e95edc..7368d61bcb8 100644
--- a/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraverseLaws.kt
+++ b/modules/core/arrow-test/src/main/kotlin/arrow/test/laws/TraverseLaws.kt
@@ -37,30 +37,30 @@ object TraverseLaws {
 
   inline fun <F> laws(TF: Traverse<F>, FF: Functor<F>, noinline cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>): List<Law> =
     FoldableLaws.laws(TF, cf, Eq.any()) + FunctorLaws.laws(FF, cf, EQ) + listOf(
-      Law("Traverse Laws: Identity", { TF.identityTraverse(FF, cf, EQ) }),
-      Law("Traverse Laws: Sequential composition", { TF.sequentialComposition(cf, EQ) }),
-      Law("Traverse Laws: Parallel composition", { TF.parallelComposition(cf, EQ) }),
-      Law("Traverse Laws: FoldMap derived", { TF.foldMapDerived(cf) })
+      Law("Traverse Laws: Identity") { TF.identityTraverse(FF, cf, EQ) },
+      Law("Traverse Laws: Sequential composition") { TF.sequentialComposition(cf, EQ) },
+      Law("Traverse Laws: Parallel composition") { TF.parallelComposition(cf, EQ) },
+      Law("Traverse Laws: FoldMap derived") { TF.foldMapDerived(cf) }
     )
 
   fun <F> Traverse<F>.identityTraverse(FF: Functor<F>, cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>) = Id.applicative().run {
-    forAll(genFunctionAToB<Int, Kind<ForId, Int>>(genConstructor(genIntSmall(), ::Id)), genConstructor(genIntSmall(), cf), { f: (Int) -> Kind<ForId, Int>, fa: Kind<F, Int> ->
+    forAll(genFunctionAToB<Int, Kind<ForId, Int>>(genConstructor(genIntSmall(), ::Id)), genConstructor(genIntSmall(), cf)) { f: (Int) -> Kind<ForId, Int>, fa: Kind<F, Int> ->
       fa.traverse(this, f).value().equalUnderTheLaw(FF.run { fa.map(f).map { it.value() } }, EQ)
-    })
+    }
   }
 
   fun <F> Traverse<F>.sequentialComposition(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>) = Id.applicative().run {
-    forAll(genFunctionAToB<Int, Kind<ForId, Int>>(genConstructor(genIntSmall(), ::Id)), genFunctionAToB<Int, Kind<ForId, Int>>(genConstructor(genIntSmall(), ::Id)), genConstructor(genIntSmall(), cf), { f: (Int) -> Kind<ForId, Int>, g: (Int) -> Kind<ForId, Int>, fha: Kind<F, Int> ->
+    forAll(genFunctionAToB<Int, Kind<ForId, Int>>(genConstructor(genIntSmall(), ::Id)), genFunctionAToB<Int, Kind<ForId, Int>>(genConstructor(genIntSmall(), ::Id)), genConstructor(genIntSmall(), cf)) { f: (Int) -> Kind<ForId, Int>, g: (Int) -> Kind<ForId, Int>, fha: Kind<F, Int> ->
 
       val fa = fha.traverse(this, f).fix()
-      val composed = fa.map({ it.traverse(this, g) }).value.value()
-      val expected = fha.traverse(ComposedApplicative(this, this), { a: Int -> f(a).map(g).nest() }).unnest().value().value()
+      val composed = fa.map { it.traverse(this, g) }.value.value()
+      val expected = fha.traverse(ComposedApplicative(this, this)) { a: Int -> f(a).map(g).nest() }.unnest().value().value()
       composed.equalUnderTheLaw(expected, EQ)
-    })
+    }
   }
 
   fun <F> Traverse<F>.parallelComposition(cf: (Int) -> Kind<F, Int>, EQ: Eq<Kind<F, Int>>) =
-    forAll(genFunctionAToB<Int, Kind<ForId, Int>>(genConstructor(genIntSmall(), ::Id)), genFunctionAToB<Int, Kind<ForId, Int>>(genConstructor(genIntSmall(), ::Id)), genConstructor(genIntSmall(), cf), { f: (Int) -> Kind<ForId, Int>, g: (Int) -> Kind<ForId, Int>, fha: Kind<F, Int> ->
+    forAll(genFunctionAToB<Int, Kind<ForId, Int>>(genConstructor(genIntSmall(), ::Id)), genFunctionAToB<Int, Kind<ForId, Int>>(genConstructor(genIntSmall(), ::Id)), genConstructor(genIntSmall(), cf)) { f: (Int) -> Kind<ForId, Int>, g: (Int) -> Kind<ForId, Int>, fha: Kind<F, Int> ->
       val TIA = object : Applicative<TIF> {
         override fun <A> just(a: A): Kind<TIF, A> =
           TIC(Id(a) toT Id(a))
@@ -79,16 +79,16 @@ object TraverseLaws {
         }
       }
 
-      val seen: TI<Kind<F, Int>> = fha.traverse(TIA, { TIC(f(it) toT g(it)) }).fix().ti
+      val seen: TI<Kind<F, Int>> = fha.traverse(TIA) { TIC(f(it) toT g(it)) }.fix().ti
       val expected: TI<Kind<F, Int>> = TIC(fha.traverse(Id.applicative(), f) toT fha.traverse(Id.applicative(), g)).ti
 
       seen.equalUnderTheLaw(expected, TIEQ)
-    })
+    }
 
   fun <F> Traverse<F>.foldMapDerived(cf: (Int) -> Kind<F, Int>) =
-    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf), { f: (Int) -> Int, fa: Kind<F, Int> ->
-      val traversed = fa.traverse(Const.applicative(Int.monoid()), { a -> f(a).const() }).value()
+    forAll(genFunctionAToB<Int, Int>(genIntSmall()), genConstructor(genIntSmall(), cf)) { f: (Int) -> Int, fa: Kind<F, Int> ->
+      val traversed = fa.traverse(Const.applicative(Int.monoid())) { a -> f(a).const() }.value()
       val mapped = fa.foldMap(Int.monoid(), f)
       mapped.equalUnderTheLaw(traversed, Eq.any())
-    })
+    }
 }
diff --git a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Applicative.kt b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Applicative.kt
index 0d578eafbd6..7e6c4843de8 100644
--- a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Applicative.kt
+++ b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Applicative.kt
@@ -25,20 +25,20 @@ interface Applicative<F> : Functor<F> {
   fun <A, B, Z> Kind<F, Tuple2<A, B>>.product(
     other: Kind<F, Z>,
     dummyImplicit: Any? = null): Kind<F, Tuple3<A, B, Z>> =
-    other.product(this).map({ Tuple3(it.b.a, it.b.b, it.a) })
+    other.product(this).map { Tuple3(it.b.a, it.b.b, it.a) }
 
   fun <A, B, C, Z> Kind<F, Tuple3<A, B, C>>.product(
     other: Kind<F, Z>,
     dummyImplicit: Any? = null,
     dummyImplicit2: Any? = null): Kind<F, Tuple4<A, B, C, Z>> =
-    other.product(this).map({ Tuple4(it.b.a, it.b.b, it.b.c, it.a) })
+    other.product(this).map { Tuple4(it.b.a, it.b.b, it.b.c, it.a) }
 
   fun <A, B, C, D, Z> Kind<F, Tuple4<A, B, C, D>>.product(
     other: Kind<F, Z>,
     dummyImplicit: Any? = null,
     dummyImplicit2: Any? = null,
     dummyImplicit3: Any? = null): Kind<F, Tuple5<A, B, C, D, Z>> =
-    other.product(this).map({ Tuple5(it.b.a, it.b.b, it.b.c, it.b.d, it.a) })
+    other.product(this).map { Tuple5(it.b.a, it.b.b, it.b.c, it.b.d, it.a) }
 
   fun <A, B, C, D, E, Z> Kind<F, Tuple5<A, B, C, D, E>>.product(
     other: Kind<F, Z>,
@@ -46,7 +46,7 @@ interface Applicative<F> : Functor<F> {
     dummyImplicit2: Any? = null,
     dummyImplicit3: Any? = null,
     dummyImplicit4: Any? = null): Kind<F, Tuple6<A, B, C, D, E, Z>> =
-    other.product(this).map({ Tuple6(it.b.a, it.b.b, it.b.c, it.b.d, it.b.e, it.a) })
+    other.product(this).map { Tuple6(it.b.a, it.b.b, it.b.c, it.b.d, it.b.e, it.a) }
 
   fun <A, B, C, D, E, FF, Z> Kind<F, Tuple6<A, B, C, D, E, FF>>.product(
     other: Kind<F, Z>,
@@ -55,7 +55,7 @@ interface Applicative<F> : Functor<F> {
     dummyImplicit3: Any? = null,
     dummyImplicit4: Any? = null,
     dummyImplicit5: Any? = null): Kind<F, Tuple7<A, B, C, D, E, FF, Z>> =
-    other.product(this).map({ Tuple7(it.b.a, it.b.b, it.b.c, it.b.d, it.b.e, it.b.f, it.a) })
+    other.product(this).map { Tuple7(it.b.a, it.b.b, it.b.c, it.b.d, it.b.e, it.b.f, it.a) }
 
   fun <A, B, C, D, E, FF, G, Z> Kind<F, Tuple7<A, B, C, D, E, FF, G>>.product(
     other: Kind<F, Z>,
@@ -65,7 +65,7 @@ interface Applicative<F> : Functor<F> {
     dummyImplicit4: Any? = null,
     dummyImplicit5: Any? = null,
     dummyImplicit6: Any? = null): Kind<F, Tuple8<A, B, C, D, E, FF, G, Z>> =
-    other.product(this).map({ Tuple8(it.b.a, it.b.b, it.b.c, it.b.d, it.b.e, it.b.f, it.b.g, it.a) })
+    other.product(this).map { Tuple8(it.b.a, it.b.b, it.b.c, it.b.d, it.b.e, it.b.f, it.b.g, it.a) }
 
   fun <A, B, C, D, E, FF, G, H, Z> Kind<F, Tuple8<A, B, C, D, E, FF, G, H>>.product(
     other: Kind<F, Z>,
@@ -76,7 +76,7 @@ interface Applicative<F> : Functor<F> {
     dummyImplicit5: Any? = null,
     dummyImplicit6: Any? = null,
     dummyImplicit7: Any? = null): Kind<F, Tuple9<A, B, C, D, E, FF, G, H, Z>> =
-    other.product(this).map({ Tuple9(it.b.a, it.b.b, it.b.c, it.b.d, it.b.e, it.b.f, it.b.g, it.b.h, it.a) })
+    other.product(this).map { Tuple9(it.b.a, it.b.b, it.b.c, it.b.d, it.b.e, it.b.f, it.b.g, it.b.h, it.a) }
 
   fun <A, B, C, D, E, FF, G, H, I, Z> Kind<F, Tuple9<A, B, C, D, E, FF, G, H, I>>.product(
     other: Kind<F, Z>,
@@ -88,7 +88,7 @@ interface Applicative<F> : Functor<F> {
     dummyImplicit6: Any? = null,
     dummyImplicit7: Any? = null,
     dummyImplicit9: Any? = null): Kind<F, Tuple10<A, B, C, D, E, FF, G, H, I, Z>> =
-    other.product(this).map({ Tuple10(it.b.a, it.b.b, it.b.c, it.b.d, it.b.e, it.b.f, it.b.g, it.b.h, it.b.i, it.a) })
+    other.product(this).map { Tuple10(it.b.a, it.b.b, it.b.c, it.b.d, it.b.e, it.b.f, it.b.g, it.b.h, it.b.i, it.a) }
 
   fun <A, B> tupled(
     a: Kind<F, A>,
diff --git a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Comonad.kt b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Comonad.kt
index a23c239d704..2f28879bb1f 100644
--- a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Comonad.kt
+++ b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Comonad.kt
@@ -36,11 +36,11 @@ open class ComonadContinuation<F, A : Any>(CM: Comonad<F>, override val context:
 
   suspend fun <B> extract(m: () -> Kind<F, B>): B = suspendCoroutineOrReturn { c ->
     val labelHere = c.stateStack // save the whole coroutine stack labels
-    returnedMonad = m().coflatMap({ x: Kind<F, B> ->
+    returnedMonad = m().coflatMap { x: Kind<F, B> ->
       c.stateStack = labelHere
       c.resume(x.extract())
       returnedMonad
-    }).extract()
+    }.extract()
     COROUTINE_SUSPENDED
   }
 }
diff --git a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Monad.kt b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Monad.kt
index 399f355fed3..406e61538a2 100644
--- a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Monad.kt
+++ b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Monad.kt
@@ -14,10 +14,10 @@ interface Monad<F> : Applicative<F> {
   fun <A, B> tailRecM(a: A, f: (A) -> Kind<F, Either<A, B>>): Kind<F, B>
 
   override fun <A, B> Kind<F, A>.map(f: (A) -> B): Kind<F, B> =
-    flatMap({ a -> just(f(a)) })
+    flatMap { a -> just(f(a)) }
 
   override fun <A, B> Kind<F, A>.ap(ff: Kind<F, (A) -> B>): Kind<F, B> =
-    ff.flatMap({ f -> this.map(f) })
+    ff.flatMap { f -> this.map(f) }
 
   fun <A> Kind<F, Kind<F, A>>.flatten(): Kind<F, A> =
     flatMap(::identity)
@@ -29,13 +29,13 @@ interface Monad<F> : Applicative<F> {
     flatMap { fb.value() }
 
   fun <A, B> Kind<F, A>.forEffect(fb: Kind<F, B>): Kind<F, A> =
-    flatMap { a -> fb.map({ a }) }
+    flatMap { a -> fb.map { a } }
 
   fun <A, B> Kind<F, A>.forEffectEval(fb: Eval<Kind<F, B>>): Kind<F, A> =
-    flatMap { a -> fb.value().map({ a }) }
+    flatMap { a -> fb.value().map { a } }
 
   fun <A, B> Kind<F, A>.mproduct(f: (A) -> Kind<F, B>): Kind<F, Tuple2<A, B>> =
-    flatMap { a -> f(a).map({ Tuple2(a, it) }) }
+    flatMap { a -> f(a).map { Tuple2(a, it) } }
 
   fun <B> Kind<F, Boolean>.ifM(ifTrue: () -> Kind<F, B>, ifFalse: () -> Kind<F, B>): Kind<F, B> =
     flatMap { if (it) ifTrue() else ifFalse() }
diff --git a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/MonadContinuations.kt b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/MonadContinuations.kt
index a421a3a5476..d822b56efd7 100644
--- a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/MonadContinuations.kt
+++ b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/MonadContinuations.kt
@@ -54,32 +54,32 @@ open class MonadContinuation<F, A>(M: Monad<F>, override val context: CoroutineC
 
   open suspend fun <B> bind(m: () -> Kind<F, B>): B = suspendCoroutineOrReturn { c ->
     val labelHere = c.stateStack // save the whole coroutine stack labels
-    returnedMonad = m().flatMap({ x: B ->
+    returnedMonad = m().flatMap { x: B ->
       c.stateStack = labelHere
       c.resume(x)
       returnedMonad
-    })
+    }
     COROUTINE_SUSPENDED
   }
 
   open suspend fun <B> bindIn(context: CoroutineContext, m: () -> B): B = suspendCoroutineOrReturn { c ->
     val labelHere = c.stateStack // save the whole coroutine stack labels
     val monadCreation: suspend () -> Kind<F, A> = {
-      just(m()).flatMap({ xx: B ->
+      just(m()).flatMap { xx: B ->
         c.stateStack = labelHere
         c.resume(xx)
         returnedMonad
-      })
+      }
     }
     val completion = bindingInContextContinuation(context)
-    returnedMonad = just(Unit).flatMap({
+    returnedMonad = just(Unit).flatMap {
       monadCreation.startCoroutine(completion)
       val error = completion.await()
       if (error != null) {
         throw error
       }
       returnedMonad
-    })
+    }
     COROUTINE_SUSPENDED
   }
 
diff --git a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/MonadError.kt b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/MonadError.kt
index 06e1b1f18bb..35f7d764e54 100644
--- a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/MonadError.kt
+++ b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/MonadError.kt
@@ -6,10 +6,10 @@ import kotlin.coroutines.experimental.startCoroutine
 interface MonadError<F, E> : ApplicativeError<F, E>, Monad<F> {
 
   fun <A> Kind<F, A>.ensure(error: () -> E, predicate: (A) -> Boolean): Kind<F, A> =
-    this.flatMap({
+    this.flatMap {
       if (predicate(it)) just(it)
       else raiseError(error())
-    })
+    }
 
 }
 
diff --git a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Reducible.kt b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Reducible.kt
index aece88f745e..a82822a670c 100644
--- a/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Reducible.kt
+++ b/modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Reducible.kt
@@ -43,7 +43,7 @@ interface Reducible<F> : Foldable<F> {
   fun <A, B> Kind<F, A>.reduceRightTo(f: (A) -> B, g: (A, Eval<B>) -> Eval<B>): Eval<B>
 
   override fun <A, B> Kind<F, A>.reduceRightToOption(f: (A) -> B, g: (A, Eval<B>) -> Eval<B>): Eval<Option<B>> =
-    reduceRightTo(f, g).map({ Some(it) })
+    reduceRightTo(f, g).map { Some(it) }
 
   override fun <A> Kind<F, A>.isEmpty(): Boolean = false
 
@@ -53,7 +53,7 @@ interface Reducible<F> : Foldable<F> {
    * Reduce a F<A> value using the given Semigroup<A>.
    */
   fun <A> Kind<F, A>.reduce(SG: Semigroup<A>): A = SG.run {
-    reduceLeft({ a, b -> a.combine(b) })
+    reduceLeft { a, b -> a.combine(b) }
   }
 
   /**
@@ -69,7 +69,7 @@ interface Reducible<F> : Foldable<F> {
    * Apply f to each element of fa and combine them using the given Semigroup<B>.
    */
   fun <A, B> Kind<F, A>.reduceMap(SG: Semigroup<B>, f: (A) -> B): B = SG.run {
-    reduceLeftTo(f, { b, a -> b.combine(f(a)) })
+    reduceLeftTo(f) { b, a -> b.combine(f(a)) }
   }
 }
 
@@ -90,20 +90,20 @@ interface NonEmptyReducible<F, G> : Reducible<F> {
   }
 
   override fun <A, B> Kind<F, A>.foldRight(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Eval<B> = FG().run {
-    Eval.Always({ split() }).flatMap { (a, ga) -> f(a, ga.foldRight(lb, f)) }
+    Eval.Always { split() }.flatMap { (a, ga) -> f(a, ga.foldRight(lb, f)) }
   }
 
   override fun <A, B> Kind<F, A>.reduceLeftTo(f: (A) -> B, g: (B, A) -> B): B = FG().run {
     val (a, ga) = split()
-    ga.foldLeft(f(a), { bb, aa -> g(bb, aa) })
+    ga.foldLeft(f(a)) { bb, aa -> g(bb, aa) }
   }
 
   override fun <A, B> Kind<F, A>.reduceRightTo(f: (A) -> B, g: (A, Eval<B>) -> Eval<B>): Eval<B> = FG().run {
-    Eval.Always({ split() }).flatMap { (a, ga) ->
+    Eval.Always { split() }.flatMap { (a, ga) ->
       ga.reduceRightToOption(f, g).flatMap { option ->
         when (option) {
           is Some<B> -> g(a, Eval.Now(option.t))
-          is None -> Eval.Later({ f(a) })
+          is None -> Eval.Later { f(a) }
         }
       }
     }
@@ -142,6 +142,6 @@ interface NonEmptyReducible<F, G> : Reducible<F> {
 
   fun <A, B> Kind<F, A>.foldM_(M: Monad<G>, z: B, f: (B, A) -> Kind<G, B>): Kind<G, B> = M.run {
     val (a, ga) = split()
-    return f(z, a).flatMap({ FG().run { ga.foldM(M, it, f) } })
+    return f(z, a).flatMap { FG().run { ga.foldM(M, it, f) } }
   }
 }
diff --git a/modules/docs/arrow-examples/src/test/kotlin/arrow/DataTypeExamples.kt b/modules/docs/arrow-examples/src/test/kotlin/arrow/DataTypeExamples.kt
index 27949c74593..84458e63167 100644
--- a/modules/docs/arrow-examples/src/test/kotlin/arrow/DataTypeExamples.kt
+++ b/modules/docs/arrow-examples/src/test/kotlin/arrow/DataTypeExamples.kt
@@ -130,7 +130,7 @@ class DataTypeExamples : FreeSpec() { init {
 
     "Functor" {
       // Transforming the value, if the computation is a success:
-      val actual = Try.functor().run { Try { "3".toInt() }.map({ it + 1 }) }
+      val actual = Try.functor().run { Try { "3".toInt() }.map { it + 1 } }
       actual shouldBe Try.Success(4)
     }
 
diff --git a/modules/effects/arrow-effects-rx2/src/main/kotlin/arrow/effects/MaybeK.kt b/modules/effects/arrow-effects-rx2/src/main/kotlin/arrow/effects/MaybeK.kt
index 379cb9a77bc..df4b518cc1f 100644
--- a/modules/effects/arrow-effects-rx2/src/main/kotlin/arrow/effects/MaybeK.kt
+++ b/modules/effects/arrow-effects-rx2/src/main/kotlin/arrow/effects/MaybeK.kt
@@ -65,7 +65,7 @@ data class MaybeK<A>(val maybe: Maybe<A>) : MaybeKOf<A>, MaybeKKindedJ<A> {
       Maybe.defer { fa().value() }.k()
 
     fun <A> async(fa: Proc<A>): MaybeK<A> =
-      Maybe.create({ emitter: MaybeEmitter<A> ->
+      Maybe.create { emitter: MaybeEmitter<A> ->
         fa { either: Either<Throwable, A> ->
           either.fold({
             emitter.onError(it)
@@ -74,7 +74,7 @@ data class MaybeK<A>(val maybe: Maybe<A>) : MaybeKOf<A>, MaybeKKindedJ<A> {
           })
 
         }
-      }).k()
+      }.k()
 
     tailrec fun <A, B> tailRecM(a: A, f: (A) -> MaybeKOf<Either<A, B>>): MaybeK<B> {
       val either = f(a).fix().value().blockingGet()
diff --git a/modules/effects/arrow-effects-rx2/src/main/kotlin/arrow/effects/SingleK.kt b/modules/effects/arrow-effects-rx2/src/main/kotlin/arrow/effects/SingleK.kt
index a36a3ed44f7..1fe2e08743e 100644
--- a/modules/effects/arrow-effects-rx2/src/main/kotlin/arrow/effects/SingleK.kt
+++ b/modules/effects/arrow-effects-rx2/src/main/kotlin/arrow/effects/SingleK.kt
@@ -49,7 +49,7 @@ data class SingleK<A>(val single: Single<A>) : SingleKOf<A>, SingleKKindedJ<A> {
       Single.defer { fa().value() }.k()
 
     fun <A> async(fa: Proc<A>): SingleK<A> =
-      Single.create({ emitter: SingleEmitter<A> ->
+      Single.create { emitter: SingleEmitter<A> ->
         fa { either: Either<Throwable, A> ->
           either.fold({
             emitter.onError(it)
@@ -58,7 +58,7 @@ data class SingleK<A>(val single: Single<A>) : SingleKOf<A>, SingleKKindedJ<A> {
           })
 
         }
-      }).k()
+      }.k()
 
     tailrec fun <A, B> tailRecM(a: A, f: (A) -> SingleKOf<Either<A, B>>): SingleK<B> {
       val either = f(a).fix().value().blockingGet()
diff --git a/modules/effects/arrow-effects/src/main/kotlin/arrow/effects/IOParallel.kt b/modules/effects/arrow-effects/src/main/kotlin/arrow/effects/IOParallel.kt
index daf8c2119af..93e084f3e45 100644
--- a/modules/effects/arrow-effects/src/main/kotlin/arrow/effects/IOParallel.kt
+++ b/modules/effects/arrow-effects/src/main/kotlin/arrow/effects/IOParallel.kt
@@ -7,46 +7,46 @@ import arrow.effects.internal.parMap3
 import kotlin.coroutines.experimental.CoroutineContext
 
 fun <A, B, C> IO.Companion.parallelMapN(ctx: CoroutineContext, ioA: IO<A>, ioB: IO<B>, f: (A, B) -> C): IO<C> =
-  IO.async(IO.effect().parMap2(ctx, ioA, ioB, f, /* see parMap2 notes on this parameter */ { it.fix().unsafeRunSync() }))
+  IO.async(IO.effect().parMap2(ctx, ioA, ioB, f /* see parMap2 notes on this parameter */) { it.fix().unsafeRunSync() })
 
 fun <A, B, C, D> IO.Companion.parallelMapN(ctx: CoroutineContext, ioA: IO<A>, ioB: IO<B>, ioC: IO<C>, f: (A, B, C) -> D): IO<D> =
-  IO.async(IO.effect().parMap3(ctx, ioA, ioB, ioC, f, /* see parMap2 notes on this parameter */ { it.fix().unsafeRunSync() }))
+  IO.async(IO.effect().parMap3(ctx, ioA, ioB, ioC, f /* see parMap2 notes on this parameter */) { it.fix().unsafeRunSync() })
 
 fun <A, B, C, D, E> IO.Companion.parallelMapN(ctx: CoroutineContext, ioA: IO<A>, ioB: IO<B>, ioC: IO<C>, ioD: IO<D>, f: (A, B, C, D) -> E): IO<E> =
   parallelMapN(ctx,
     parallelMapN(ctx, ioA, ioB, ::Tuple2),
-    parallelMapN(ctx, ioC, ioD, ::Tuple2),
-    { ab, cd -> f(ab.a, ab.b, cd.a, cd.b) })
+    parallelMapN(ctx, ioC, ioD, ::Tuple2)
+  ) { ab, cd -> f(ab.a, ab.b, cd.a, cd.b) }
 
 fun <A, B, C, D, E, F> IO.Companion.parallelMapN(ctx: CoroutineContext, ioA: IO<A>, ioB: IO<B>, ioC: IO<C>, ioD: IO<D>, ioE: IO<E>, f: (A, B, C, D, E) -> F): IO<F> =
   parallelMapN(ctx,
     parallelMapN(ctx, ioA, ioB, ioC, ::Tuple3),
-    parallelMapN(ctx, ioD, ioE, ::Tuple2),
-    { abc, de -> f(abc.a, abc.b, abc.c, de.a, de.b) })
+    parallelMapN(ctx, ioD, ioE, ::Tuple2)
+  ) { abc, de -> f(abc.a, abc.b, abc.c, de.a, de.b) }
 
 fun <A, B, C, D, E, F, G> IO.Companion.parallelMapN(ctx: CoroutineContext, ioA: IO<A>, ioB: IO<B>, ioC: IO<C>, ioD: IO<D>, ioE: IO<E>, ioF: IO<F>, f: (A, B, C, D, E, F) -> G): IO<G> =
   parallelMapN(ctx,
     parallelMapN(ctx, ioA, ioB, ioC, ::Tuple3),
-    parallelMapN(ctx, ioD, ioE, ioF, ::Tuple3),
-    { abc, def -> f(abc.a, abc.b, abc.c, def.a, def.b, def.c) })
+    parallelMapN(ctx, ioD, ioE, ioF, ::Tuple3)
+  ) { abc, def -> f(abc.a, abc.b, abc.c, def.a, def.b, def.c) }
 
 fun <A, B, C, D, E, F, G, H> IO.Companion.parallelMapN(ctx: CoroutineContext, ioA: IO<A>, ioB: IO<B>, ioC: IO<C>, ioD: IO<D>, ioE: IO<E>, ioF: IO<F>, ioG: IO<G>, f: (A, B, C, D, E, F, G) -> H): IO<H> =
   parallelMapN(ctx,
     parallelMapN(ctx, ioA, ioB, ioC, ::Tuple3),
     parallelMapN(ctx, ioD, ioE, ::Tuple2),
-    parallelMapN(ctx, ioF, ioG, ::Tuple2),
-    { abc, de, fg -> f(abc.a, abc.b, abc.c, de.a, de.b, fg.a, fg.b) })
+    parallelMapN(ctx, ioF, ioG, ::Tuple2)
+  ) { abc, de, fg -> f(abc.a, abc.b, abc.c, de.a, de.b, fg.a, fg.b) }
 
 fun <A, B, C, D, E, F, G, H, I> IO.Companion.parallelMapN(ctx: CoroutineContext, ioA: IO<A>, ioB: IO<B>, ioC: IO<C>, ioD: IO<D>, ioE: IO<E>, ioF: IO<F>, ioG: IO<G>, ioH: IO<H>, f: (A, B, C, D, E, F, G, H) -> I): IO<I> =
   parallelMapN(ctx,
     parallelMapN(ctx, ioA, ioB, ioC, ::Tuple3),
     parallelMapN(ctx, ioD, ioE, ioF, ::Tuple3),
-    parallelMapN(ctx, ioG, ioH, ::Tuple2),
-    { abc, def, gh -> f(abc.a, abc.b, abc.c, def.a, def.b, def.c, gh.a, gh.b) })
+    parallelMapN(ctx, ioG, ioH, ::Tuple2)
+  ) { abc, def, gh -> f(abc.a, abc.b, abc.c, def.a, def.b, def.c, gh.a, gh.b) }
 
 fun <A, B, C, D, E, F, G, H, I, J> IO.Companion.parallelMapN(ctx: CoroutineContext, ioA: IO<A>, ioB: IO<B>, ioC: IO<C>, ioD: IO<D>, ioE: IO<E>, ioF: IO<F>, ioG: IO<G>, ioH: IO<H>, ioI: IO<I>, f: (A, B, C, D, E, F, G, H, I) -> J): IO<J> =
   parallelMapN(ctx,
     parallelMapN(ctx, ioA, ioB, ioC, ::Tuple3),
     parallelMapN(ctx, ioD, ioE, ioF, ::Tuple3),
-    parallelMapN(ctx, ioG, ioH, ioI, ::Tuple3),
-    { abc, def, ghi -> f(abc.a, abc.b, abc.c, def.a, def.b, def.c, ghi.a, ghi.b, ghi.c) })
+    parallelMapN(ctx, ioG, ioH, ioI, ::Tuple3)
+  ) { abc, def, ghi -> f(abc.a, abc.b, abc.c, def.a, def.b, def.c, ghi.a, ghi.b, ghi.c) }
diff --git a/modules/effects/arrow-effects/src/main/kotlin/arrow/effects/typeclasses/MonadSuspendCancellableContinuations.kt b/modules/effects/arrow-effects/src/main/kotlin/arrow/effects/typeclasses/MonadSuspendCancellableContinuations.kt
index bc02ee280be..ed9dbafa817 100644
--- a/modules/effects/arrow-effects/src/main/kotlin/arrow/effects/typeclasses/MonadSuspendCancellableContinuations.kt
+++ b/modules/effects/arrow-effects/src/main/kotlin/arrow/effects/typeclasses/MonadSuspendCancellableContinuations.kt
@@ -37,14 +37,14 @@ open class MonadDeferCancellableContinuation<F, A>(SC: MonadDefer<F>, override v
 
   override suspend fun <B> bind(m: () -> Kind<F, B>): B = suspendCoroutineOrReturn { c ->
     val labelHere = c.stateStack // save the whole coroutine stack labels
-    returnedMonad = m().flatMap({ x: B ->
+    returnedMonad = m().flatMap { x: B ->
       c.stateStack = labelHere
       if (cancelled.get()) {
         throw BindingCancellationException()
       }
       c.resume(x)
       returnedMonad
-    })
+    }
     COROUTINE_SUSPENDED
   }
 
@@ -56,24 +56,24 @@ open class MonadDeferCancellableContinuation<F, A>(SC: MonadDefer<F>, override v
       } catch (t: Throwable) {
         ME.raiseError<B>(t)
       }
-      datatype.flatMap({ xx: B ->
+      datatype.flatMap { xx: B ->
         c.stateStack = labelHere
         if (cancelled.get()) {
           throw BindingCancellationException()
         }
         c.resume(xx)
         returnedMonad
-      })
+      }
     }
     val completion = bindingInContextContinuation(context)
-    returnedMonad = just(Unit).flatMap({
+    returnedMonad = just(Unit).flatMap {
       monadCreation.startCoroutine(completion)
       val error = completion.await()
       if (error != null) {
         throw error
       }
       returnedMonad
-    })
+    }
     COROUTINE_SUSPENDED
   }
 }
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Fold.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Fold.kt
index d0e29027681..c00cc889be5 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Fold.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Fold.kt
@@ -71,7 +71,7 @@ interface Fold<S, A> : FoldOf<S, A> {
   /**
    * Check if there is no target
    */
-  fun isEmpty(s: S): Boolean = foldMap(AndMonoid, s, { _ -> false })
+  fun isEmpty(s: S): Boolean = foldMap(AndMonoid, s) { _ -> false }
 
   /**
    * Check if there is at least one target
@@ -81,12 +81,12 @@ interface Fold<S, A> : FoldOf<S, A> {
   /**
    * Get the first target
    */
-  fun headOption(s: S): Option<A> = foldMap(firstOptionMonoid<A>(), s, { b -> Const(Some(b)) }).value
+  fun headOption(s: S): Option<A> = foldMap(firstOptionMonoid<A>(), s) { b -> Const(Some(b)) }.value
 
   /**
    * Get the last target
    */
-  fun lastOption(s: S): Option<A> = foldMap(lastOptionMonoid<A>(), s, { b -> Const(Some(b)) }).value
+  fun lastOption(s: S): Option<A> = foldMap(lastOptionMonoid<A>(), s) { b -> Const(Some(b)) }.value
 
   /**
    * Fold using the given [Monoid] instance.
@@ -101,7 +101,7 @@ interface Fold<S, A> : FoldOf<S, A> {
   /**
    * Get all targets of the [Fold]
    */
-  fun getAll(s: S): ListK<A> = foldMap(ListK.monoid(), s, { ListK.just(it) })
+  fun getAll(s: S): ListK<A> = foldMap(ListK.monoid(), s) { ListK.just(it) }
 
   /**
    * Join two [Fold] with the same target
@@ -116,7 +116,7 @@ interface Fold<S, A> : FoldOf<S, A> {
    */
   fun <C> left(): Fold<Either<S, C>, Either<A, C>> = object : Fold<Either<S, C>, Either<A, C>> {
     override fun <R> foldMap(M: Monoid<R>, s: Either<S, C>, f: (Either<A, C>) -> R): R =
-      s.fold({ a1: S -> this@Fold.foldMap(M, a1, { b -> f(Either.Left(b)) }) }, { c -> f(Either.Right(c)) })
+      s.fold({ a1: S -> this@Fold.foldMap(M, a1) { b -> f(Either.Left(b)) } }, { c -> f(Either.Right(c)) })
   }
 
   /**
@@ -124,7 +124,7 @@ interface Fold<S, A> : FoldOf<S, A> {
    */
   fun <C> right(): Fold<Either<C, S>, Either<C, A>> = object : Fold<Either<C, S>, Either<C, A>> {
     override fun <R> foldMap(M: Monoid<R>, s: Either<C, S>, f: (Either<C, A>) -> R): R =
-      s.fold({ c -> f(Either.Left(c)) }, { a1 -> this@Fold.foldMap(M, a1, { b -> f(Either.Right(b)) }) })
+      s.fold({ c -> f(Either.Left(c)) }, { a1 -> this@Fold.foldMap(M, a1) { b -> f(Either.Right(b)) } })
   }
 
   /**
@@ -132,7 +132,7 @@ interface Fold<S, A> : FoldOf<S, A> {
    */
   infix fun <C> compose(other: Fold<A, C>): Fold<S, C> = object : Fold<S, C> {
     override fun <R> foldMap(M: Monoid<R>, s: S, f: (C) -> R): R =
-      this@Fold.foldMap(M, s, { c -> other.foldMap(M, c, f) })
+      this@Fold.foldMap(M, s) { c -> other.foldMap(M, c, f) }
   }
 
   /**
@@ -186,7 +186,7 @@ interface Fold<S, A> : FoldOf<S, A> {
    * Find the first element matching the predicate, if one exists.
    */
   fun find(s: S, p: (A) -> Boolean): Option<A> =
-    foldMap(firstOptionMonoid<A>(), s, { b -> (if (p(b)) Const(Some(b)) else Const(None)) }).value
+    foldMap(firstOptionMonoid<A>(), s) { b -> (if (p(b)) Const(Some(b)) else Const(None)) }.value
 
   /**
    * Check whether at least one element satisfies the predicate.
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Iso.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Iso.kt
index 470c3c5f0f7..8d909f4136c 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Iso.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Iso.kt
@@ -220,7 +220,7 @@ interface PIso<S, T, A, B> : PIsoOf<S, T, A, B> {
   /**
    * View a [PIso] as a [PLens]
    */
-  fun asLens(): PLens<S, T, A, B> = PLens(this::get, { b -> { _ -> set(b) } })
+  fun asLens(): PLens<S, T, A, B> = PLens(this::get) { b -> { _ -> set(b) } }
 
   /**
    * View a [PIso] as a [Getter]
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Lens.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Lens.kt
index c6c2bf6072b..3f5f827b8f5 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Lens.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Lens.kt
@@ -67,7 +67,7 @@ interface PLens<S, T, A, B> : PLensOf<S, T, A, B> {
    * Modify the focus of a [PLens] using Functor function
    */
   fun <F> modifyF(FF: Functor<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> = FF.run {
-    f(get(s)).map({ b -> set(s, b) })
+    f(get(s)).map { b -> set(s, b) }
   }
 
   /**
@@ -200,7 +200,7 @@ interface PLens<S, T, A, B> : PLensOf<S, T, A, B> {
    */
   fun asTraversal(): PTraversal<S, T, A, B> = object : PTraversal<S, T, A, B> {
     override fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> = FA.run {
-      f(get(s)).map({ b -> this@PLens.set(s, b) })
+      f(get(s)).map { b -> this@PLens.set(s, b) }
     }
   }
 
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Optional.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Optional.kt
index fdc38f9e668..9d48fc0753a 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Optional.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Optional.kt
@@ -91,9 +91,8 @@ interface POptional<S, T, A, B> : POptionalOf<S, T, A, B> {
    */
   fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> = FA.run {
     getOrModify(s).fold(
-      ::just,
-      { f(it).map({ set(s, it) }) }
-    )
+      ::just
+    ) { f(it).map { set(s, it) } }
   }
 
   /**
@@ -236,7 +235,7 @@ interface POptional<S, T, A, B> : POptionalOf<S, T, A, B> {
   /**
    * Modify the focus of a [POptional] with a function [f]
    */
-  fun modify(s: S, f: (A) -> B): T = getOrModify(s).fold(::identity, { a -> set(s, f(a)) })
+  fun modify(s: S, f: (A) -> B): T = getOrModify(s).fold(::identity) { a -> set(s, f(a)) }
 
   /**
    * Lift a function [f]: `(A) -> B to the context of `S`: `(S) -> T`
@@ -247,7 +246,7 @@ interface POptional<S, T, A, B> : POptionalOf<S, T, A, B> {
    * Modify the focus of a [POptional] with a function [f]
    * @return [Option.None] if the [POptional] is not matching
    */
-  fun modifiyOption(s: S, f: (A) -> B): Option<T> = getOption(s).map({ set(s, f(it)) })
+  fun modifiyOption(s: S, f: (A) -> B): Option<T> = getOption(s).map { set(s, f(it)) }
 
   /**
    * Find the focus that satisfies the predicate [p]
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Prism.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Prism.kt
index d9c8476a123..1c55769c799 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Prism.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Prism.kt
@@ -87,9 +87,8 @@ interface PPrism<S, T, A, B> : PPrismOf<S, T, A, B> {
    */
   fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> = FA.run {
     getOrModify(s).fold(
-      ::just,
-      { f(it).map(::reverseGet) }
-    )
+      ::just
+    ) { f(it).map(::reverseGet) }
   }
 
   /**
@@ -98,9 +97,8 @@ interface PPrism<S, T, A, B> : PPrismOf<S, T, A, B> {
   fun <F> liftF(FA: Applicative<F>, f: (A) -> Kind<F, B>): (S) -> Kind<F, T> = FA.run {
     { s ->
       getOrModify(s).fold(
-        ::just,
-        { f(it).map(::reverseGet) }
-      )
+        ::just
+      ) { f(it).map(::reverseGet) }
     }
   }
 
@@ -204,9 +202,8 @@ interface PPrism<S, T, A, B> : PPrismOf<S, T, A, B> {
    * View a [PPrism] as an [POptional]
    */
   fun asOptional(): POptional<S, T, A, B> = POptional(
-    this::getOrModify,
-    { b -> { s -> set(s, b) } }
-  )
+    this::getOrModify
+  ) { b -> { s -> set(s, b) } }
 
   /**
    * View a [PPrism] as a [PSetter]
@@ -226,9 +223,8 @@ interface PPrism<S, T, A, B> : PPrismOf<S, T, A, B> {
   fun asTraversal(): PTraversal<S, T, A, B> = object : PTraversal<S, T, A, B> {
     override fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> = FA.run {
       getOrModify(s).fold(
-        ::just,
-        { f(it).map(this@PPrism::reverseGet) }
-      )
+        ::just
+      ) { f(it).map(this@PPrism::reverseGet) }
     }
   }
 }
@@ -236,12 +232,12 @@ interface PPrism<S, T, A, B> : PPrismOf<S, T, A, B> {
 /**
  * Modify the focus of a [PPrism] with a function
  */
-inline fun <S, T, A, B> PPrism<S, T, A, B>.modify(s: S, crossinline f: (A) -> B): T = getOrModify(s).fold(::identity, { a -> reverseGet(f(a)) })
+inline fun <S, T, A, B> PPrism<S, T, A, B>.modify(s: S, crossinline f: (A) -> B): T = getOrModify(s).fold(::identity) { a -> reverseGet(f(a)) }
 
 /**
  * Lift a function [f]: `(A) -> B to the context of `S`: `(S) -> T`
  */
-inline fun <S, T, A, B> PPrism<S, T, A, B>.lift(crossinline f: (A) -> B): (S) -> T = { s -> getOrModify(s).fold(::identity, { a -> reverseGet(f(a)) }) }
+inline fun <S, T, A, B> PPrism<S, T, A, B>.lift(crossinline f: (A) -> B): (S) -> T = { s -> getOrModify(s).fold(::identity) { a -> reverseGet(f(a)) } }
 
 /**
  * Modify the focus of a [PPrism] with a function
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Traversal.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Traversal.kt
index 185560d3401..9ecbde1cd56 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Traversal.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/Traversal.kt
@@ -39,7 +39,7 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
 
     fun <S> codiagonal(): Traversal<Either<S, S>, S> = object : Traversal<Either<S, S>, S> {
       override fun <F> modifyF(FA: Applicative<F>, s: Either<S, S>, f: (S) -> Kind<F, S>): Kind<F, Either<S, S>> = FA.run {
-        s.bimap(f, f).fold({ fa -> fa.map({ a -> Either.Left(a) }) }, { fa -> fa.map({ a -> Either.Right(a) }) })
+        s.bimap(f, f).fold({ fa -> fa.map { a -> Either.Left(a) } }, { fa -> fa.map { a -> Either.Right(a) } })
       }
     }
 
@@ -62,9 +62,8 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
     operator fun <S, T, A, B> invoke(get1: (S) -> A, get2: (S) -> A, set: (B, B, S) -> T): PTraversal<S, T, A, B> = object : PTraversal<S, T, A, B> {
       override fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> =
         FA.map(
-          f(get1(s)), f(get2(s)),
-          { (b1, b2) -> set(b1, b2, s) }
-        )
+          f(get1(s)), f(get2(s))
+        ) { (b1, b2) -> set(b1, b2, s) }
     }
 
     operator fun <S, T, A, B> invoke(
@@ -74,9 +73,8 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
       set: (B, B, B, S) -> T): PTraversal<S, T, A, B> = object : PTraversal<S, T, A, B> {
       override fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> =
         FA.map(
-          f(get1(s)), f(get2(s)), f(get3(s)),
-          { (b1, b2, b3) -> set(b1, b2, b3, s) }
-        )
+          f(get1(s)), f(get2(s)), f(get3(s))
+        ) { (b1, b2, b3) -> set(b1, b2, b3, s) }
     }
 
     operator fun <S, T, A, B> invoke(
@@ -87,9 +85,8 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
       set: (B, B, B, B, S) -> T): PTraversal<S, T, A, B> = object : PTraversal<S, T, A, B> {
       override fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> =
         FA.map(
-          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)),
-          { (b1, b2, b3, b4) -> set(b1, b2, b3, b4, s) }
-        )
+          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s))
+        ) { (b1, b2, b3, b4) -> set(b1, b2, b3, b4, s) }
     }
 
     operator fun <S, T, A, B> invoke(
@@ -101,9 +98,8 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
       set: (B, B, B, B, B, S) -> T): PTraversal<S, T, A, B> = object : PTraversal<S, T, A, B> {
       override fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> =
         FA.map(
-          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s)),
-          { (b1, b2, b3, b4, b5) -> set(b1, b2, b3, b4, b5, s) }
-        )
+          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s))
+        ) { (b1, b2, b3, b4, b5) -> set(b1, b2, b3, b4, b5, s) }
     }
 
     operator fun <S, T, A, B> invoke(
@@ -116,9 +112,8 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
       set: (B, B, B, B, B, B, S) -> T): PTraversal<S, T, A, B> = object : PTraversal<S, T, A, B> {
       override fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> =
         FA.map(
-          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s)), f(get6(s)),
-          { (b1, b2, b3, b4, b5, b6) -> set(b1, b2, b3, b4, b5, b6, s) }
-        )
+          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s)), f(get6(s))
+        ) { (b1, b2, b3, b4, b5, b6) -> set(b1, b2, b3, b4, b5, b6, s) }
     }
 
     operator fun <S, T, A, B> invoke(
@@ -132,9 +127,8 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
       set: (B, B, B, B, B, B, B, S) -> T): PTraversal<S, T, A, B> = object : PTraversal<S, T, A, B> {
       override fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> =
         FA.map(
-          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s)), f(get6(s)), f(get7(s)),
-          { (b1, b2, b3, b4, b5, b6, b7) -> set(b1, b2, b3, b4, b5, b6, b7, s) }
-        )
+          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s)), f(get6(s)), f(get7(s))
+        ) { (b1, b2, b3, b4, b5, b6, b7) -> set(b1, b2, b3, b4, b5, b6, b7, s) }
     }
 
     operator fun <S, T, A, B> invoke(
@@ -149,9 +143,8 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
       set: (B, B, B, B, B, B, B, B, S) -> T): PTraversal<S, T, A, B> = object : PTraversal<S, T, A, B> {
       override fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> =
         FA.map(
-          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s)), f(get6(s)), f(get7(s)), f(get8(s)),
-          { (b1, b2, b3, b4, b5, b6, b7, b8) -> set(b1, b2, b3, b4, b5, b6, b7, b8, s) }
-        )
+          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s)), f(get6(s)), f(get7(s)), f(get8(s))
+        ) { (b1, b2, b3, b4, b5, b6, b7, b8) -> set(b1, b2, b3, b4, b5, b6, b7, b8, s) }
     }
 
     operator fun <S, T, A, B> invoke(
@@ -167,9 +160,8 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
       set: (B, B, B, B, B, B, B, B, B, S) -> T): PTraversal<S, T, A, B> = object : PTraversal<S, T, A, B> {
       override fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> =
         FA.map(
-          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s)), f(get6(s)), f(get7(s)), f(get8(s)), f(get9(s)),
-          { (b1, b2, b3, b4, b5, b6, b7, b8, b9) -> set(b1, b2, b3, b4, b5, b6, b7, b8, b9, s) }
-        )
+          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s)), f(get6(s)), f(get7(s)), f(get8(s)), f(get9(s))
+        ) { (b1, b2, b3, b4, b5, b6, b7, b8, b9) -> set(b1, b2, b3, b4, b5, b6, b7, b8, b9, s) }
     }
 
     operator fun <S, T, A, B> invoke(
@@ -186,9 +178,8 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
       set: (B, B, B, B, B, B, B, B, B, B, S) -> T): PTraversal<S, T, A, B> = object : PTraversal<S, T, A, B> {
       override fun <F> modifyF(FA: Applicative<F>, s: S, f: (A) -> Kind<F, B>): Kind<F, T> =
         FA.map(
-          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s)), f(get6(s)), f(get7(s)), f(get8(s)), f(get9(s)), f(get10(s)),
-          { (b1, b2, b3, b4, b5, b6, b7, b8, b9, b10) -> set(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, s) }
-        )
+          f(get1(s)), f(get2(s)), f(get3(s)), f(get4(s)), f(get5(s)), f(get6(s)), f(get7(s)), f(get8(s)), f(get9(s)), f(get10(s))
+        ) { (b1, b2, b3, b4, b5, b6, b7, b8, b9, b10) -> set(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, s) }
     }
 
   }
@@ -197,7 +188,7 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
    * Map each target to a Monoid and combine the results
    */
   fun <R> foldMap(M: Monoid<R>, s: S, f: (A) -> R): R =
-    modifyF(Const.applicative(M, Unit), s, { b -> Const(f(b)) }).value()
+    modifyF(Const.applicative(M, Unit), s) { b -> Const(f(b)) }.value()
 
   /**
    * Fold using the given [Monoid] instance.
@@ -212,7 +203,7 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
   /**
    * Get all foci of the [PTraversal]
    */
-  fun getAll(s: S): ListK<A> = foldMap(ListK.monoid(), s, { ListK(listOf(it)) })
+  fun getAll(s: S): ListK<A> = foldMap(ListK.monoid(), s) { ListK(listOf(it)) }
 
   /**
    * Set polymorphically the target of a [PTraversal] with a value
@@ -222,12 +213,12 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
   /**
    * Calculate the number of targets in the [PTraversal]
    */
-  fun size(s: S): Int = foldMap(Int.monoid(), s, { 1 })
+  fun size(s: S): Int = foldMap(Int.monoid(), s) { 1 }
 
   /**
    * Check if there is no target
    */
-  fun isEmpty(s: S): Boolean = foldMap(AndMonoid, s, { _ -> false })
+  fun isEmpty(s: S): Boolean = foldMap(AndMonoid, s) { _ -> false }
 
   /**
    * Check if there is at least one target
@@ -237,12 +228,12 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
   /**
    * Find the first target or [Option.None] if no targets
    */
-  fun headOption(s: S): Option<A> = foldMap(firstOptionMonoid<A>(), s, { b -> Const(Some(b)) }).value
+  fun headOption(s: S): Option<A> = foldMap(firstOptionMonoid<A>(), s) { b -> Const(Some(b)) }.value
 
   /**
    * Find the first target or [Option.None] if no targets
    */
-  fun lastOption(s: S): Option<A> = foldMap(lastOptionMonoid<A>(), s, { b -> Const(Some(b)) }).value
+  fun lastOption(s: S): Option<A> = foldMap(lastOptionMonoid<A>(), s) { b -> Const(Some(b)) }.value
 
   fun <U, V> choice(other: PTraversal<U, V, A, B>): PTraversal<Either<S, U>, Either<T, V>, A, B> = object : PTraversal<Either<S, U>, Either<T, V>, A, B> {
     override fun <F> modifyF(FA: Applicative<F>, s: Either<S, U>, f: (A) -> Kind<F, B>): Kind<F, Either<T, V>> = FA.run {
@@ -258,7 +249,7 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
    */
   infix fun <C, D> compose(other: PTraversal<A, B, C, D>): PTraversal<S, T, C, D> = object : PTraversal<S, T, C, D> {
     override fun <F> modifyF(FA: Applicative<F>, s: S, f: (C) -> Kind<F, D>): Kind<F, T> =
-      this@PTraversal.modifyF(FA, s, { b -> other.modifyF(FA, b, f) })
+      this@PTraversal.modifyF(FA, s) { b -> other.modifyF(FA, b, f) }
   }
 
   /**
@@ -318,21 +309,21 @@ interface PTraversal<S, T, A, B> : PTraversalOf<S, T, A, B> {
   /**
    * Find the first target matching the predicate
    */
-  fun find(s: S, p: (A) -> Boolean): Option<A> = foldMap(firstOptionMonoid<A>(), s, { a ->
+  fun find(s: S, p: (A) -> Boolean): Option<A> = foldMap(firstOptionMonoid<A>(), s) { a ->
     if (p(a)) Const(Some(a))
     else Const(None)
-  }).value
+  }.value
 
   /**
    * Map each target to a Monoid and combine the results
    */
   fun <R> foldMap(s: S, f: (A) -> R, M: Monoid<R>): R =
-    modifyF(Const.applicative(M), s, { b -> Const(f(b)) }).value()
+    modifyF(Const.applicative(M), s) { b -> Const(f(b)) }.value()
 
   /**
    * Modify polymorphically the target of a [PTraversal] with a function [f]
    */
-  fun modify(s: S, f: (A) -> B): T = modifyF(Id.applicative(), s, { b -> Id(f(b)) }).value()
+  fun modify(s: S, f: (A) -> B): T = modifyF(Id.applicative(), s) { b -> Id(f(b)) }.value()
 
   /**
    * Check whether at least one element satisfies the predicate.
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/list.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/list.kt
index 4d43e28605a..9a35e22509d 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/list.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/list.kt
@@ -60,9 +60,9 @@ fun <A> ListInstances.filterIndex(): FilterIndex<List<A>, Int, A> = ListFilterIn
 interface ListFilterIndexInstance<A> : FilterIndex<List<A>, Int, A> {
   override fun filter(p: (Int) -> Boolean): Traversal<List<A>, A> = object : Traversal<List<A>, A> {
     override fun <F> modifyF(FA: Applicative<F>, s: List<A>, f: (A) -> Kind<F, A>): Kind<F, List<A>> = FA.run {
-      s.mapIndexed { index, a -> a toT index }.k().traverse(FA, { (a, j) ->
+      s.mapIndexed { index, a -> a toT index }.k().traverse(FA) { (a, j) ->
         if (p(j)) f(a) else just(a)
-      }).map { it.list }
+      }.map { it.list }
     }
   }
 
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/listk.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/listk.kt
index 3941caf79f0..e7db433537b 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/listk.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/listk.kt
@@ -39,9 +39,9 @@ interface ListKEachInstance<A> : Each<ListK<A>, A> {
 interface ListKFilterIndexInstance<A> : FilterIndex<ListK<A>, Int, A> {
   override fun filter(p: (Int) -> Boolean): Traversal<ListK<A>, A> = object : Traversal<ListK<A>, A> {
     override fun <F> modifyF(FA: Applicative<F>, s: ListK<A>, f: (A) -> Kind<F, A>): Kind<F, ListK<A>> = FA.run {
-      s.mapIndexed { index, a -> a toT index }.k().traverse(FA, { (a, j) ->
+      s.mapIndexed { index, a -> a toT index }.k().traverse(FA) { (a, j) ->
         if (p(j)) f(a) else just(a)
-      })
+      }
     }
   }
 }
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/map.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/map.kt
index 13ad0e7947c..ccbab550ae9 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/map.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/map.kt
@@ -85,11 +85,11 @@ fun <K, V> MapInstances.filterIndex(): FilterIndex<Map<K, V>, K, V> = MapFilterI
 interface MapFilterIndexInstance<K, V> : FilterIndex<Map<K, V>, K, V> {
   override fun filter(p: Predicate<K>) = object : Traversal<Map<K, V>, V> {
     override fun <F> modifyF(FA: Applicative<F>, s: Map<K, V>, f: (V) -> Kind<F, V>): Kind<F, Map<K, V>> = FA.run {
-      s.toList().k().traverse(FA, { (k, v) ->
+      s.toList().k().traverse(FA) { (k, v) ->
         (if (p(k)) f(v) else just(v)).map {
           k to it
         }
-      }).map { it.toMap() }
+      }.map { it.toMap() }
     }
   }
 
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/mapk.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/mapk.kt
index d6569f600bb..9234951eb1a 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/mapk.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/mapk.kt
@@ -57,11 +57,11 @@ interface MapKEachInstance<K, V> : Each<MapK<K, V>, V> {
 interface MapKFilterIndexInstance<K, V> : FilterIndex<MapK<K, V>, K, V> {
   override fun filter(p: (K) -> Boolean): Traversal<MapK<K, V>, V> = object : Traversal<MapK<K, V>, V> {
     override fun <F> modifyF(FA: Applicative<F>, s: MapK<K, V>, f: (V) -> Kind<F, V>): Kind<F, MapK<K, V>> = FA.run {
-        s.toList().k().traverse(FA, { (k, v) ->
+        s.toList().k().traverse(FA) { (k, v) ->
           (if (p(k)) f(v) else just(v)).map {
             k to it
           }
-        }).map { it.toMap().k() }
+        }.map { it.toMap().k() }
     }
   }
 }
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/sequencek.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/sequencek.kt
index d3b8d26d247..daf35055547 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/sequencek.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/sequencek.kt
@@ -39,9 +39,9 @@ interface SequenceKEachInstance<A> : Each<SequenceK<A>, A> {
 interface SequenceKFilterIndexInstance<A> : FilterIndex<SequenceK<A>, Int, A> {
   override fun filter(p: (Int) -> Boolean): Traversal<SequenceK<A>, A> = object : Traversal<SequenceK<A>, A> {
     override fun <F> modifyF(FA: Applicative<F>, s: SequenceK<A>, f: (A) -> Kind<F, A>): Kind<F, SequenceK<A>> = FA.run {
-      s.mapIndexed { index, a -> a toT index }.k().traverse(FA, { (a, j) ->
+      s.mapIndexed { index, a -> a toT index }.k().traverse(FA) { (a, j) ->
         if (p(j)) f(a) else just(a)
-      })
+      }
     }
   }
 }
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/std/try.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/std/try.kt
index 9269714f06f..cd65a88099b 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/std/try.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/std/try.kt
@@ -21,7 +21,7 @@ fun <A> Try.Companion.success(): Prism<Try<A>, A> = pSuccess()
  * [Prism] to focus into an [arrow.Try.Failure]
  */
 fun <A> Try.Companion.failure(): Prism<Try<A>, Throwable> = Prism(
-  getOrModify = { aTry -> aTry.fold(::Right, { Either.Left(aTry) }) },
+  getOrModify = { aTry -> aTry.fold(::Right) { Either.Left(aTry) } },
   reverseGet = ::Failure
 )
 
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/typeclasses/FilterIndex.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/typeclasses/FilterIndex.kt
index 4fdeaaba193..ccdc8ea5dee 100644
--- a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/typeclasses/FilterIndex.kt
+++ b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/typeclasses/FilterIndex.kt
@@ -40,9 +40,9 @@ interface FilterIndex<S, I, A> {
         override fun <F> modifyF(FA: Applicative<F>, s: Kind<S, A>, f: (A) -> Kind<F, A>): Kind<F, Kind<S, A>> =
           traverse.run {
             FA.run {
-              zipWithIndex(s).traverse(this, { (a, j) ->
+              zipWithIndex(s).traverse(this) { (a, j) ->
                 if (p(j)) f(a) else just(a)
-              })
+              }
             }
           }
       }
diff --git a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/FoldTest.kt b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/FoldTest.kt
index c1e3e613aed..cde909307ff 100644
--- a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/FoldTest.kt
+++ b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/FoldTest.kt
@@ -23,72 +23,72 @@ class FoldTest : UnitSpec() {
     "Fold select a list that contains one" {
       val select = Fold.select<List<Int>> { it.contains(1) }
 
-      forAll(Gen.list(Gen.int()), { ints ->
+      forAll(Gen.list(Gen.int())) { ints ->
         select.run { getAll(ints) }.list.firstOrNull() ==
           ints.let { if (it.contains(1)) it else null }
-      })
+      }
     }
 
     with(intFold) {
 
       "Folding a list of ints" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           fold(Int.monoid(), ints.k()) == ints.sum()
-        })
+        }
       }
 
       "Folding a list should yield same result as combineAll" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           combineAll(Int.monoid(), ints.k()) == ints.sum()
-        })
+        }
       }
 
       "Folding and mapping a list of strings" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           stringFold.run { foldMap(Int.monoid(), ints.map(Int::toString).k(), String::toInt) } == ints.sum()
-        })
+        }
       }
 
       "Get all targets" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           getAll(ints.k()) == ints.k()
-        })
+        }
       }
 
       "Get the size of the fold" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           size(ints.k()) == ints.size
-        })
+        }
       }
 
       "Find the first element matching the predicate" {
-        forAll(Gen.list(Gen.choose(-100, 100)), { ints ->
+        forAll(Gen.list(Gen.choose(-100, 100))) { ints ->
           find(ints.k()) { it > 10 } == Option.fromNullable(ints.firstOrNull { it > 10 })
-        })
+        }
       }
 
       "Checking existence of a target" {
-        forAll(Gen.list(Gen.int()), Gen.bool(), { ints, predicate ->
+        forAll(Gen.list(Gen.int()), Gen.bool()) { ints, predicate ->
           exists(ints.k()) { predicate } == predicate
-        })
+        }
       }
 
       "Check if all targets match the predicate" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           forall(ints.k()) { it % 2 == 0 } == ints.all { it % 2 == 0 }
-        })
+        }
       }
 
       "Check if there is no target" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           isEmpty(ints.k()) == ints.isEmpty()
-        })
+        }
       }
 
       "Check if there is a target" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           nonEmpty(ints.k()) == ints.isNotEmpty()
-        })
+        }
       }
     }
   }
diff --git a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/GetterTest.kt b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/GetterTest.kt
index 6d524ab8ba9..f96f57c011b 100644
--- a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/GetterTest.kt
+++ b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/GetterTest.kt
@@ -73,60 +73,60 @@ class GetterTest : UnitSpec() {
     with(tokenGetter) {
 
       "Getting the target should always yield the exact result" {
-        forAll({ value: String ->
+        forAll { value: String ->
           get(Token(value)) == value
-        })
+        }
       }
 
       "Finding a target using a predicate within a Getter should be wrapped in the correct option result" {
-        forAll({ value: String, predicate: Boolean ->
+        forAll { value: String, predicate: Boolean ->
           find(Token(value)) { predicate }.fold({ false }, { true }) == predicate
-        })
+        }
       }
 
       "Checking existence of a target should always result in the same result as predicate" {
-        forAll({ value: String, predicate: Boolean ->
+        forAll { value: String, predicate: Boolean ->
           exist(Token(value)) { predicate } == predicate
-        })
+        }
       }
     }
 
     "Zipping two lenses should yield a tuple of the targets" {
-      forAll({ value: String ->
+      forAll { value: String ->
         length.zip(upper).get(value) == value.length toT value.toUpperCase()
-      })
+      }
     }
 
     "Joining two getters together with same target should yield same result" {
       val userTokenStringGetter = userGetter compose tokenGetter
       val joinedGetter = tokenGetter.choice(userTokenStringGetter)
 
-      forAll({ tokenValue: String ->
+      forAll { tokenValue: String ->
         val token = Token(tokenValue)
         val user = User(token)
         joinedGetter.get(Left(token)) == joinedGetter.get(Right(user))
-      })
+      }
     }
 
     "Pairing two disjoint getters should yield a pair of their results" {
       val splitGetter: Getter<Tuple2<Token, User>, Tuple2<String, Token>> = tokenGetter.split(userGetter)
-      forAll(TokenGen, UserGen, { token: Token, user: User ->
+      forAll(TokenGen, UserGen) { token: Token, user: User ->
         splitGetter.get(token toT user) == token.value toT user.token
-      })
+      }
     }
 
     "Creating a first pair with a type should result in the target to value" {
       val first = tokenGetter.first<Int>()
-      forAll(TokenGen, Gen.int(), { token: Token, int: Int ->
+      forAll(TokenGen, Gen.int()) { token: Token, int: Int ->
         first.get(token toT int) == token.value toT int
-      })
+      }
     }
 
     "Creating a second pair with a type should result in the value target" {
       val first = tokenGetter.second<Int>()
-      forAll(Gen.int(), TokenGen, { int: Int, token: Token ->
+      forAll(Gen.int(), TokenGen) { int: Int, token: Token ->
         first.get(int toT token) == int toT token.value
-      })
+      }
     }
 
   }
diff --git a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/IsoTest.kt b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/IsoTest.kt
index 347c42e6348..72243c9a04d 100644
--- a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/IsoTest.kt
+++ b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/IsoTest.kt
@@ -153,77 +153,77 @@ class IsoTest : UnitSpec() {
     }
 
     "Lifting a function should yield the same result as not yielding" {
-      forAll(TokenGen, Gen.string(), { token, value ->
+      forAll(TokenGen, Gen.string()) { token, value ->
         tokenIso.modify(token) { value } == tokenIso.lift { value }(token)
-      })
+      }
     }
 
     "Lifting a function as a functor should yield the same result as not yielding" {
-      forAll(TokenGen, Gen.string(), { token, value ->
+      forAll(TokenGen, Gen.string()) { token, value ->
         tokenIso.modifyF(Option.functor(), token) { Some(value) } == tokenIso.liftF(Option.functor()) { Some(value) }(token)
-      })
+      }
     }
 
     "Creating a first pair with a type should result in the target to value" {
       val first = tokenIso.first<Int>()
-      forAll(TokenGen, Gen.int(), { token: Token, int: Int ->
+      forAll(TokenGen, Gen.int()) { token: Token, int: Int ->
         first.get(token toT int) == token.value toT int
-      })
+      }
     }
 
     "Creating a second pair with a type should result in the value to target" {
       val second = tokenIso.second<Int>()
-      forAll(Gen.int(), TokenGen, { int: Int, token: Token ->
+      forAll(Gen.int(), TokenGen) { int: Int, token: Token ->
         second.get(int toT token) == int toT token.value
-      })
+      }
     }
 
     "Creating a left with a type should result in a sum target to value" {
       val left = tokenIso.left<Int>()
-      forAll(TokenGen, Gen.int(), { token: Token, int: Int ->
+      forAll(TokenGen, Gen.int()) { token: Token, int: Int ->
         left.get(Either.Left(token)) == Either.Left(token.value) &&
           left.get(Either.Right(int)) == Either.Right(int)
-      })
+      }
     }
 
     "Creating a right with a type should result in a sum value to target" {
       val left = tokenIso.right<Int>()
-      forAll(TokenGen, Gen.int(), { token: Token, int: Int ->
+      forAll(TokenGen, Gen.int()) { token: Token, int: Int ->
         left.get(Either.Left(int)) == Either.Left(int) &&
           left.get(Either.Right(token)) == Either.Right(token.value)
-      })
+      }
     }
 
     "Finding a target using a predicate within a Iso should be wrapped in the correct option result" {
-      forAll({ predicate: Boolean ->
+      forAll { predicate: Boolean ->
         tokenIso.find(Token("any value")) { predicate }.fold({ false }, { true }) == predicate
-      })
+      }
     }
 
     "Checking existence predicate over the target should result in same result as predicate" {
-      forAll({ predicate: Boolean ->
+      forAll { predicate: Boolean ->
         tokenIso.exist(Token("any value")) { predicate } == predicate
-      })
+      }
     }
 
     "Pairing two disjoint isos together" {
       val joinedIso = tokenIso split userIso
 
-      forAll({ tokenValue: String ->
+      forAll { tokenValue: String ->
         val token = Token(tokenValue)
         val user = User(token)
         joinedIso.get(token toT user) == tokenValue toT token
-      })
+      }
     }
 
     "Composing isos should result in an iso of the first iso's value with the second iso's target" {
       val composedIso = userIso compose tokenIso
 
-      forAll({ tokenValue: String ->
+      forAll { tokenValue: String ->
         val token = Token(tokenValue)
         val user = User(token)
         composedIso.get(user) == tokenValue
-      })
+      }
     }
   }
 
diff --git a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/LensTest.kt b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/LensTest.kt
index 06a405c8b96..79ac608ec75 100644
--- a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/LensTest.kt
+++ b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/LensTest.kt
@@ -137,59 +137,59 @@ class LensTest : UnitSpec() {
     }
 
     "Lifting a function should yield the same result as not yielding" {
-      forAll(TokenGen, Gen.string(), { token, value ->
+      forAll(TokenGen, Gen.string()) { token, value ->
         tokenLens.set(token, value) == tokenLens.lift { value }(token)
-      })
+      }
     }
 
     "Lifting a function as a functor should yield the same result as not yielding" {
-      forAll(TokenGen, Gen.string(), { token, value ->
+      forAll(TokenGen, Gen.string()) { token, value ->
         tokenLens.modifyF(Option.functor(), token) { Some(value) } == tokenLens.liftF(Option.functor()) { Some(value) }(token)
-      })
+      }
     }
 
     "Finding a target using a predicate within a Lens should be wrapped in the correct option result" {
-      forAll({ predicate: Boolean ->
+      forAll { predicate: Boolean ->
         tokenLens.find(Token("any value")) { predicate }.fold({ false }, { true }) == predicate
-      })
+      }
     }
 
     "Checking existence predicate over the target should result in same result as predicate" {
-      forAll({ predicate: Boolean ->
+      forAll { predicate: Boolean ->
         tokenLens.exist(Token("any value")) { predicate } == predicate
-      })
+      }
     }
 
     "Joining two lenses together with same target should yield same result" {
       val userTokenStringLens = userLens compose tokenLens
       val joinedLens = tokenLens choice userTokenStringLens
 
-      forAll({ tokenValue: String ->
+      forAll { tokenValue: String ->
         val token = Token(tokenValue)
         val user = User(token)
         joinedLens.get(Left(token)) == joinedLens.get(Right(user))
-      })
+      }
     }
 
     "Pairing two disjoint lenses should yield a pair of their results" {
       val spiltLens: Lens<Tuple2<Token, User>, Tuple2<String, Token>> = tokenLens split userLens
-      forAll(TokenGen, UserGen, { token: Token, user: User ->
+      forAll(TokenGen, UserGen) { token: Token, user: User ->
         spiltLens.get(token toT user) == token.value toT user.token
-      })
+      }
     }
 
     "Creating a first pair with a type should result in the target to value" {
       val first = tokenLens.first<Int>()
-      forAll(TokenGen, Gen.int(), { token: Token, int: Int ->
+      forAll(TokenGen, Gen.int()) { token: Token, int: Int ->
         first.get(token toT int) == token.value toT int
-      })
+      }
     }
 
     "Creating a second pair with a type should result in the value target" {
       val first = tokenLens.second<Int>()
-      forAll(Gen.int(), TokenGen, { int: Int, token: Token ->
+      forAll(Gen.int(), TokenGen) { int: Int, token: Token ->
         first.get(int toT token) == int toT token.value
-      })
+      }
     }
   }
 
diff --git a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/OptionalTest.kt b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/OptionalTest.kt
index af50929fad7..10a7c5a88d1 100644
--- a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/OptionalTest.kt
+++ b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/OptionalTest.kt
@@ -140,67 +140,67 @@ class OptionalTest : UnitSpec() {
     }
 
     "void should always " {
-      forAll({ string: String ->
+      forAll { string: String ->
         Optional.void<String, Int>().getOption(string) == None
-      })
+      }
     }
 
     "void should always return source when setting target" {
-      forAll({ int: Int, string: String ->
+      forAll { int: Int, string: String ->
         Optional.void<String, Int>().set(string, int) == string
-      })
+      }
     }
 
     "Checking if there is no target" {
-      forAll(Gen.list(Gen.int()), { list ->
+      forAll(Gen.list(Gen.int())) { list ->
         optionalHead.nonEmpty(list) == list.isNotEmpty()
-      })
+      }
     }
 
     "Lift should be consistent with modify" {
-      forAll(Gen.list(Gen.int()), { list ->
+      forAll(Gen.list(Gen.int())) { list ->
         val f = { i: Int -> i + 5 }
         optionalHead.lift(f)(list) == optionalHead.modify(list, f)
-      })
+      }
     }
 
     "LiftF should be consistent with modifyF" {
-      forAll(Gen.list(Gen.int()), genTry(Gen.int()), { list, tryInt ->
+      forAll(Gen.list(Gen.int()), genTry(Gen.int())) { list, tryInt ->
         val f = { _: Int -> tryInt }
         optionalHead.liftF(Try.applicative(), f)(list) == optionalHead.modifyF(Try.applicative(), list, f)
-      })
+      }
     }
 
     "Checking if a target exists" {
-      forAll(Gen.list(Gen.int()), { list ->
+      forAll(Gen.list(Gen.int())) { list ->
         optionalHead.isEmpty(list) == list.isEmpty()
-      })
+      }
     }
 
     "Finding a target using a predicate should be wrapped in the correct option result" {
-      forAll(Gen.list(Gen.int()), Gen.bool(), { list, predicate ->
+      forAll(Gen.list(Gen.int()), Gen.bool()) { list, predicate ->
         optionalHead.find(list) { predicate }.fold({ false }, { true }) == predicate
-      })
+      }
     }
 
     "Checking existence predicate over the target should result in same result as predicate" {
-      forAll(Gen.list(Gen.int()), Gen.bool(), { list, predicate ->
+      forAll(Gen.list(Gen.int()), Gen.bool()) { list, predicate ->
         optionalHead.exists(list) { predicate } == predicate
-      })
+      }
     }
 
     "Checking satisfaction of predicate over the target should result in opposite result as predicate" {
-      forAll(Gen.list(Gen.int()), Gen.bool(), { list, predicate ->
+      forAll(Gen.list(Gen.int()), Gen.bool()) { list, predicate ->
         optionalHead.all(list) { predicate } == predicate
-      })
+      }
     }
 
     "Joining two optionals together with same target should yield same result" {
       val joinedOptional = optionalHead.choice(defaultHead)
 
-      forAll(Gen.int(), { int ->
+      forAll(Gen.int()) { int ->
         joinedOptional.getOption(Left(listOf(int))) == joinedOptional.getOption(Right(int))
-      })
+      }
     }
 
   }
diff --git a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/PrismTest.kt b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/PrismTest.kt
index 965b2b64fe7..59bb9f76e55 100644
--- a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/PrismTest.kt
+++ b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/PrismTest.kt
@@ -161,54 +161,54 @@ class PrismTest : UnitSpec() {
     }
 
     "Joining two prisms together with same target should yield same result" {
-      forAll(SumGen, { a ->
+      forAll(SumGen) { a ->
         (sumPrism compose stringPrism).getOption(a) == sumPrism.getOption(a).flatMap(stringPrism::getOption) &&
           (sumPrism + stringPrism).getOption(a) == (sumPrism compose stringPrism).getOption(a)
-      })
+      }
     }
 
     "Checking if a prism exists with a target" {
-      forAll(SumGen, SumGen, Gen.bool(), { a, other, bool ->
+      forAll(SumGen, SumGen, Gen.bool()) { a, other, bool ->
         Prism.only(a, object : Eq<SumType> {
           override fun SumType.eqv(b: SumType): Boolean = bool
         }).isEmpty(other) == bool
-      })
+      }
     }
 
     "Checking if there is no target" {
-      forAll(SumGen, { sum ->
+      forAll(SumGen) { sum ->
         sumPrism.isEmpty(sum) == sum !is SumType.A
-      })
+      }
     }
 
     "Checking if a target exists" {
-      forAll(SumGen, { sum ->
+      forAll(SumGen) { sum ->
         sumPrism.nonEmpty(sum) == sum is SumType.A
-      })
+      }
     }
 
     "Setting a target on a prism should set the correct target"{
-      forAll(AGen, Gen.string(), { a, string ->
+      forAll(AGen, Gen.string()) { a, string ->
         sumPrism.setOption(a, string) == Some(a.copy(string = string))
-      })
+      }
     }
 
     "Finding a target using a predicate within a Lens should be wrapped in the correct option result" {
-      forAll(SumGen, Gen.bool(), { sum, predicate ->
+      forAll(SumGen, Gen.bool()) { sum, predicate ->
         sumPrism.find(sum) { predicate }.fold({ false }, { true }) == (predicate && sum is SumType.A)
-      })
+      }
     }
 
     "Checking existence predicate over the target should result in same result as predicate" {
-      forAll(SumGen, Gen.bool(), { sum, predicate ->
+      forAll(SumGen, Gen.bool()) { sum, predicate ->
         sumPrism.exist(sum) { predicate } == (predicate && sum is SumType.A)
-      })
+      }
     }
 
     "Checking satisfaction of predicate over the target should result in opposite result as predicate" {
-      forAll(SumGen, Gen.bool(), { sum, predicate ->
+      forAll(SumGen, Gen.bool()) { sum, predicate ->
         sumPrism.all(sum) { predicate } == (predicate || sum is SumType.B)
-      })
+      }
     }
 
   }
diff --git a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/SetterTest.kt b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/SetterTest.kt
index 69414fbcf07..9675cf86859 100644
--- a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/SetterTest.kt
+++ b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/SetterTest.kt
@@ -47,16 +47,16 @@ class SetterTest : UnitSpec() {
       val token = Token(oldValue)
       val user = User(token)
 
-      forAll({ value: String ->
+      forAll { value: String ->
         joinedSetter.set(token.left(), value).swap().getOrElse { Token("Wrong value") }.value ==
           joinedSetter.set(user.right(), value).getOrElse { User(Token("Wrong value")) }.token.value
-      })
+      }
     }
 
     "Lifting a function should yield the same result as direct modify" {
-      forAll(TokenGen, Gen.string(), { token, value ->
+      forAll(TokenGen, Gen.string()) { token, value ->
         tokenSetter.modify(token) { value } == tokenSetter.lift { value }(token)
-      })
+      }
     }
   }
 }
diff --git a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/TraversalTest.kt b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/TraversalTest.kt
index 0f38854372a..bef6e9098a1 100644
--- a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/TraversalTest.kt
+++ b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/TraversalTest.kt
@@ -110,33 +110,33 @@ class TraversalTest : UnitSpec() {
     with(listKTraverse) {
 
       "Getting all targets of a traversal" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           getAll(ints.k()) == ints.k()
-        })
+        }
       }
 
       "Folding all the values of a traversal" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           fold(Int.monoid(), ints.k()) == ints.sum()
-        })
+        }
       }
 
       "Combining all the values of a traversal" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           combineAll(Int.monoid(), ints.k()) == ints.sum()
-        })
+        }
       }
 
       "Finding an number larger than 10" {
-        forAll(Gen.list(Gen.choose(-100, 100)), { ints ->
+        forAll(Gen.list(Gen.choose(-100, 100))) { ints ->
           find(ints.k()) { it > 10 } == Option.fromNullable(ints.firstOrNull { it > 10 })
-        })
+        }
       }
 
       "Get the length from a traversal" {
-        forAll(Gen.list(Gen.int()), { ints ->
+        forAll(Gen.list(Gen.int())) { ints ->
           size(ints.k()) == ints.size
-        })
+        }
       }
     }