diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2c4d46c7..0d8405dc 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -29,7 +29,7 @@ jobs:
       matrix:
         os: [ubuntu-22.04]
         scala: [2.12, 2.13, 3]
-        java: [temurin@8]
+        java: [temurin@17]
         project: [rootJS, rootJVM, rootNative]
     runs-on: ${{ matrix.os }}
     timeout-minutes: 60
@@ -42,24 +42,24 @@ jobs:
       - name: Setup sbt
         uses: sbt/setup-sbt@v1
 
-      - name: Setup Java (temurin@8)
-        id: setup-java-temurin-8
-        if: matrix.java == 'temurin@8'
+      - name: Setup Java (temurin@17)
+        id: setup-java-temurin-17
+        if: matrix.java == 'temurin@17'
         uses: actions/setup-java@v5
         with:
           distribution: temurin
-          java-version: 8
+          java-version: 17
           cache: sbt
 
       - name: sbt update
-        if: matrix.java == 'temurin@8' && steps.setup-java-temurin-8.outputs.cache-hit == 'false'
+        if: matrix.java == 'temurin@17' && steps.setup-java-temurin-17.outputs.cache-hit == 'false'
         run: sbt +update
 
       - name: Check that workflows are up to date
         run: sbt githubWorkflowCheck
 
       - name: Check formatting
-        if: matrix.java == 'temurin@8' && matrix.os == 'ubuntu-22.04'
+        if: matrix.java == 'temurin@17' && matrix.os == 'ubuntu-22.04'
         run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' scalafmtCheckAll 'project /' scalafmtSbtCheck
 
       - name: scalaJSLink
@@ -74,11 +74,11 @@ jobs:
         run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' test
 
       - name: Check binary compatibility
-        if: matrix.java == 'temurin@8' && matrix.os == 'ubuntu-22.04'
+        if: matrix.java == 'temurin@17' && matrix.os == 'ubuntu-22.04'
         run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' mimaReportBinaryIssues
 
       - name: Generate API documentation
-        if: matrix.java == 'temurin@8' && matrix.os == 'ubuntu-22.04'
+        if: matrix.java == 'temurin@17' && matrix.os == 'ubuntu-22.04'
         run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' doc
 
       - name: Make target directories
@@ -103,7 +103,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-22.04]
-        java: [temurin@8]
+        java: [temurin@17]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout current branch (full)
@@ -114,17 +114,17 @@ jobs:
       - name: Setup sbt
         uses: sbt/setup-sbt@v1
 
-      - name: Setup Java (temurin@8)
-        id: setup-java-temurin-8
-        if: matrix.java == 'temurin@8'
+      - name: Setup Java (temurin@17)
+        id: setup-java-temurin-17
+        if: matrix.java == 'temurin@17'
         uses: actions/setup-java@v5
         with:
           distribution: temurin
-          java-version: 8
+          java-version: 17
           cache: sbt
 
       - name: sbt update
-        if: matrix.java == 'temurin@8' && steps.setup-java-temurin-8.outputs.cache-hit == 'false'
+        if: matrix.java == 'temurin@17' && steps.setup-java-temurin-17.outputs.cache-hit == 'false'
         run: sbt +update
 
       - name: Download target directories (2.12, rootJS)
@@ -247,7 +247,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-22.04]
-        java: [temurin@8]
+        java: [temurin@17]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout current branch (full)
@@ -258,17 +258,17 @@ jobs:
       - name: Setup sbt
         uses: sbt/setup-sbt@v1
 
-      - name: Setup Java (temurin@8)
-        id: setup-java-temurin-8
-        if: matrix.java == 'temurin@8'
+      - name: Setup Java (temurin@17)
+        id: setup-java-temurin-17
+        if: matrix.java == 'temurin@17'
         uses: actions/setup-java@v5
         with:
           distribution: temurin
-          java-version: 8
+          java-version: 17
           cache: sbt
 
       - name: sbt update
-        if: matrix.java == 'temurin@8' && steps.setup-java-temurin-8.outputs.cache-hit == 'false'
+        if: matrix.java == 'temurin@17' && steps.setup-java-temurin-17.outputs.cache-hit == 'false'
         run: sbt +update
 
       - name: Submit Dependencies
diff --git a/.mergify.yml b/.mergify.yml
index 6415897f..a8db2344 100644
--- a/.mergify.yml
+++ b/.mergify.yml
@@ -12,15 +12,15 @@ pull_request_rules:
   - or:
     - body~=labels:.*early-semver-patch
     - body~=labels:.*early-semver-minor
-  - status-success=Test (ubuntu-22.04, 2.12, temurin@8, rootJS)
-  - status-success=Test (ubuntu-22.04, 2.12, temurin@8, rootJVM)
-  - status-success=Test (ubuntu-22.04, 2.12, temurin@8, rootNative)
-  - status-success=Test (ubuntu-22.04, 2.13, temurin@8, rootJS)
-  - status-success=Test (ubuntu-22.04, 2.13, temurin@8, rootJVM)
-  - status-success=Test (ubuntu-22.04, 2.13, temurin@8, rootNative)
-  - status-success=Test (ubuntu-22.04, 3, temurin@8, rootJS)
-  - status-success=Test (ubuntu-22.04, 3, temurin@8, rootJVM)
-  - status-success=Test (ubuntu-22.04, 3, temurin@8, rootNative)
+  - status-success=Test (ubuntu-22.04, 2.12, temurin@17, rootJS)
+  - status-success=Test (ubuntu-22.04, 2.12, temurin@17, rootJVM)
+  - status-success=Test (ubuntu-22.04, 2.12, temurin@17, rootNative)
+  - status-success=Test (ubuntu-22.04, 2.13, temurin@17, rootJS)
+  - status-success=Test (ubuntu-22.04, 2.13, temurin@17, rootJVM)
+  - status-success=Test (ubuntu-22.04, 2.13, temurin@17, rootNative)
+  - status-success=Test (ubuntu-22.04, 3, temurin@17, rootJS)
+  - status-success=Test (ubuntu-22.04, 3, temurin@17, rootJVM)
+  - status-success=Test (ubuntu-22.04, 3, temurin@17, rootNative)
   actions:
     merge: {}
 - name: Label core PRs
diff --git a/build.sbt b/build.sbt
index 9d47501f..cdaff0bf 100644
--- a/build.sbt
+++ b/build.sbt
@@ -2,12 +2,13 @@ import com.typesafe.tools.mima.core.{MissingClassProblem, ProblemFilters}
 
 val scala212 = "2.12.21"
 val scala213 = "2.13.18"
-val scala3 = "3.3.8"
+val scala3 = "3.9.0"
 
 ThisBuild / crossScalaVersions := Seq(scala212, scala213, scala3)
 ThisBuild / scalaVersion := scala3
-ThisBuild / tlBaseVersion := "3.5"
+ThisBuild / tlBaseVersion := "3.6"
 ThisBuild / organization := "org.typelevel"
+ThisBuild / githubWorkflowJavaVersions := Seq(JavaSpec.temurin("17"))
 
 val catsVersion = "2.13.0"
 val munitVersion = "1.3.6"
@@ -26,7 +27,6 @@ val commonOptions = List(
 )
 
 val scala3Options = List(
-  "-source:future",
   "-Xmax-inlines",
   "64",
   "-Wvalue-discard",
diff --git a/core/src/main/scala-3/cats/derived/DerivedApplicative.scala b/core/src/main/scala-3/cats/derived/DerivedApplicative.scala
index a52afd0e..9effd96f 100644
--- a/core/src/main/scala-3/cats/derived/DerivedApplicative.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedApplicative.scala
@@ -45,7 +45,8 @@ object DerivedApplicative:
         DerivedApply.Product[T, F]:
 
     final override def pure[A](x: A): F[A] =
-      inst.construct([f[_]] => (F: T[f]) => F.pure[A](x))
+      inst.construct: [f[_]] =>
+        F => F.pure[A](x)
 
   object Strict:
     given product[F[_]: ProductInstancesOf[Applicative]]: DerivedApplicative[F] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedApply.scala b/core/src/main/scala-3/cats/derived/DerivedApply.scala
index 283b371f..134c4a4a 100644
--- a/core/src/main/scala-3/cats/derived/DerivedApply.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedApply.scala
@@ -39,9 +39,13 @@ object DerivedApply:
 
   trait Product[T[f[_]] <: Apply[f], F[_]](using inst: ProductInstances[T, F]) extends Apply[F]:
     private lazy val F = DerivedFunctor.Strict.product(using inst.widen).instance
-    final override def map[A, B](fa: F[A])(f: A => B): F[B] = F.map(fa)(f)
+
+    final override def map[A, B](fa: F[A])(f: A => B): F[B] =
+      F.map(fa)(f)
+
     final override def ap[A, B](ff: F[A => B])(fa: F[A]): F[B] =
-      inst.map2(ff, fa)([f[_]] => (F: T[f], ff: f[A => B], fa: f[A]) => F.ap(ff)(fa))
+      inst.map2(ff, fa): [f[_]] =>
+        (F, ff, fa) => F.ap(ff)(fa)
 
   object Strict:
     given product[F[_]: ProductInstancesOf[Apply]]: DerivedApply[F] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedBifoldable.scala b/core/src/main/scala-3/cats/derived/DerivedBifoldable.scala
index 34b1bba0..950c3858 100644
--- a/core/src/main/scala-3/cats/derived/DerivedBifoldable.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedBifoldable.scala
@@ -76,23 +76,25 @@ object DerivedBifoldable:
 
   trait Product[T[f[_, _]] <: Bifoldable[f], F[_, _]](using inst: ProductInstances[T, F]) extends Bifoldable[F]:
     final override def bifoldLeft[A, B, C](fab: F[A, B], c: C)(f: (C, A) => C, g: (C, B) => C): C =
-      inst.foldLeft(fab)(c)([f[_, _]] => (c: C, F: T[f], fab: f[A, B]) => F.bifoldLeft(fab, c)(f, g))
+      inst.foldLeft(fab)(c): [f[_, _]] =>
+        (c, F, fab) => F.bifoldLeft(fab, c)(f, g)
 
     final override def bifoldRight[A, B, C](fab: F[A, B], c: Eval[C])(
         f: (A, Eval[C]) => Eval[C],
         g: (B, Eval[C]) => Eval[C]
     ): Eval[C] = inst.foldRight(fab)(c): [f[_, _]] =>
-      (F: T[f], fab: f[A, B], c: Eval[C]) => Eval.defer(F.bifoldRight(fab, c)(f, g))
+      (F, fab, c) => Eval.defer(F.bifoldRight(fab, c)(f, g))
 
   trait Coproduct[T[f[_, _]] <: Bifoldable[f], F[_, _]](using inst: CoproductInstances[T, F]) extends Bifoldable[F]:
     final override def bifoldLeft[A, B, C](fab: F[A, B], c: C)(f: (C, A) => C, g: (C, B) => C): C =
-      inst.fold(fab)([f[_, _]] => (F: T[f], fab: f[A, B]) => F.bifoldLeft(fab, c)(f, g))
+      inst.fold(fab): [f[_, _]] =>
+        (F, fab) => F.bifoldLeft(fab, c)(f, g)
 
     final override def bifoldRight[A, B, C](fab: F[A, B], c: Eval[C])(
         f: (A, Eval[C]) => Eval[C],
         g: (B, Eval[C]) => Eval[C]
     ): Eval[C] = inst.fold(fab): [f[_, _]] =>
-      (F: T[f], fab: f[A, B]) => Eval.defer(F.bifoldRight(fab, c)(f, g))
+      (F, fab) => Eval.defer(F.bifoldRight(fab, c)(f, g))
 
   object Strict:
     given product[F[_, _]: ProductInstancesOf[Bifoldable]]: DerivedBifoldable[F] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedBifunctor.scala b/core/src/main/scala-3/cats/derived/DerivedBifunctor.scala
index b75653c2..95429a58 100644
--- a/core/src/main/scala-3/cats/derived/DerivedBifunctor.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedBifunctor.scala
@@ -54,7 +54,8 @@ object DerivedBifunctor:
 
   trait Generic[T[f[_, _]] <: Bifunctor[f], F[_, _]](using inst: Instances[T, F]) extends Bifunctor[F]:
     final override def bimap[A, B, C, D](fab: F[A, B])(f: A => C, g: B => D): F[C, D] =
-      inst.map(fab)([f[_, _]] => (F: T[f], fa: f[A, B]) => F.bimap(fa)(f, g))
+      inst.map(fab): [f[_, _]] =>
+        (F, fa) => F.bimap(fa)(f, g)
 
   object Strict:
     given product[F[_, _]: ProductInstancesOf[Bifunctor]]: DerivedBifunctor[F] = gen
diff --git a/core/src/main/scala-3/cats/derived/DerivedBitraverse.scala b/core/src/main/scala-3/cats/derived/DerivedBitraverse.scala
index c652c0f5..0abbac31 100644
--- a/core/src/main/scala-3/cats/derived/DerivedBitraverse.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedBitraverse.scala
@@ -96,10 +96,10 @@ object DerivedBitraverse:
     final override def bitraverse[G[_], A, B, C, D](fab: F[A, B])(f: A => G[C], g: B => G[D])(using
         G: Applicative[G]
     ): G[F[C, D]] =
-      val pure = [a] => (x: a) => G.pure(x)
-      val map = [a, b] => (ga: G[a], f: a => b) => G.map(ga)(f)
-      val ap = [a, b] => (gf: G[a => b], ga: G[a]) => G.ap(gf)(ga)
-      inst.traverse[A, B, G, C, D](fab)(map)(pure)(ap)([f[_, _]] => (F: T[f], fab: f[A, B]) => F.bitraverse(fab)(f, g))
+      inst.traverse[A, B, G, C, D](fab)([a, b] => (ga, f) => G.map(ga)(f))([a] => x => G.pure(x))([a, b] =>
+        (gf, ga) => G.ap(gf)(ga)
+      ): [f[_, _]] =>
+        (F, fab) => F.bitraverse(fab)(f, g)
 
   trait Coproduct[T[f[_, _]] <: Bitraverse[f], F[_, _]](using inst: CoproductInstances[T, F])
       extends Bitraverse[F]
@@ -109,7 +109,7 @@ object DerivedBitraverse:
     final override def bitraverse[G[_], A, B, C, D](fab: F[A, B])(f: A => G[C], g: B => G[D])(using
         G: Applicative[G]
     ): G[F[C, D]] = inst.fold(fab): [f[a, b] <: F[a, b]] =>
-      (F: T[f], fa: f[A, B]) => G.widen[f[C, D], F[C, D]](F.bitraverse(fa)(f, g))
+      (F, fa) => G.widen[f[C, D], F[C, D]](F.bitraverse(fa)(f, g))
 
   object Strict:
     given product[F[_, _]: ProductInstancesOf[Bitraverse]]: DerivedBitraverse[F] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedContravariant.scala b/core/src/main/scala-3/cats/derived/DerivedContravariant.scala
index 4c0a45cc..26de14c5 100644
--- a/core/src/main/scala-3/cats/derived/DerivedContravariant.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedContravariant.scala
@@ -46,7 +46,8 @@ object DerivedContravariant:
 
   trait Generic[T[f[_]] <: Contravariant[f], F[_]](using inst: Instances[T, F]) extends Contravariant[F]:
     final override def contramap[A, B](fa: F[A])(f: B => A): F[B] =
-      inst.map(fa)([f[_]] => (T: T[f], fa: f[A]) => T.contramap(fa)(f))
+      inst.map(fa): [f[_]] =>
+        (T, fa) => T.contramap(fa)(f)
 
   object Strict:
     given product[F[_]: ProductInstancesOf[Contravariant]]: DerivedContravariant[F] = generic
diff --git a/core/src/main/scala-3/cats/derived/DerivedEmpty.scala b/core/src/main/scala-3/cats/derived/DerivedEmpty.scala
index e0a26319..68f654de 100644
--- a/core/src/main/scala-3/cats/derived/DerivedEmpty.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedEmpty.scala
@@ -30,8 +30,8 @@ object DerivedEmpty:
 
   object Strict:
     given product[A: ProductInstancesOf[Empty]]: DerivedEmpty[A] =
-      Empty(ProductInstances.construct([a] => (A: Empty[a]) => A.empty))
+      Empty(ProductInstances.construct([a] => A => A.empty))
 
     @nowarn("id=E197")
     inline given coproduct[A: CoproductGeneric]: DerivedEmpty[A] =
-      Empty(CoproductGeneric.withOnly[Empty |: Derived, A]([a <: A] => (A: (Empty |: Derived)[a]) => A.unify.empty))
+      Empty(CoproductGeneric.withOnly[Empty |: Derived, A]([a <: A] => A => A.unify.empty))
diff --git a/core/src/main/scala-3/cats/derived/DerivedEmptyK.scala b/core/src/main/scala-3/cats/derived/DerivedEmptyK.scala
index fc9c681d..84ff5007 100644
--- a/core/src/main/scala-3/cats/derived/DerivedEmptyK.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedEmptyK.scala
@@ -61,9 +61,10 @@ object DerivedEmptyK:
 
   object Strict:
     given product[F[_]: ProductInstancesOf[EmptyK]]: DerivedEmptyK[F] = new EmptyK[F]:
-      def empty[A]: F[A] = ProductInstances.construct([f[_]] => (F: EmptyK[f]) => F.empty[A])
+      def empty[A]: F[A] = ProductInstances.construct: [f[_]] =>
+        F => F.empty[A]
 
     @nowarn("id=E197")
     inline given coproduct[F[_]: CoproductGeneric]: DerivedEmptyK[F] =
       CoproductGeneric.withOnly[EmptyK |: Derived, EmptyK[F]]: [f[x] <: F[x]] =>
-        (F: (EmptyK |: Derived)[f]) => F.asInstanceOf[EmptyK[F]]
+        F => F.asInstanceOf[EmptyK[F]]
diff --git a/core/src/main/scala-3/cats/derived/DerivedEq.scala b/core/src/main/scala-3/cats/derived/DerivedEq.scala
index c515c2d0..b00da3d7 100644
--- a/core/src/main/scala-3/cats/derived/DerivedEq.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedEq.scala
@@ -34,12 +34,12 @@ object DerivedEq:
     new Coproduct[Eq, A] {}
 
   trait Product[F[x] <: Eq[x], A](using inst: ProductInstances[F, A]) extends Eq[A]:
-    final override def eqv(x: A, y: A): Boolean = inst.foldLeft2(x, y)(true: Boolean): [t] =>
-      (acc: Boolean, eqt: F[t], x: t, y: t) => Complete(!eqt.eqv(x, y))(false)(acc)
+    final override def eqv(x: A, y: A): Boolean = inst.foldLeft2(x, y)(true): [t] =>
+      (acc, eqt, x, y) => Complete(!eqt.eqv(x, y))(false)(acc)
 
   trait Coproduct[F[x] <: Eq[x], A](using inst: CoproductInstances[F, A]) extends Eq[A]:
     final override def eqv(x: A, y: A): Boolean = inst.fold2(x, y)(false): [t] =>
-      (eqt: F[t], x: t, y: t) => eqt.eqv(x, y)
+      (eqt, x, y) => eqt.eqv(x, y)
 
   object Strict:
     export DerivedEq.coproduct
diff --git a/core/src/main/scala-3/cats/derived/DerivedFoldable.scala b/core/src/main/scala-3/cats/derived/DerivedFoldable.scala
index 95f97775..5eb8fd27 100644
--- a/core/src/main/scala-3/cats/derived/DerivedFoldable.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedFoldable.scala
@@ -46,17 +46,21 @@ object DerivedFoldable:
 
   trait Product[T[f[_]] <: Foldable[f], F[_]](using inst: ProductInstances[T, F]) extends Foldable[F]:
     final override def foldLeft[A, B](fa: F[A], b: B)(f: (B, A) => B): B =
-      inst.foldLeft(fa)(b)([f[_]] => (b: B, F: T[f], fa: f[A]) => F.foldLeft(fa, b)(f))
+      inst.foldLeft(fa)(b): [f[_]] =>
+        (b, F, fa) => F.foldLeft(fa, b)(f)
 
     final override def foldRight[A, B](fa: F[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
-      inst.foldRight(fa)(lb)([f[_]] => (F: T[f], fa: f[A], lb: Eval[B]) => Eval.defer(F.foldRight(fa, lb)(f)))
+      inst.foldRight(fa)(lb): [f[_]] =>
+        (F, fa, lb) => Eval.defer(F.foldRight(fa, lb)(f))
 
   trait Coproduct[T[f[_]] <: Foldable[f], F[_]](using inst: CoproductInstances[T, F]) extends Foldable[F]:
     final override def foldLeft[A, B](fa: F[A], b: B)(f: (B, A) => B): B =
-      inst.fold(fa)([f[_]] => (F: T[f], fa: f[A]) => F.foldLeft(fa, b)(f))
+      inst.fold(fa): [f[_]] =>
+        (F, fa) => F.foldLeft(fa, b)(f)
 
     final override def foldRight[A, B](fa: F[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
-      inst.fold(fa)([f[_]] => (F: T[f], fa: f[A]) => Eval.defer(F.foldRight(fa, lb)(f)))
+      inst.fold(fa): [f[_]] =>
+        (F, fa) => Eval.defer(F.foldRight(fa, lb)(f))
 
   object Strict:
     given product[F[_]: ProductInstancesOf[Foldable]]: DerivedFoldable[F] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedFunctor.scala b/core/src/main/scala-3/cats/derived/DerivedFunctor.scala
index 7df5259c..10da3674 100644
--- a/core/src/main/scala-3/cats/derived/DerivedFunctor.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedFunctor.scala
@@ -63,7 +63,8 @@ object DerivedFunctor:
 
   trait Generic[T[f[_]] <: Functor[f], F[_]](using inst: Instances[T, F]) extends Functor[F]:
     final override def map[A, B](fa: F[A])(f: A => B): F[B] =
-      inst.map(fa)([f[_]] => (F: T[f], fa: f[A]) => F.map(fa)(f))
+      inst.map(fa): [f[_]] =>
+        (F, fa) => F.map(fa)(f)
 
   object Strict:
     given product[F[_]: ProductInstancesOf[Functor]]: DerivedFunctor[F] = generic
diff --git a/core/src/main/scala-3/cats/derived/DerivedGroup.scala b/core/src/main/scala-3/cats/derived/DerivedGroup.scala
index dbce84fa..a6e4bf0f 100644
--- a/core/src/main/scala-3/cats/derived/DerivedGroup.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedGroup.scala
@@ -23,7 +23,8 @@ object DerivedGroup:
     Strict.product(using inst.unify)
 
   trait Product[F[x] <: Group[x], A: ProductInstancesOf[F]] extends DerivedMonoid.Product[F, A], Group[A]:
-    final override def inverse(a: A): A = ProductInstances.map(a)([a] => (F: F[a], x: a) => F.inverse(x))
+    final override def inverse(a: A): A = ProductInstances.map(a): [a] =>
+      (F, x) => F.inverse(x)
 
   object Strict:
     given product[A: ProductInstancesOf[Group]]: DerivedGroup[A] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedHash.scala b/core/src/main/scala-3/cats/derived/DerivedHash.scala
index 5d32632d..c83c06d6 100644
--- a/core/src/main/scala-3/cats/derived/DerivedHash.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedHash.scala
@@ -56,7 +56,8 @@ object DerivedHash:
         MurmurHash3.finalizeHash(hash, arity)
 
   trait Coproduct[F[x] <: Hash[x], A](using inst: CoproductInstances[F, A]) extends DerivedEq.Coproduct[F, A], Hash[A]:
-    final override def hash(x: A): Int = inst.fold[Int](x)([t] => (h: F[t], x: t) => h.hash(x))
+    final override def hash(x: A): Int = inst.fold[Int](x): [t] =>
+      (h, x) => h.hash(x)
 
   object Strict:
     export DerivedHash.coproduct
diff --git a/core/src/main/scala-3/cats/derived/DerivedInvariant.scala b/core/src/main/scala-3/cats/derived/DerivedInvariant.scala
index 46cd3407..0265fa6a 100644
--- a/core/src/main/scala-3/cats/derived/DerivedInvariant.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedInvariant.scala
@@ -46,7 +46,8 @@ object DerivedInvariant:
 
   trait Generic[T[f[_]] <: Invariant[f], F[_]](using inst: Instances[T, F]) extends Invariant[F]:
     final override def imap[A, B](fa: F[A])(f: A => B)(g: B => A): F[B] =
-      inst.map(fa)([f[_]] => (F: T[f], fa: f[A]) => F.imap(fa)(f)(g))
+      inst.map(fa): [f[_]] =>
+        (F, fa) => F.imap(fa)(f)(g)
 
   object Strict:
     given product[F[_]: ProductInstancesOf[Invariant]]: DerivedInvariant[F] = generic
diff --git a/core/src/main/scala-3/cats/derived/DerivedMonoid.scala b/core/src/main/scala-3/cats/derived/DerivedMonoid.scala
index da14a83c..b49e6503 100644
--- a/core/src/main/scala-3/cats/derived/DerivedMonoid.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedMonoid.scala
@@ -26,7 +26,8 @@ object DerivedMonoid:
       extends DerivedSemigroup.Product[F, A],
         Monoid[A]:
     final override lazy val empty: A =
-      inst.construct([a] => (F: F[a]) => F.empty)
+      inst.construct: [a] =>
+        F => F.empty
 
   object Strict:
     given product[A: ProductInstancesOf[Monoid]]: DerivedMonoid[A] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedMonoidK.scala b/core/src/main/scala-3/cats/derived/DerivedMonoidK.scala
index 5f131333..fe28d816 100644
--- a/core/src/main/scala-3/cats/derived/DerivedMonoidK.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedMonoidK.scala
@@ -59,7 +59,8 @@ object DerivedMonoidK:
         DerivedSemigroupK.Product[T, F]:
 
     final override def empty[A]: F[A] =
-      inst.construct([f[_]] => (F: T[f]) => F.empty[A])
+      inst.construct: [f[_]] =>
+        F => F.empty[A]
 
   object Strict:
     given product[F[_]: ProductInstancesOf[MonoidK]]: DerivedMonoidK[F] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedNonEmptyTraverse.scala b/core/src/main/scala-3/cats/derived/DerivedNonEmptyTraverse.scala
index d071acc0..f80fb838 100644
--- a/core/src/main/scala-3/cats/derived/DerivedNonEmptyTraverse.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedNonEmptyTraverse.scala
@@ -64,7 +64,8 @@ object DerivedNonEmptyTraverse:
         DerivedTraverse.Coproduct[T, F]:
 
     final override def nonEmptyTraverse[G[_], A, B](fa: F[A])(f: A => G[B])(using G: Apply[G]): G[F[B]] =
-      inst.fold(fa)([f[a] <: F[a]] => (F: T[f], fa: f[A]) => G.widen[f[B], F[B]](F.nonEmptyTraverse(fa)(f)))
+      inst.fold(fa): [f[a] <: F[a]] =>
+        (F, fa) => G.widen[f[B], F[B]](F.nonEmptyTraverse(fa)(f))
 
   private type Alt[F[_]] = [A] =>> Either[F[A], A]
   private given [F[_]](using F: Apply[F]): Applicative[Alt[F]] with
diff --git a/core/src/main/scala-3/cats/derived/DerivedOrder.scala b/core/src/main/scala-3/cats/derived/DerivedOrder.scala
index 6502dc21..3a92903c 100644
--- a/core/src/main/scala-3/cats/derived/DerivedOrder.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedOrder.scala
@@ -36,14 +36,14 @@ object DerivedOrder:
   trait Product[T[x] <: Order[x], A](using inst: ProductInstances[T, A]) extends Order[A]:
     def compare(x: A, y: A): Int =
       inst.foldLeft2(x, y)(0: Int): [t] =>
-        (acc: Int, ord: T[t], t0: t, t1: t) =>
-          val cmp = ord.compare(t0, t1)
+        (acc, ord, x, y) =>
+          val cmp = ord.compare(x, y)
           Complete(cmp != 0)(cmp)(acc)
 
   trait Coproduct[T[x] <: Order[x], A](using inst: CoproductInstances[T, A]) extends Order[A]:
     def compare(x: A, y: A): Int =
       inst.fold2(x, y)((x: Int, y: Int) => x - y): [t] =>
-        (ord: T[t], t0: t, t1: t) => ord.compare(t0, t1)
+        (ord, x, y) => ord.compare(x, y)
 
   object Strict:
     export DerivedOrder.coproduct
diff --git a/core/src/main/scala-3/cats/derived/DerivedPartialOrder.scala b/core/src/main/scala-3/cats/derived/DerivedPartialOrder.scala
index 9683bc3d..77679c8a 100644
--- a/core/src/main/scala-3/cats/derived/DerivedPartialOrder.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedPartialOrder.scala
@@ -36,14 +36,14 @@ object DerivedPartialOrder:
   trait Product[T[x] <: PartialOrder[x], A](using inst: ProductInstances[T, A]) extends PartialOrder[A]:
     def partialCompare(x: A, y: A): Double =
       inst.foldLeft2(x, y)(0: Double): [t] =>
-        (acc: Double, ord: T[t], t0: t, t1: t) =>
-          val cmp = ord.partialCompare(t0, t1)
+        (acc, ord, x, y) =>
+          val cmp = ord.partialCompare(x, y)
           Complete(cmp != 0)(cmp)(acc)
 
   trait Coproduct[T[x] <: PartialOrder[x], A](using inst: CoproductInstances[T, A]) extends PartialOrder[A]:
     def partialCompare(x: A, y: A): Double =
       inst.fold2(x, y)(Double.NaN: Double): [t] =>
-        (ord: T[t], t0: t, t1: t) => ord.partialCompare(t0, t1)
+        (ord, x, y) => ord.partialCompare(x, y)
 
   object Strict:
     export DerivedPartialOrder.coproduct
diff --git a/core/src/main/scala-3/cats/derived/DerivedPure.scala b/core/src/main/scala-3/cats/derived/DerivedPure.scala
index 8369f998..97394a22 100644
--- a/core/src/main/scala-3/cats/derived/DerivedPure.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedPure.scala
@@ -42,4 +42,5 @@ object DerivedPure:
 
   object Strict:
     given product[F[_]: ProductInstancesOf[Pure]]: DerivedPure[F] = new Pure[F]:
-      def pure[A](a: A): F[A] = ProductInstances.construct([f[_]] => (F: Pure[f]) => F.pure(a))
+      def pure[A](a: A): F[A] = ProductInstances.construct: [f[_]] =>
+        F => F.pure(a)
diff --git a/core/src/main/scala-3/cats/derived/DerivedReducible.scala b/core/src/main/scala-3/cats/derived/DerivedReducible.scala
index 49273fbd..d71d5b78 100644
--- a/core/src/main/scala-3/cats/derived/DerivedReducible.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedReducible.scala
@@ -53,32 +53,32 @@ object DerivedReducible:
       Eval.now(None)
 
     final override def reduceLeftTo[A, B](fa: F[A])(f: A => B)(g: (B, A) => B): B =
-      inst
-        .foldLeft[A, Option[B]](fa)(None) { [f[_]] => (acc: Option[B], F: T[f], fa: f[A]) =>
+      val result = inst.foldLeft[A, Option[B]](fa)(None): [f[_]] =>
+        (acc, F, fa) =>
           acc match
             case Some(b) => Some(F.foldLeft(fa, b)(g))
             case None => F.reduceLeftToOption(fa)(f)(g)
-        }
-        .get
+      result.get
 
     final override def reduceRightTo[A, B](fa: F[A])(f: A => B)(g: (A, Eval[B]) => Eval[B]): Eval[B] =
-      inst
-        .foldRight[A, Eval[Option[B]]](fa)(evalNone) { [f[_]] => (F: T[f], fa: f[A], acc: Eval[Option[B]]) =>
+      val result = inst.foldRight[A, Eval[Option[B]]](fa)(evalNone): [f[_]] =>
+        (F, fa, acc) =>
           acc.flatMap:
             case Some(b) => F.foldRight(fa, Eval.now(b))(g).map(Some.apply)
             case None => F.reduceRightToOption(fa)(f)(g)
-        }
-        .map(_.get)
+      result.map(_.get)
 
   trait Coproduct[T[f[_]] <: Reducible[f], F[_]](using inst: CoproductInstances[T, F])
       extends DerivedFoldable.Coproduct[T, F],
         Reducible[F]:
 
     final override def reduceLeftTo[A, B](fa: F[A])(f: A => B)(g: (B, A) => B): B =
-      inst.fold(fa)([f[_]] => (F: T[f], fa: f[A]) => F.reduceLeftTo(fa)(f)(g))
+      inst.fold(fa): [f[_]] =>
+        (F, fa) => F.reduceLeftTo(fa)(f)(g)
 
     final override def reduceRightTo[A, B](fa: F[A])(f: A => B)(g: (A, Eval[B]) => Eval[B]): Eval[B] =
-      inst.fold(fa)([f[_]] => (F: T[f], fa: f[A]) => Eval.defer(F.reduceRightTo(fa)(f)(g)))
+      inst.fold(fa): [f[_]] =>
+        (F, fa) => Eval.defer(F.reduceRightTo(fa)(f)(g))
 
   object Strict:
     def product[F[_]: ProductInstancesOf[Foldable]](ev: Reducible[?]): DerivedReducible[F] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedSemigroup.scala b/core/src/main/scala-3/cats/derived/DerivedSemigroup.scala
index 8ff1cd91..5d659d21 100644
--- a/core/src/main/scala-3/cats/derived/DerivedSemigroup.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedSemigroup.scala
@@ -24,7 +24,8 @@ object DerivedSemigroup:
 
   trait Product[F[x] <: Semigroup[x], A](using inst: ProductInstances[F, A]) extends Semigroup[A]:
     final override def combine(x: A, y: A): A =
-      inst.map2(x, y)([a] => (F: F[a], x: a, y: a) => F.combine(x, y))
+      inst.map2(x, y): [a] =>
+        (F, x, y) => F.combine(x, y)
 
   object Strict:
     given product[A: ProductInstancesOf[Semigroup]]: DerivedSemigroup[A] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedSemigroupK.scala b/core/src/main/scala-3/cats/derived/DerivedSemigroupK.scala
index abf0f658..d4709366 100644
--- a/core/src/main/scala-3/cats/derived/DerivedSemigroupK.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedSemigroupK.scala
@@ -54,7 +54,8 @@ object DerivedSemigroupK:
 
   trait Product[T[f[_]] <: SemigroupK[f], F[_]](using inst: ProductInstances[T, F]) extends SemigroupK[F]:
     final override def combineK[A](x: F[A], y: F[A]): F[A] =
-      inst.map2(x, y)([f[_]] => (F: T[f], x: f[A], y: f[A]) => F.combineK(x, y))
+      inst.map2(x, y): [f[_]] =>
+        (F, x, y) => F.combineK(x, y)
 
   object Strict:
     given product[F[_]: ProductInstancesOf[SemigroupK]]: DerivedSemigroupK[F] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedShow.scala b/core/src/main/scala-3/cats/derived/DerivedShow.scala
index 6d4dfdc2..35c2fbc9 100644
--- a/core/src/main/scala-3/cats/derived/DerivedShow.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedShow.scala
@@ -54,7 +54,7 @@ object DerivedShow:
         while i < n do
           sb.append(labels(i))
           sb.append(" = ")
-          sb.append(inst.project(a)(i)([t] => (show: F[t], x: t) => show.show(x)))
+          sb.append(inst.project(a)(i)([t] => (show, x) => show.show(x)))
           sb.append(", ")
           i += 1
 
@@ -64,7 +64,8 @@ object DerivedShow:
         sb.toString
 
   trait Coproduct[F[x] <: Show[x], A](using inst: CoproductInstances[F, A]) extends Show[A]:
-    def show(a: A): String = inst.fold(a)([t] => (st: F[t], t: t) => st.show(t))
+    def show(a: A): String = inst.fold(a): [t] =>
+      (st, t) => st.show(t)
 
   object Strict:
     given product[A: Labelling](using => ProductInstances[Show, A]): DerivedShow[A] =
diff --git a/core/src/main/scala-3/cats/derived/DerivedShowPretty.scala b/core/src/main/scala-3/cats/derived/DerivedShowPretty.scala
index c2d27329..6c5893dd 100644
--- a/core/src/main/scala-3/cats/derived/DerivedShowPretty.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedShowPretty.scala
@@ -76,7 +76,7 @@ object DerivedShowPretty:
           case h :: t => lines :::= s"  ${labels(n - 1)} = $h" :: t.map(s => "  " + s)
         var i = n - 2
         while i >= 0 do
-          inst.project(a)(i)([a] => (show: Or[a], x: a) => show(x)) match
+          inst.project(a)(i)([a] => (show, x) => show(x)) match
             case Nil => lines ::= s"  ${labels(i)} = \"\","
             case v :: Nil => lines ::= s"  ${labels(i)} = $v,"
             case h :: t => lines = s"  ${labels(i)} = $h" :: t.init.map(s => "  " + s) ::: s"  ${t.last}," :: lines
@@ -84,10 +84,12 @@ object DerivedShowPretty:
         s"$prefix(" :: lines
 
   trait Coproduct[A](using inst: CoproductInstances[Or, A]) extends ShowPretty[A]:
-    def showLines(a: A): List[String] = inst.fold(a)([a] => (show: DerivedShowPretty.Or[a], x: a) => show(x))
+    def showLines(a: A): List[String] = inst.fold(a): [a] =>
+      (show, x) => show(x)
 
   object Strict:
     export DerivedShowPretty.coproduct
     given product[A: Labelling](using inst: => ProductInstances[Show, A]): DerivedShowPretty[A] =
-      given ProductInstances[Or, A] = inst.mapK([a] => (show: Show[a]) => DerivedShowPretty.Or.fromShow(show))
+      given ProductInstances[Or, A] = inst.mapK: [a] =>
+        show => DerivedShowPretty.Or.fromShow(show)
       DerivedShowPretty.product
diff --git a/core/src/main/scala-3/cats/derived/DerivedTraverse.scala b/core/src/main/scala-3/cats/derived/DerivedTraverse.scala
index fcbb7eb2..308c7157 100644
--- a/core/src/main/scala-3/cats/derived/DerivedTraverse.scala
+++ b/core/src/main/scala-3/cats/derived/DerivedTraverse.scala
@@ -52,10 +52,10 @@ object DerivedTraverse:
         DerivedFoldable.Product[T, F]:
 
     final override def traverse[G[_], A, B](fa: F[A])(f: A => G[B])(using G: Applicative[G]): G[F[B]] =
-      val pure = [a] => (x: a) => G.pure(x)
-      val map = [a, b] => (ga: G[a], f: a => b) => G.map(ga)(f)
-      val ap = [a, b] => (gf: G[a => b], ga: G[a]) => G.ap(gf)(ga)
-      inst.traverse[A, G, B](fa)(map)(pure)(ap)([f[_]] => (F: T[f], fa: f[A]) => F.traverse(fa)(f))
+      inst.traverse[A, G, B](fa)([a, b] => (ga, f) => G.map(ga)(f))([a] => x => G.pure(x))([a, b] =>
+        (gf, ga) => G.ap(gf)(ga)
+      ): [f[_]] =>
+        (F, fa) => F.traverse(fa)(f)
 
   trait Coproduct[T[f[_]] <: Traverse[f], F[_]](using inst: CoproductInstances[T, F])
       extends Traverse[F],
@@ -63,7 +63,8 @@ object DerivedTraverse:
         DerivedFoldable.Coproduct[T, F]:
 
     final override def traverse[G[_], A, B](fa: F[A])(f: A => G[B])(using G: Applicative[G]): G[F[B]] =
-      inst.fold(fa)([f[a] <: F[a]] => (F: T[f], fa: f[A]) => G.widen[f[B], F[B]](F.traverse(fa)(f)))
+      inst.fold(fa): [f[a] <: F[a]] =>
+        (F, fa) => G.widen[f[B], F[B]](F.traverse(fa)(f))
 
   object Strict:
     given product[F[_]: ProductInstancesOf[Traverse]]: DerivedTraverse[F] =
diff --git a/core/src/test/scala-3/cats/derived/KittensSuite.scala b/core/src/test/scala-3/cats/derived/KittensSuite.scala
index 14a11859..a636816b 100644
--- a/core/src/test/scala-3/cats/derived/KittensSuite.scala
+++ b/core/src/test/scala-3/cats/derived/KittensSuite.scala
@@ -58,11 +58,11 @@ object KittensSuite:
       .withMinSize(0)
 
     // The default Arbitrary[Duration] causes overflow.
-    given Arbitrary[Duration] = Arbitrary(Gen.chooseNum(-750.days.toNanos, 750.days.toNanos).map(Duration.fromNanos))
+    given Arbitrary[Duration] = Arbitrary(Gen.chooseNum((-750).days.toNanos, 750.days.toNanos).map(Duration.fromNanos))
     given [A: Arbitrary]: Arbitrary[List[A]] = Arbitrary.arbContainer
     given [A <: Singleton: ValueOf]: Arbitrary[A] = Arbitrary(Gen.const(valueOf[A]))
     @unused given [A <: Singleton: ValueOf]: Cogen[A] = Cogen((seed, _) => seed)
-    inline given [F[_]]: Isomorphisms[F] = Isomorphisms.invariant(summonInline)
+    inline given [F[_]]: Isomorphisms[F] = Isomorphisms.invariant(using summonInline)
 
     given [A <: Product](using mirror: Mirror.ProductOf[A], via: Arbitrary[mirror.MirroredElemTypes]): Arbitrary[A] =
       Arbitrary(via.arbitrary.map(mirror.fromTuple))