diff --git a/control/src/main/java/com/github/tonivade/purefun/control/Control.java b/control/src/main/java/com/github/tonivade/purefun/control/Control.java
index 6067da0de..82a9f0b29 100644
--- a/control/src/main/java/com/github/tonivade/purefun/control/Control.java
+++ b/control/src/main/java/com/github/tonivade/purefun/control/Control.java
@@ -15,7 +15,7 @@
 import com.github.tonivade.purefun.core.Tuple2;
 
 @HigherKind
-public sealed interface Control<T> extends ControlOf<T>, Bindable<Control_, T> {
+public sealed interface Control<T> extends ControlOf<T>, Bindable<Control<?>, T> {
 
   <R> Result<R> apply(MetaCont<T, R> cont);
 
@@ -29,12 +29,12 @@ default <R> Control<R> map(Function1<? super T, ? extends R> mapper) {
   }
 
   @Override
-  default <R> Control<R> flatMap(Function1<? super T, ? extends Kind<Control_, ? extends R>> mapper) {
+  default <R> Control<R> flatMap(Function1<? super T, ? extends Kind<Control<?>, ? extends R>> mapper) {
     return new FlatMapped<>(Control.this, mapper);
   }
 
   @Override
-  default <R> Control<R> andThen(Kind<Control_, ? extends R> next) {
+  default <R> Control<R> andThen(Kind<Control<?>, ? extends R> next) {
     return flatMap(ignore -> next);
   }
 
@@ -85,9 +85,9 @@ public <R1> Result<R1> apply(MetaCont<R, R1> cont) {
   final class FlatMapped<T, R> implements Control<R> {
     
     private final Control<T> self;
-    private final Function1<? super T, ? extends Kind<Control_, ? extends R>> outer;
+    private final Function1<? super T, ? extends Kind<Control<?>, ? extends R>> outer;
     
-    private FlatMapped(Control<T> self, Function1<? super T, ? extends Kind<Control_, ? extends R>> outer) {
+    private FlatMapped(Control<T> self, Function1<? super T, ? extends Kind<Control<?>, ? extends R>> outer) {
       this.self = checkNonNull(self);
       this.outer = checkNonNull(outer);
     }
@@ -225,7 +225,7 @@ public <R> Control<R> map(Function1<? super T, ? extends R> mapper) {
 
     @Override
     @SuppressWarnings("unchecked")
-    public <R> Control<R> flatMap(Function1<? super T, ? extends Kind<Control_, ? extends R>> mapper) {
+    public <R> Control<R> flatMap(Function1<? super T, ? extends Kind<Control<?>, ? extends R>> mapper) {
       return (Control<R>) this;
     }
   }
diff --git a/control/src/main/java/com/github/tonivade/purefun/control/MetaCont.java b/control/src/main/java/com/github/tonivade/purefun/control/MetaCont.java
index 43fafd535..f0428e6fb 100644
--- a/control/src/main/java/com/github/tonivade/purefun/control/MetaCont.java
+++ b/control/src/main/java/com/github/tonivade/purefun/control/MetaCont.java
@@ -27,7 +27,7 @@ default <R> MetaCont<R, B> map(Function1<? super R, ? extends A> mapper) {
   }
 
   @SuppressWarnings({"unchecked", "rawtypes"})
-  default <R> MetaCont<R, B> flatMap(Function1<? super R, ? extends Kind<Control_, ? extends A>> mapper) {
+  default <R> MetaCont<R, B> flatMap(Function1<? super R, ? extends Kind<Control<?>, ? extends A>> mapper) {
     Function1<?, Control<?>> f = (Function1) mapper;
     return new Frames<>(NonEmptyList.of(f), this);
   }
@@ -114,7 +114,7 @@ public <R> Tuple2<MetaCont<A, R>, MetaCont<R, C>> splitAt(Marker.Cont<R> cont) {
 
     @Override
     @SuppressWarnings({"unchecked", "rawtypes"})
-    public <R> MetaCont<R, C> flatMap(Function1<? super R, ? extends Kind<Control_, ? extends A>> mapper) {
+    public <R> MetaCont<R, C> flatMap(Function1<? super R, ? extends Kind<Control<?>, ? extends A>> mapper) {
       NonEmptyList<Function1<?, Control<?>>> list = NonEmptyList.of((Function1) mapper);
       return new Frames<>(list.appendAll(frames), tail);
     }
diff --git a/control/src/test/java/com/github/tonivade/purefun/control/ControlTest.java b/control/src/test/java/com/github/tonivade/purefun/control/ControlTest.java
index 1d0b6b9d5..714e84cb4 100644
--- a/control/src/test/java/com/github/tonivade/purefun/control/ControlTest.java
+++ b/control/src/test/java/com/github/tonivade/purefun/control/ControlTest.java
@@ -54,7 +54,7 @@ private Control<Integer> program(Amb amb) {
   }
 
   private Control<Integer> program(State<Integer> state, Amb amb) {
-    return Instances.monad(Control_.class).use()
+    return Instances.<Control<?>>monad().use()
         .then(state.get())
         .flatMap(x -> amb.flip().flatMap(b -> b ? state.set(x + 1) : pure(unit())))
         .then(state.get())
diff --git a/control/src/test/java/com/github/tonivade/purefun/control/PipingExample.java b/control/src/test/java/com/github/tonivade/purefun/control/PipingExample.java
index 6c5a516bc..dedc1cb6e 100644
--- a/control/src/test/java/com/github/tonivade/purefun/control/PipingExample.java
+++ b/control/src/test/java/com/github/tonivade/purefun/control/PipingExample.java
@@ -76,9 +76,9 @@ static abstract class Process<R, P, E> extends Stateful<R, Kind<P, Control<R>>,
     }
   }
 
-  static final class Down<R> extends Process<R, Prod_, Receive> implements Receive {
+  static final class Down<R> extends Process<R, Prod<?>, Receive> implements Receive {
 
-    Down(Kind<Prod_, Control<R>> init) {
+    Down(Kind<Prod<?>, Control<R>> init) {
       super(init);
     }
 
@@ -91,9 +91,9 @@ public Control<Integer> receive() {
     }
   }
 
-  static final class Up<R> extends Process<R, Cons_, Send> implements Send {
+  static final class Up<R> extends Process<R, Cons<?>, Send> implements Send {
 
-    Up(Kind<Cons_, Control<R>> init) {
+    Up(Kind<Cons<?>, Control<R>> init) {
       super(init);
     }
 
@@ -110,13 +110,13 @@ public Control<Unit> send(int n) {
 @HigherKind
 final class Prod<R> implements ProdOf<R> {
 
-  private final Function1<Unit, Function1<Kind<Cons_, R>, R>> apply;
+  private final Function1<Unit, Function1<Kind<Cons<?>, R>, R>> apply;
 
-  Prod(Function1<Unit, Function1<Kind<Cons_, R>, R>> apply) {
+  Prod(Function1<Unit, Function1<Kind<Cons<?>, R>, R>> apply) {
     this.apply = requireNonNull(apply);
   }
 
-  public Function1<Kind<Cons_, R>, R> apply(Unit unit) {
+  public Function1<Kind<Cons<?>, R>, R> apply(Unit unit) {
     return apply.apply(unit);
   }
 }
@@ -124,13 +124,13 @@ public Function1<Kind<Cons_, R>, R> apply(Unit unit) {
 @HigherKind
 final class Cons<R> implements ConsOf<R> {
 
-  private final Function1<Integer, Function1<Kind<Prod_, R>, R>> apply;
+  private final Function1<Integer, Function1<Kind<Prod<?>, R>, R>> apply;
 
-  Cons(Function1<Integer, Function1<Kind<Prod_, R>, R>> apply) {
+  Cons(Function1<Integer, Function1<Kind<Prod<?>, R>, R>> apply) {
     this.apply = requireNonNull(apply);
   }
 
-  public Function1<Kind<Prod_, R>, R> apply(int n) {
+  public Function1<Kind<Prod<?>, R>, R> apply(int n) {
     return apply.apply(n);
   }
 }
diff --git a/control/src/test/java/com/github/tonivade/purefun/control/TwitterExample.java b/control/src/test/java/com/github/tonivade/purefun/control/TwitterExample.java
index c9c8af1c4..3ca0d81fb 100644
--- a/control/src/test/java/com/github/tonivade/purefun/control/TwitterExample.java
+++ b/control/src/test/java/com/github/tonivade/purefun/control/TwitterExample.java
@@ -37,7 +37,7 @@ static <R> Control<R> instanceOf(Function1<Twitter, Control<R>> apply) {
   }
   
   private Control<ImmutableList<Tweet>> program(Twitter twitter) {
-    return Instances.<Control_>monad().use()
+    return Instances.<Control<?>>monad().use()
       .then(twitter.userTweets("12345"))
       .then(twitter.userTweets("54321"))
       .apply(ImmutableList::appendAll)
diff --git a/core/src/main/java/com/github/tonivade/purefun/concurrent/Future.java b/core/src/main/java/com/github/tonivade/purefun/concurrent/Future.java
index f7e8f6c63..49b3fb1d5 100644
--- a/core/src/main/java/com/github/tonivade/purefun/concurrent/Future.java
+++ b/core/src/main/java/com/github/tonivade/purefun/concurrent/Future.java
@@ -67,7 +67,7 @@
  * @see Promise
  */
 @HigherKind
-public sealed interface Future<T> extends FutureOf<T>, Bindable<Future_, T> {
+public sealed interface Future<T> extends FutureOf<T>, Bindable<Future<?>, T> {
 
   Executor DEFAULT_EXECUTOR = Executors.newVirtualThreadPerTaskExecutor();
 
@@ -88,7 +88,7 @@ public sealed interface Future<T> extends FutureOf<T>, Bindable<Future_, T> {
   Future<T> mapError(Function1<? super Throwable, ? extends Throwable> mapper);
 
   @Override
-  <R> Future<R> flatMap(Function1<? super T, ? extends Kind<Future_, ? extends R>> mapper);
+  <R> Future<R> flatMap(Function1<? super T, ? extends Kind<Future<?>, ? extends R>> mapper);
 
   <R> Future<R> andThen(Future<? extends R> next);
 
@@ -352,7 +352,7 @@ public Future<T> mapError(Function1<? super Throwable, ? extends Throwable> mapp
   }
 
   @Override
-  public <R> Future<R> flatMap(Function1<? super T, ? extends Kind<Future_, ? extends R>> mapper) {
+  public <R> Future<R> flatMap(Function1<? super T, ? extends Kind<Future<?>, ? extends R>> mapper) {
     return chain(value -> value.fold(e -> Future.failure(executor, e), mapper));
   }
 
@@ -419,7 +419,7 @@ private <R> Future<R> transform(Function1<? super Try<? extends T>, ? extends Tr
           promise.onComplete(value -> p.tryComplete(mapper.apply(value))), this::cancel);
   }
 
-  private <R> Future<R> chain(Function1<? super Try<? extends T>, ? extends Kind<Future_, ? extends R>> mapper) {
+  private <R> Future<R> chain(Function1<? super Try<? extends T>, ? extends Kind<Future<?>, ? extends R>> mapper) {
     checkNonNull(executor);
     checkNonNull(mapper);
     return new FutureImpl<>(executor,
diff --git a/core/src/main/java/com/github/tonivade/purefun/concurrent/Par.java b/core/src/main/java/com/github/tonivade/purefun/concurrent/Par.java
index 066ab6b73..369721539 100644
--- a/core/src/main/java/com/github/tonivade/purefun/concurrent/Par.java
+++ b/core/src/main/java/com/github/tonivade/purefun/concurrent/Par.java
@@ -28,7 +28,7 @@
 
 @HigherKind
 @FunctionalInterface
-public non-sealed interface Par<T> extends ParOf<T>, Bindable<Par_, T> {
+public non-sealed interface Par<T> extends ParOf<T>, Bindable<Par<?>, T> {
 
   Future<T> apply(Executor executor);
 
@@ -46,7 +46,7 @@ default <R> Par<R> map(Function1<? super T, ? extends R> mapper) {
   }
 
   @Override
-  default <R> Par<R> flatMap(Function1<? super T, ? extends Kind<Par_, ? extends R>> mapper) {
+  default <R> Par<R> flatMap(Function1<? super T, ? extends Kind<Par<?>, ? extends R>> mapper) {
     return executor -> apply(executor).flatMap(value -> mapper.andThen(ParOf::narrowK).apply(value).apply(executor));
   }
 
@@ -104,7 +104,7 @@ static <T> Par<T> task(Producer<? extends T> producer) {
     return executor -> Future.task(executor, producer);
   }
 
-  static <T> Par<T> defer(Producer<? extends Kind<Par_, ? extends T>> producer) {
+  static <T> Par<T> defer(Producer<? extends Kind<Par<?>, ? extends T>> producer) {
     return executor -> {
       Producer<Par<T>> andThen = producer.andThen(ParOf::narrowK);
       return andThen.get().apply(executor);
diff --git a/core/src/main/java/com/github/tonivade/purefun/concurrent/Promise.java b/core/src/main/java/com/github/tonivade/purefun/concurrent/Promise.java
index 94c4e52e4..097eb4c9b 100644
--- a/core/src/main/java/com/github/tonivade/purefun/concurrent/Promise.java
+++ b/core/src/main/java/com/github/tonivade/purefun/concurrent/Promise.java
@@ -35,7 +35,7 @@
 import com.github.tonivade.purefun.type.TryOf;
 
 @HigherKind
-public sealed interface Promise<T> extends PromiseOf<T>, Bindable<Promise_, T>, Applicable<Promise_, T> permits PromiseImpl {
+public sealed interface Promise<T> extends PromiseOf<T>, Bindable<Promise<?>, T>, Applicable<Promise<?>, T> permits PromiseImpl {
 
   boolean tryComplete(Try<? extends T> value);
 
@@ -71,15 +71,15 @@ default Promise<T> onFailure(Consumer1<? super Throwable> consumer) {
   <R> Promise<R> map(Function1<? super T, ? extends R> mapper);
 
   @Override
-  <R> Promise<R> ap(Kind<Promise_, ? extends Function1<? super T, ? extends R>> apply);
+  <R> Promise<R> ap(Kind<Promise<?>, ? extends Function1<? super T, ? extends R>> apply);
 
   @Override
-  default <R> Promise<R> andThen(Kind<Promise_, ? extends R> next) {
+  default <R> Promise<R> andThen(Kind<Promise<?>, ? extends R> next) {
     return PromiseOf.narrowK(Bindable.super.andThen(next));
   }
 
   @Override
-  <R> Promise<R> flatMap(Function1<? super T, ? extends Kind<Promise_, ? extends R>> mapper);
+  <R> Promise<R> flatMap(Function1<? super T, ? extends Kind<Promise<?>, ? extends R>> mapper);
 
   default Promise<Unit> then(Consumer1<? super T> next) {
     return map(next.asFunction());
@@ -236,7 +236,7 @@ public Promise<T> onComplete(Consumer1<? super Try<? extends T>> consumer) {
   }
 
   @Override
-  public <R> Promise<R> ap(Kind<Promise_, ? extends Function1<? super T, ? extends R>> apply) {
+  public <R> Promise<R> ap(Kind<Promise<?>, ? extends Function1<? super T, ? extends R>> apply) {
     Promise<R> result = new PromiseImpl<>(executor);
     onComplete(try1 -> PromiseOf.narrowK(apply).onComplete(
         try2 -> result.tryComplete(Try.map2(try2,  try1, Function1::apply))));
@@ -251,7 +251,7 @@ public <R> Promise<R> map(Function1<? super T, ? extends R> mapper) {
   }
 
   @Override
-  public <R> Promise<R> flatMap(Function1<? super T, ? extends Kind<Promise_, ? extends R>> mapper) {
+  public <R> Promise<R> flatMap(Function1<? super T, ? extends Kind<Promise<?>, ? extends R>> mapper) {
     Promise<R> other = new PromiseImpl<>(executor);
     onComplete(value -> {
       Try<Promise<R>> map = value.map(mapper.andThen(PromiseOf::narrowK));
diff --git a/core/src/main/java/com/github/tonivade/purefun/data/ImmutableArray.java b/core/src/main/java/com/github/tonivade/purefun/data/ImmutableArray.java
index 34d701c9c..7aa3df6fb 100644
--- a/core/src/main/java/com/github/tonivade/purefun/data/ImmutableArray.java
+++ b/core/src/main/java/com/github/tonivade/purefun/data/ImmutableArray.java
@@ -61,7 +61,7 @@ default <R> ImmutableArray<R> map(Function1<? super E, ? extends R> mapper) {
   }
 
   @Override
-  default <R> ImmutableArray<R> flatMap(Function1<? super E, ? extends Kind<Sequence_, ? extends R>> mapper) {
+  default <R> ImmutableArray<R> flatMap(Function1<? super E, ? extends Kind<Sequence<?>, ? extends R>> mapper) {
     return ImmutableArray.from(stream().flatMap(mapper.andThen(SequenceOf::<R>narrowK).andThen(Sequence::stream)::apply));
   }
 
diff --git a/core/src/main/java/com/github/tonivade/purefun/data/ImmutableList.java b/core/src/main/java/com/github/tonivade/purefun/data/ImmutableList.java
index f1b958636..346ba69be 100644
--- a/core/src/main/java/com/github/tonivade/purefun/data/ImmutableList.java
+++ b/core/src/main/java/com/github/tonivade/purefun/data/ImmutableList.java
@@ -66,7 +66,7 @@ default <R> ImmutableList<R> map(Function1<? super E, ? extends R> mapper) {
   }
 
   @Override
-  default <R> ImmutableList<R> flatMap(Function1<? super E, ? extends Kind<Sequence_, ? extends R>> mapper) {
+  default <R> ImmutableList<R> flatMap(Function1<? super E, ? extends Kind<Sequence<?>, ? extends R>> mapper) {
     return ImmutableList.from(stream().flatMap(mapper.andThen(SequenceOf::<R>narrowK).andThen(Sequence::stream)::apply));
   }
 
diff --git a/core/src/main/java/com/github/tonivade/purefun/data/ImmutableSet.java b/core/src/main/java/com/github/tonivade/purefun/data/ImmutableSet.java
index 7525cdeb6..f33908d9f 100644
--- a/core/src/main/java/com/github/tonivade/purefun/data/ImmutableSet.java
+++ b/core/src/main/java/com/github/tonivade/purefun/data/ImmutableSet.java
@@ -56,7 +56,7 @@ default <R> ImmutableSet<R> map(Function1<? super E, ? extends R> mapper) {
   }
 
   @Override
-  default <R> ImmutableSet<R> flatMap(Function1<? super E, ? extends Kind<Sequence_, ? extends R>> mapper) {
+  default <R> ImmutableSet<R> flatMap(Function1<? super E, ? extends Kind<Sequence<?>, ? extends R>> mapper) {
     return ImmutableSet.from(stream().flatMap(mapper.andThen(SequenceOf::narrowK).andThen(Sequence::stream)::apply));
   }
 
diff --git a/core/src/main/java/com/github/tonivade/purefun/data/ImmutableTree.java b/core/src/main/java/com/github/tonivade/purefun/data/ImmutableTree.java
index 456088740..161773b7c 100644
--- a/core/src/main/java/com/github/tonivade/purefun/data/ImmutableTree.java
+++ b/core/src/main/java/com/github/tonivade/purefun/data/ImmutableTree.java
@@ -78,11 +78,11 @@ default <R> ImmutableTree<R> map(Comparator<? super R> comparator, Function1<? s
   }
 
   @Override
-  default <R> ImmutableTree<R> flatMap(Function1<? super E, ? extends Kind<Sequence_, ? extends R>> mapper) {
+  default <R> ImmutableTree<R> flatMap(Function1<? super E, ? extends Kind<Sequence<?>, ? extends R>> mapper) {
     return ImmutableTree.from(naturalOrder(), stream().flatMap(mapper.andThen(SequenceOf::narrowK).andThen(Sequence::stream)::apply));
   }
 
-  default <R> ImmutableTree<R> flatMap(Comparator<? super R> comparator, Function1<? super E, ? extends Kind<Sequence_, ? extends R>> mapper) {
+  default <R> ImmutableTree<R> flatMap(Comparator<? super R> comparator, Function1<? super E, ? extends Kind<Sequence<?>, ? extends R>> mapper) {
     return ImmutableTree.from(comparator, stream().flatMap(mapper.andThen(SequenceOf::narrowK).andThen(Sequence::stream)::apply));
   }
 
diff --git a/core/src/main/java/com/github/tonivade/purefun/data/NonEmptyList.java b/core/src/main/java/com/github/tonivade/purefun/data/NonEmptyList.java
index 82eb4148f..ac100f501 100644
--- a/core/src/main/java/com/github/tonivade/purefun/data/NonEmptyList.java
+++ b/core/src/main/java/com/github/tonivade/purefun/data/NonEmptyList.java
@@ -40,7 +40,7 @@ public <R> NonEmptyList<R> map(Function1<? super E, ? extends R> mapper) {
   }
 
   @Override
-  public <R> NonEmptyList<R> flatMap(Function1<? super E, ? extends Kind<Sequence_, ? extends R>> mapper) {
+  public <R> NonEmptyList<R> flatMap(Function1<? super E, ? extends Kind<Sequence<?>, ? extends R>> mapper) {
     return of(value.flatMap(mapper));
   }
 
diff --git a/core/src/main/java/com/github/tonivade/purefun/data/Sequence.java b/core/src/main/java/com/github/tonivade/purefun/data/Sequence.java
index 83248acd4..801015909 100644
--- a/core/src/main/java/com/github/tonivade/purefun/data/Sequence.java
+++ b/core/src/main/java/com/github/tonivade/purefun/data/Sequence.java
@@ -33,7 +33,7 @@
 import com.github.tonivade.purefun.type.Option;
 
 @HigherKind
-public non-sealed interface Sequence<E> extends SequenceOf<E>, Iterable<E>, Bindable<Sequence_, E> {
+public non-sealed interface Sequence<E> extends SequenceOf<E>, Iterable<E>, Bindable<Sequence<?>, E> {
 
   int size();
 
@@ -59,7 +59,7 @@ default boolean containsAll(Iterable<?> elements) {
   <R> Sequence<R> map(Function1<? super E, ? extends R> mapper);
 
   @Override
-  <R> Sequence<R> flatMap(Function1<? super E, ? extends Kind<Sequence_, ? extends R>> mapper);
+  <R> Sequence<R> flatMap(Function1<? super E, ? extends Kind<Sequence<?>, ? extends R>> mapper);
 
   Sequence<E> filter(Matcher1<? super E> matcher);
 
diff --git a/core/src/main/java/com/github/tonivade/purefun/type/Either.java b/core/src/main/java/com/github/tonivade/purefun/type/Either.java
index a1f1bc222..c2302017f 100644
--- a/core/src/main/java/com/github/tonivade/purefun/type/Either.java
+++ b/core/src/main/java/com/github/tonivade/purefun/type/Either.java
@@ -39,7 +39,7 @@
  * @param <R> type of the right value, positive case
  */
 @HigherKind
-public sealed interface Either<L, R> extends EitherOf<L, R>, Bindable<Kind<Either_, L>, R>, Applicable<Kind<Either_, L>, R> {
+public sealed interface Either<L, R> extends EitherOf<L, R>, Bindable<Kind<Either<?, ?>, L>, R>, Applicable<Kind<Either<?, ?>, L>, R> {
 
   static <L, R> Either<L, R> left(L value) {
     return new Left<>(value);
@@ -108,7 +108,7 @@ default <T> Either<L, T> map(Function1<? super R, ? extends T> map) {
 
   @Override
   default <T> Either<L, T> ap(
-      Kind<Kind<Either_, L>, ? extends Function1<? super R, ? extends T>> apply) {
+      Kind<Kind<Either<?, ?>, L>, ? extends Function1<? super R, ? extends T>> apply) {
     return apply.fix(toEither()).flatMap(this::map);
   }
 
@@ -118,7 +118,7 @@ default <T> Either<T, R> mapLeft(Function1<? super L, ? extends T> map) {
 
   @Override
   @SuppressWarnings("unchecked")
-  default <T> Either<L, T> flatMap(Function1<? super R, ? extends Kind<Kind<Either_, L>, ? extends T>> map) {
+  default <T> Either<L, T> flatMap(Function1<? super R, ? extends Kind<Kind<Either<?, ?>, L>, ? extends T>> map) {
     if (this instanceof Right<L, R>(var right)) {
       return map.andThen(EitherOf::<L, T>narrowK).apply(right);
     }
@@ -144,7 +144,7 @@ default Option<Either<L, R>> filterNot(Matcher1<? super R> matcher) {
     return filter(matcher.negate());
   }
 
-  default Either<L, R> filterOrElse(Matcher1<? super R> matcher, Producer<? extends Kind<Kind<Either_, L>, R>> orElse) {
+  default Either<L, R> filterOrElse(Matcher1<? super R> matcher, Producer<? extends Kind<Kind<Either<?, ?>, L>, R>> orElse) {
     if (this instanceof Left) {
       return this;
     }
@@ -154,14 +154,14 @@ default Either<L, R> filterOrElse(Matcher1<? super R> matcher, Producer<? extend
     return orElse.andThen(EitherOf::narrowK).get();
   }
 
-  default Either<L, R> or(Producer<Kind<Kind<Either_, L>, R>> orElse) {
+  default Either<L, R> or(Producer<Kind<Kind<Either<?, ?>, L>, R>> orElse) {
     if (this instanceof Left) {
       return orElse.andThen(EitherOf::narrowK).get();
     }
     return this;
   }
 
-  default Either<L, R> orElse(Kind<Kind<Either_, L>, R> orElse) {
+  default Either<L, R> orElse(Kind<Kind<Either<?, ?>, L>, R> orElse) {
     return or(Producer.cons(orElse));
   }
 
diff --git a/core/src/main/java/com/github/tonivade/purefun/type/Eval.java b/core/src/main/java/com/github/tonivade/purefun/type/Eval.java
index 23b133d8d..7cf99451e 100644
--- a/core/src/main/java/com/github/tonivade/purefun/type/Eval.java
+++ b/core/src/main/java/com/github/tonivade/purefun/type/Eval.java
@@ -30,7 +30,7 @@
  * @param <A> result of the computation
  */
 @HigherKind
-public sealed interface Eval<A> extends EvalOf<A>, Bindable<Eval_, A> {
+public sealed interface Eval<A> extends EvalOf<A>, Bindable<Eval<?>, A> {
 
   Eval<Boolean> TRUE = now(true);
   Eval<Boolean> FALSE = now(false);
@@ -46,7 +46,7 @@ default <R> Eval<R> map(Function1<? super A, ? extends R> map) {
   }
 
   @Override
-  <R> Eval<R> flatMap(Function1<? super A, ? extends Kind<Eval_, ? extends R>> map);
+  <R> Eval<R> flatMap(Function1<? super A, ? extends Kind<Eval<?>, ? extends R>> map);
 
   static <T> Eval<T> now(T value) {
     return new Done<>(cons(value));
@@ -60,7 +60,7 @@ static <T> Eval<T> always(Producer<? extends T> always) {
     return new Done<>(always);
   }
 
-  static <T> Eval<T> defer(Producer<? extends Kind<Eval_, ? extends T>> eval) {
+  static <T> Eval<T> defer(Producer<? extends Kind<Eval<?>, ? extends T>> eval) {
     return new Defer<>(eval);
   }
 
@@ -82,7 +82,7 @@ public A value() {
     }
 
     @Override
-    public <R> Eval<R> flatMap(Function1<? super A, ? extends Kind<Eval_, ? extends R>> map) {
+    public <R> Eval<R> flatMap(Function1<? super A, ? extends Kind<Eval<?>, ? extends R>> map) {
       return new FlatMapped<>(cons(this), map::apply);
     }
 
@@ -94,9 +94,9 @@ public String toString() {
 
   final class Defer<A> implements Eval<A> {
 
-    private final Producer<? extends Kind<Eval_, ? extends A>> deferred;
+    private final Producer<? extends Kind<Eval<?>, ? extends A>> deferred;
 
-    private Defer(Producer<? extends Kind<Eval_, ? extends A>> deferred) {
+    private Defer(Producer<? extends Kind<Eval<?>, ? extends A>> deferred) {
       this.deferred = checkNonNull(deferred);
     }
 
@@ -106,7 +106,7 @@ public A value() {
     }
 
     @Override
-    public <R> Eval<R> flatMap(Function1<? super A, ? extends Kind<Eval_, ? extends R>> map) {
+    public <R> Eval<R> flatMap(Function1<? super A, ? extends Kind<Eval<?>, ? extends R>> map) {
       return new FlatMapped<>(deferred::get, map::apply);
     }
 
@@ -123,10 +123,10 @@ public String toString() {
 
   final class FlatMapped<A, B> implements Eval<B> {
 
-    private final Producer<? extends Kind<Eval_, ? extends A>> start;
-    private final Function1<? super A, ? extends Kind<Eval_, ? extends B>> run;
+    private final Producer<? extends Kind<Eval<?>, ? extends A>> start;
+    private final Function1<? super A, ? extends Kind<Eval<?>, ? extends B>> run;
 
-    private FlatMapped(Producer<? extends Kind<Eval_, ? extends A>> start, Function1<? super A, ? extends Kind<Eval_, ? extends B>> run) {
+    private FlatMapped(Producer<? extends Kind<Eval<?>, ? extends A>> start, Function1<? super A, ? extends Kind<Eval<?>, ? extends B>> run) {
       this.start = checkNonNull(start);
       this.run = checkNonNull(run);
     }
@@ -137,7 +137,7 @@ public B value() {
     }
 
     @Override
-    public <R> Eval<R> flatMap(Function1<? super B, ? extends Kind<Eval_, ? extends R>> map) {
+    public <R> Eval<R> flatMap(Function1<? super B, ? extends Kind<Eval<?>, ? extends R>> map) {
       return new FlatMapped<>(this::start, b -> new FlatMapped<>(() -> run(b), map::apply));
     }
 
diff --git a/core/src/main/java/com/github/tonivade/purefun/type/Id.java b/core/src/main/java/com/github/tonivade/purefun/type/Id.java
index 4fe0dbc0b..c4d5365d2 100644
--- a/core/src/main/java/com/github/tonivade/purefun/type/Id.java
+++ b/core/src/main/java/com/github/tonivade/purefun/type/Id.java
@@ -22,7 +22,7 @@
  * @param <T> the wrapped value
  */
 @HigherKind
-public record Id<T>(T value) implements IdOf<T>, Bindable<Id_, T>, Applicable<Id_, T>, Serializable {
+public record Id<T>(T value) implements IdOf<T>, Bindable<Id<?>, T>, Applicable<Id<?>, T>, Serializable {
 
   public Id {
     checkNonNull(value);
@@ -34,12 +34,12 @@ public <R> Id<R> map(Function1<? super T, ? extends R> map) {
   }
 
   @Override
-  public <R> Id<R> ap(Kind<Id_, ? extends Function1<? super T, ? extends R>> apply) {
+  public <R> Id<R> ap(Kind<Id<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return apply.fix(toId()).flatMap(this::map);
   }
 
   @Override
-  public <R> Id<R> flatMap(Function1<? super T, ? extends Kind<Id_, ? extends R>> map) {
+  public <R> Id<R> flatMap(Function1<? super T, ? extends Kind<Id<?>, ? extends R>> map) {
     return map.andThen(IdOf::<R>narrowK).apply(value);
   }
 
diff --git a/core/src/main/java/com/github/tonivade/purefun/type/Option.java b/core/src/main/java/com/github/tonivade/purefun/type/Option.java
index b20836a7a..8b7780e1d 100644
--- a/core/src/main/java/com/github/tonivade/purefun/type/Option.java
+++ b/core/src/main/java/com/github/tonivade/purefun/type/Option.java
@@ -39,7 +39,7 @@
  * @param <T> the wrapped value
  */
 @HigherKind
-public sealed interface Option<T> extends OptionOf<T>, Bindable<Option_, T>, Applicable<Option_, T> {
+public sealed interface Option<T> extends OptionOf<T>, Bindable<Option<?>, T>, Applicable<Option<?>, T> {
 
   static <T> Option<T> some(T value) {
     return new Some<>(value);
@@ -78,12 +78,12 @@ default <R> Option<R> map(Function1<? super T, ? extends R> mapper) {
   }
 
   @Override
-  default <R> Option<R> ap(Kind<Option_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <R> Option<R> ap(Kind<Option<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return apply.fix(toOption()).flatMap(this::map);
   }
 
   @Override
-  default <R> Option<R> flatMap(Function1<? super T, ? extends Kind<Option_, ? extends R>> map) {
+  default <R> Option<R> flatMap(Function1<? super T, ? extends Kind<Option<?>, ? extends R>> map) {
     return switch (this) {
       case Some<T>(var value) -> map.andThen(OptionOf::<R>narrowK).apply(value);
       case None<T> n -> none();
@@ -115,14 +115,14 @@ default Option<T> filterNot(Matcher1<? super T> matcher) {
     return filter(matcher.negate());
   }
 
-  default Option<T> or(Producer<Kind<Option_, T>> orElse) {
+  default Option<T> or(Producer<Kind<Option<?>, T>> orElse) {
     if (this instanceof None) {
       return orElse.andThen(OptionOf::narrowK).get();
     }
     return this;
   }
 
-  default Option<T> orElse(Kind<Option_, T> orElse) {
+  default Option<T> orElse(Kind<Option<?>, T> orElse) {
     return or(cons(orElse));
   }
 
diff --git a/core/src/main/java/com/github/tonivade/purefun/type/Try.java b/core/src/main/java/com/github/tonivade/purefun/type/Try.java
index 07d86f987..42d8481fe 100644
--- a/core/src/main/java/com/github/tonivade/purefun/type/Try.java
+++ b/core/src/main/java/com/github/tonivade/purefun/type/Try.java
@@ -41,7 +41,7 @@
  * @param <T> the wrapped value
  */
 @HigherKind
-public sealed interface Try<T> extends TryOf<T>, Bindable<Try_, T>, Applicable<Try_, T> {
+public sealed interface Try<T> extends TryOf<T>, Bindable<Try<?>, T>, Applicable<Try<?>, T> {
 
   static <T> Try<T> success(T value) {
     return new Success<>(value);
@@ -122,7 +122,7 @@ default <R> Try<R> map(Function1<? super T, ? extends R> mapper) {
   }
 
   @Override
-  default <R> Try<R> ap(Kind<Try_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <R> Try<R> ap(Kind<Try<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return apply.fix(toTry()).flatMap(this::map);
   }
 
@@ -135,7 +135,7 @@ default Try<T> mapError(Function1<? super Throwable, ? extends Throwable> mapper
 
   @Override
   @SuppressWarnings("unchecked")
-  default <R> Try<R> flatMap(Function1<? super T, ? extends Kind<Try_, ? extends R>> mapper) {
+  default <R> Try<R> flatMap(Function1<? super T, ? extends Kind<Try<?>, ? extends R>> mapper) {
     return switch (this) {
       case Success<T>(var value) -> mapper.andThen(TryOf::<R>narrowK).apply(value);
       case Failure<T> f -> (Try<R>) this;
@@ -179,7 +179,7 @@ default Try<T> filterNot(Matcher1<? super T> matcher) {
     return filter(matcher.negate());
   }
 
-  default Try<T> filterOrElse(Matcher1<? super T> matcher, Producer<? extends Kind<Try_, ? extends T>> producer) {
+  default Try<T> filterOrElse(Matcher1<? super T> matcher, Producer<? extends Kind<Try<?>, ? extends T>> producer) {
     if (this instanceof Failure) {
       return this;
     }
@@ -196,14 +196,14 @@ default <U> U fold(Function1<? super Throwable, ? extends U> failureMapper, Func
     };
   }
 
-  default Try<T> or(Producer<Kind<Try_, T>> orElse) {
+  default Try<T> or(Producer<Kind<Try<?>, T>> orElse) {
     if (this instanceof Failure) {
       return orElse.andThen(TryOf::narrowK).get();
     }
     return this;
   }
 
-  default Try<T> orElse(Kind<Try_, T> orElse) {
+  default Try<T> orElse(Kind<Try<?>, T> orElse) {
     return or(Producer.cons(orElse));
   }
 
diff --git a/core/src/main/java/com/github/tonivade/purefun/type/Validation.java b/core/src/main/java/com/github/tonivade/purefun/type/Validation.java
index 9245b9d5e..ef65b9999 100644
--- a/core/src/main/java/com/github/tonivade/purefun/type/Validation.java
+++ b/core/src/main/java/com/github/tonivade/purefun/type/Validation.java
@@ -49,7 +49,7 @@
  * @param <T> type of the value when valid
  */
 @HigherKind
-public sealed interface Validation<E, T> extends ValidationOf<E, T>, Bindable<Kind<Validation_, E>, T> {
+public sealed interface Validation<E, T> extends ValidationOf<E, T>, Bindable<Kind<Validation<?, ?>, E>, T> {
 
   static <E, T> Validation<E, T> valid(T value) {
     return new Valid<>(value);
@@ -105,7 +105,7 @@ default <U, R>  Validation<U, R> bimap(Function1<? super E, ? extends U> error,
 
   @Override
   @SuppressWarnings("unchecked")
-  default <R> Validation<E, R> flatMap(Function1<? super T, ? extends Kind<Kind<Validation_, E>, ? extends R>> mapper) {
+  default <R> Validation<E, R> flatMap(Function1<? super T, ? extends Kind<Kind<Validation<?, ?>, E>, ? extends R>> mapper) {
     if (this instanceof Valid<E, T>(var value)) {
       return mapper.andThen(ValidationOf::<E, R>narrowK).apply(value);
     }
@@ -126,7 +126,7 @@ default Option<Validation<E, T>> filterNot(Matcher1<? super T> matcher) {
     return filter(matcher.negate());
   }
 
-  default Validation<E, T> filterOrElse(Matcher1<? super T> matcher, Producer<? extends Kind<Kind<Validation_, E>, T>> orElse) {
+  default Validation<E, T> filterOrElse(Matcher1<? super T> matcher, Producer<? extends Kind<Kind<Validation<?, ?>, E>, T>> orElse) {
     if (this instanceof Invalid) {
       return this;
     }
@@ -136,14 +136,14 @@ default Validation<E, T> filterOrElse(Matcher1<? super T> matcher, Producer<? ex
     return orElse.andThen(ValidationOf::narrowK).get();
   }
 
-  default Validation<E, T> or(Producer<Kind<Kind<Validation_, E>, T>> orElse) {
+  default Validation<E, T> or(Producer<Kind<Kind<Validation<?, ?>, E>, T>> orElse) {
     if (this instanceof Invalid) {
       return orElse.andThen(ValidationOf::narrowK).get();
     }
     return this;
   }
 
-  default Validation<E, T> orElse(Kind<Kind<Validation_, E>, T> orElse) {
+  default Validation<E, T> orElse(Kind<Kind<Validation<?, ?>, E>, T> orElse) {
     return or(Producer.cons(orElse));
   }
 
diff --git a/effect/src/main/java/com/github/tonivade/purefun/effect/EIO.java b/effect/src/main/java/com/github/tonivade/purefun/effect/EIO.java
index 36e4759e5..ca33ce9c9 100644
--- a/effect/src/main/java/com/github/tonivade/purefun/effect/EIO.java
+++ b/effect/src/main/java/com/github/tonivade/purefun/effect/EIO.java
@@ -34,7 +34,7 @@
 import com.github.tonivade.purefun.typeclasses.FunctionK;
 
 @HigherKind
-public final class EIO<E, A> implements EIOOf<E, A>, Effect<Kind<EIO_, E>, A> {
+public final class EIO<E, A> implements EIOOf<E, A>, Effect<Kind<EIO<?, ?>, E>, A> {
 
   private static final EIO<?, Unit> UNIT = new EIO<>(PureIO.unit());
 
@@ -75,7 +75,7 @@ public <B> EIO<E, B> map(Function1<? super A, ? extends B> map) {
   }
 
   @Override
-  public <B> EIO<E, B> flatMap(Function1<? super A, ? extends Kind<Kind<EIO_, E>, ? extends B>> map) {
+  public <B> EIO<E, B> flatMap(Function1<? super A, ? extends Kind<Kind<EIO<?, ?>, E>, ? extends B>> map) {
     return new EIO<>(instance.flatMap(value -> {
       EIO<E, ? extends B> apply = map.andThen(EIOOf::narrowK).apply(value);
       return apply.instance;
@@ -83,12 +83,12 @@ public <B> EIO<E, B> flatMap(Function1<? super A, ? extends Kind<Kind<EIO_, E>,
   }
 
   @Override
-  public <B> EIO<E, B> andThen(Kind<Kind<EIO_, E>, ? extends B> next) {
+  public <B> EIO<E, B> andThen(Kind<Kind<EIO<?, ?>, E>, ? extends B> next) {
     return new EIO<>(instance.andThen(next.fix(EIOOf.toEIO()).instance));
   }
 
   @Override
-  public <B> EIO<E, B> ap(Kind<Kind<EIO_, E>, ? extends Function1<? super A, ? extends B>> apply) {
+  public <B> EIO<E, B> ap(Kind<Kind<EIO<?, ?>, E>, ? extends Function1<? super A, ? extends B>> apply) {
     return new EIO<>(instance.ap(apply.fix(EIOOf.toEIO()).toPureIO()));
   }
 
@@ -100,7 +100,7 @@ public <B> EIO<B, A> mapError(Function1<? super E, ? extends B> map) {
     return new EIO<>(instance.mapError(map));
   }
 
-  public <F> EIO<F, A> flatMapError(Function1<? super E, ? extends Kind<Kind<EIO_, F>, ? extends A>> map) {
+  public <F> EIO<F, A> flatMapError(Function1<? super E, ? extends Kind<Kind<EIO<?, ?>, F>, ? extends A>> map) {
     return new EIO<>(instance.flatMapError(error -> {
       EIO<F, ? extends A> apply = map.andThen(EIOOf::narrowK).apply(error);
       return apply.instance;
@@ -112,8 +112,8 @@ public <B, F> EIO<F, B> bimap(Function1<? super E, ? extends F> mapError, Functi
   }
 
   public <B, F> EIO<F, B> foldM(
-      Function1<? super E, ? extends Kind<Kind<EIO_, F>, ? extends B>> mapError,
-      Function1<? super A, ? extends Kind<Kind<EIO_, F>, ? extends B>> map) {
+      Function1<? super E, ? extends Kind<Kind<EIO<?, ?>, F>, ? extends B>> mapError,
+      Function1<? super A, ? extends Kind<Kind<EIO<?, ?>, F>, ? extends B>> map) {
     return new EIO<>(instance.foldM(
         error -> mapError.andThen(EIOOf::narrowK).apply(error).instance,
         value -> map.andThen(EIOOf::narrowK).apply(value).instance));
@@ -132,30 +132,30 @@ public EIO<E, A> orElse(EIO<E, ? extends A> other) {
   }
 
   @Override
-  public <B> EIO<E, Tuple2<A, B>> zip(Kind<Kind<EIO_, E>, ? extends B> other) {
+  public <B> EIO<E, Tuple2<A, B>> zip(Kind<Kind<EIO<?, ?>, E>, ? extends B> other) {
     return zipWith(other, Tuple::of);
   }
 
   @Override
-  public <B> EIO<E, A> zipLeft(Kind<Kind<EIO_, E>, ? extends B> other) {
+  public <B> EIO<E, A> zipLeft(Kind<Kind<EIO<?, ?>, E>, ? extends B> other) {
     return zipWith(other, first());
   }
 
   @Override
-  public <B> EIO<E, B> zipRight(Kind<Kind<EIO_, E>, ? extends B> other) {
+  public <B> EIO<E, B> zipRight(Kind<Kind<EIO<?, ?>, E>, ? extends B> other) {
     return zipWith(other, second());
   }
 
   @Override
-  public <B, C> EIO<E, C> zipWith(Kind<Kind<EIO_, E>, ? extends B> other,
+  public <B, C> EIO<E, C> zipWith(Kind<Kind<EIO<?, ?>, E>, ? extends B> other,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(this, other.fix(EIOOf.toEIO()), mapper);
   }
 
-  public EIO<E, Fiber<Kind<EIO_, E>, A>> fork() {
+  public EIO<E, Fiber<Kind<EIO<?, ?>, E>, A>> fork() {
     return new EIO<>(instance.fork().map(f -> f.mapK(new FunctionK<>() {
       @Override
-      public <T> EIO<E, T> apply(Kind<Kind<Kind<PureIO_, Void>, E>, ? extends T> from) {
+      public <T> EIO<E, T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, E>, ? extends T> from) {
         return new EIO<>(from.fix(PureIOOf::narrowK));
       }
     })));
@@ -225,39 +225,39 @@ public <X extends Throwable> EIO<X, A> refineOrDie(Class<X> type) {
     return new EIO<>(instance.refineOrDie(type));
   }
 
-  public static <E, A, B, C> EIO<E, C> parMap2(Kind<Kind<EIO_, E>, ? extends A> za, Kind<Kind<EIO_, E>, ? extends B> zb,
+  public static <E, A, B, C> EIO<E, C> parMap2(Kind<Kind<EIO<?, ?>, E>, ? extends A> za, Kind<Kind<EIO<?, ?>, E>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(Future.DEFAULT_EXECUTOR, za, zb, mapper);
   }
 
-  public static <E, A, B, C> EIO<E, C> parMap2(Executor executor, Kind<Kind<EIO_, E>, ? extends A> za, Kind<Kind<EIO_, E>, ? extends B> zb,
+  public static <E, A, B, C> EIO<E, C> parMap2(Executor executor, Kind<Kind<EIO<?, ?>, E>, ? extends A> za, Kind<Kind<EIO<?, ?>, E>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return new EIO<>(PureIO.parMap2(executor, za.fix(EIOOf::narrowK).instance, zb.fix(EIOOf::narrowK).instance, mapper));
   }
 
-  public static <E, A, B> EIO<E, Either<A, B>> race(Kind<Kind<EIO_, E>, ? extends A> fa, Kind<Kind<EIO_, E>, ? extends B> fb) {
+  public static <E, A, B> EIO<E, Either<A, B>> race(Kind<Kind<EIO<?, ?>, E>, ? extends A> fa, Kind<Kind<EIO<?, ?>, E>, ? extends B> fb) {
     return race(Future.DEFAULT_EXECUTOR, fa, fb);
   }
 
-  public static <E, A, B> EIO<E, Either<A, B>> race(Executor executor, Kind<Kind<EIO_, E>, ? extends A> fa, Kind<Kind<EIO_, E>, ? extends B> fb) {
+  public static <E, A, B> EIO<E, Either<A, B>> race(Executor executor, Kind<Kind<EIO<?, ?>, E>, ? extends A> fa, Kind<Kind<EIO<?, ?>, E>, ? extends B> fb) {
     return racePair(executor, fa, fb).flatMap(either -> either.fold(
         ta -> ta.get2().cancel().fix(EIOOf.toEIO()).map(x -> Either.left(ta.get1())),
         tb -> tb.get1().cancel().fix(EIOOf.toEIO()).map(x -> Either.right(tb.get2()))));
   }
 
-  public static <E, A, B> EIO<E, Either<Tuple2<A, Fiber<Kind<EIO_, E>, B>>, Tuple2<Fiber<Kind<EIO_, E>, A>, B>>>
-      racePair(Executor executor, Kind<Kind<EIO_, E>, ? extends A> fa, Kind<Kind<EIO_, E>, ? extends B> fb) {
+  public static <E, A, B> EIO<E, Either<Tuple2<A, Fiber<Kind<EIO<?, ?>, E>, B>>, Tuple2<Fiber<Kind<EIO<?, ?>, E>, A>, B>>>
+      racePair(Executor executor, Kind<Kind<EIO<?, ?>, E>, ? extends A> fa, Kind<Kind<EIO<?, ?>, E>, ? extends B> fb) {
     PureIO<Void, E, A> instance1 = fa.fix(EIOOf.toEIO()).instance.fix(PureIOOf::narrowK);
     PureIO<Void, E, B> instance2 = fb.fix(EIOOf.toEIO()).instance.fix(PureIOOf::narrowK);
     return new EIO<>(PureIO.racePair(executor, instance1, instance2).map(
       either -> either.bimap(a -> a.map2(f -> f.mapK(new FunctionK<>() {
         @Override
-        public <T> EIO<E, T> apply(Kind<Kind<Kind<PureIO_, Void>, E>, ? extends T> from) {
+        public <T> EIO<E, T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, E>, ? extends T> from) {
           return new EIO<>(from.fix(PureIOOf::narrowK));
         }
       })), b -> b.map1(f -> f.mapK(new FunctionK<>() {
         @Override
-        public <T> EIO<E, T> apply(Kind<Kind<Kind<PureIO_, Void>, E>, ? extends T> from) {
+        public <T> EIO<E, T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, E>, ? extends T> from) {
           return new EIO<>(from.fix(PureIOOf::narrowK));
         }
       })))));
@@ -323,7 +323,7 @@ public static <E, A> EIO<E, A> pure(A value) {
     return new EIO<>(PureIO.pure(value));
   }
 
-  public static <E, A> EIO<E, A> defer(Producer<Kind<Kind<EIO_, E>, ? extends A>> lazy) {
+  public static <E, A> EIO<E, A> defer(Producer<Kind<Kind<EIO<?, ?>, E>, ? extends A>> lazy) {
     return new EIO<>(PureIO.defer(() -> lazy.andThen(EIOOf::narrowK).get().instance));
   }
 
@@ -351,29 +351,29 @@ public static <E, A> EIO<E, A> throwError(Throwable error) {
     return new EIO<>(PureIO.throwError(error));
   }
 
-  public static <E, A> EIO<E, Sequence<A>> traverse(Sequence<? extends Kind<Kind<EIO_, E>, ? extends A>> sequence) {
+  public static <E, A> EIO<E, Sequence<A>> traverse(Sequence<? extends Kind<Kind<EIO<?, ?>, E>, ? extends A>> sequence) {
     return traverse(Future.DEFAULT_EXECUTOR, sequence);
   }
 
-  public static <E, A> EIO<E, Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<Kind<EIO_, E>, ? extends A>> sequence) {
+  public static <E, A> EIO<E, Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<Kind<EIO<?, ?>, E>, ? extends A>> sequence) {
     return sequence.foldLeft(pure(ImmutableList.empty()),
-        (Kind<Kind<EIO_, E>, ? extends Sequence<A>> xs, Kind<Kind<EIO_, E>, ? extends A> a) -> parMap2(executor, xs, a, Sequence::append));
+        (Kind<Kind<EIO<?, ?>, E>, ? extends Sequence<A>> xs, Kind<Kind<EIO<?, ?>, E>, ? extends A> a) -> parMap2(executor, xs, a, Sequence::append));
   }
 
-  public static <E, A extends AutoCloseable, B> EIO<E, B> bracket(Kind<Kind<EIO_, E>, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<Kind<EIO_, E>, ? extends B>> use) {
+  public static <E, A extends AutoCloseable, B> EIO<E, B> bracket(Kind<Kind<EIO<?, ?>, E>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<Kind<EIO<?, ?>, E>, ? extends B>> use) {
     return new EIO<>(PureIO.bracket(acquire.fix(EIOOf::narrowK).instance,
         resource -> use.andThen(EIOOf::<E, B>narrowK).apply(resource).instance));
   }
 
-  public static <E, A, B> EIO<E, B> bracket(Kind<Kind<EIO_, E>, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<Kind<EIO_, E>, ? extends B>> use, Consumer1<? super A> release) {
+  public static <E, A, B> EIO<E, B> bracket(Kind<Kind<EIO<?, ?>, E>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<Kind<EIO<?, ?>, E>, ? extends B>> use, Consumer1<? super A> release) {
     return new EIO<>(PureIO.bracket(acquire.fix(EIOOf::narrowK).instance,
         resource -> use.andThen(EIOOf::<E, B>narrowK).apply(resource).instance, release));
   }
 
-  public static <E, A, B> EIO<E, B> bracket(Kind<Kind<EIO_, E>, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<Kind<EIO_, E>, ? extends B>> use, Function1<? super A, ? extends Kind<Kind<EIO_, E>, Unit>> release) {
+  public static <E, A, B> EIO<E, B> bracket(Kind<Kind<EIO<?, ?>, E>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<Kind<EIO<?, ?>, E>, ? extends B>> use, Function1<? super A, ? extends Kind<Kind<EIO<?, ?>, E>, Unit>> release) {
     return new EIO<>(PureIO.bracket(acquire.fix(EIOOf::narrowK).instance,
         resource -> use.andThen(EIOOf::<E, B>narrowK).apply(resource).instance, release.andThen(EIOOf::narrowK).andThen(EIO::toPureIO)));
   }
diff --git a/effect/src/main/java/com/github/tonivade/purefun/effect/Managed.java b/effect/src/main/java/com/github/tonivade/purefun/effect/Managed.java
index 9d09c4800..b21d07135 100644
--- a/effect/src/main/java/com/github/tonivade/purefun/effect/Managed.java
+++ b/effect/src/main/java/com/github/tonivade/purefun/effect/Managed.java
@@ -35,7 +35,7 @@ public <F> Managed<R, F, A> mapError(Function1<? super E, ? extends F> mapper) {
     return new Managed<>(resource.mapError(mapper));
   }
 
-  public <B> Managed<R, E, B> flatMap(Function1<? super A, ? extends Kind<Kind<Kind<Managed_, R>, E>, ? extends B>> mapper) {
+  public <B> Managed<R, E, B> flatMap(Function1<? super A, ? extends Kind<Kind<Kind<Managed<?, ?, ?>, R>, E>, ? extends B>> mapper) {
     PureIO<R, E, Tuple2<B, Consumer1<? super B>>> result = resource.flatMap(t -> {
       Managed<R, E, B> apply = ManagedOf.narrowK(mapper.apply(t.get1()));
       return apply.resource.map(r -> r.map2(ignore -> releaseAndThen(t, r)));
@@ -43,11 +43,11 @@ public <B> Managed<R, E, B> flatMap(Function1<? super A, ? extends Kind<Kind<Kin
     return new Managed<>(result);
   }
 
-  public <F> Managed<R, F, A> flatMapError(Function1<? super E, ? extends Kind<Kind<Kind<Managed_, R>, F>, ? extends A>> mapper) {
+  public <F> Managed<R, F, A> flatMapError(Function1<? super E, ? extends Kind<Kind<Kind<Managed<?, ?, ?>, R>, F>, ? extends A>> mapper) {
     return new Managed<>(resource.flatMapError(e -> ManagedOf.<R, F, A>narrowK(mapper.apply(e)).resource));
   }
 
-  public <B> Managed<R, E, B> andThen(Kind<Kind<Kind<Managed_, A>, E>, B> other) {
+  public <B> Managed<R, E, B> andThen(Kind<Kind<Kind<Managed<?, ?, ?>, A>, E>, B> other) {
     PureIO<R, E, Tuple2<B, Consumer1<? super B>>> flatMap = resource.flatMap(a -> {
       Either<E, Tuple2<B, Consumer1<? super B>>> next = ManagedOf.narrowK(other).resource.provide(a.get1());
       return PureIO.fromEither(() -> next.map(t -> t.map2(ignore -> releaseAndThen(a, t))));
@@ -75,8 +75,8 @@ public Managed<R, E, A> orElse(Managed<R, E, ? extends A> other) {
   }
 
   public <F, B> Managed<R, F, B> foldM(
-      Function1<? super E, ? extends Kind<Kind<Kind<Managed_, R>, F>, ? extends B>> mapError,
-      Function1<? super A, ? extends Kind<Kind<Kind<Managed_, R>, F>, ? extends B>> mapper) {
+      Function1<? super E, ? extends Kind<Kind<Kind<Managed<?, ?, ?>, R>, F>, ? extends B>> mapError,
+      Function1<? super A, ? extends Kind<Kind<Kind<Managed<?, ?, ?>, R>, F>, ? extends B>> mapper) {
     PureIO<R, F, Tuple2<B, Consumer1<? super B>>> foldM =
         resource.foldM(
             error -> ManagedOf.<R, F, B>narrowK(mapError.apply(error)).resource,
diff --git a/effect/src/main/java/com/github/tonivade/purefun/effect/PureIO.java b/effect/src/main/java/com/github/tonivade/purefun/effect/PureIO.java
index 084d6d474..ca66f2276 100644
--- a/effect/src/main/java/com/github/tonivade/purefun/effect/PureIO.java
+++ b/effect/src/main/java/com/github/tonivade/purefun/effect/PureIO.java
@@ -45,7 +45,7 @@
 import com.github.tonivade.purefun.typeclasses.Fiber;
 
 @HigherKind
-public sealed interface PureIO<R, E, A> extends PureIOOf<R, E, A>, Effect<Kind<Kind<PureIO_, R>, E>, A> {
+public sealed interface PureIO<R, E, A> extends PureIOOf<R, E, A>, Effect<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A> {
 
   default Either<E, A> provide(@Nullable R env) {
     return runAsync(env).getOrElseThrow();
@@ -85,27 +85,27 @@ default <B, F> PureIO<R, F, B> bimap(Function1<? super E, ? extends F> mapError,
   }
 
   @Override
-  default <B> PureIO<R, E, B> flatMap(Function1<? super A, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends B>> map) {
+  default <B> PureIO<R, E, B> flatMap(Function1<? super A, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B>> map) {
     return foldM(PureIO::raiseError, map);
   }
 
-  default <F> PureIO<R, F, A> flatMapError(Function1<? super E, ? extends Kind<Kind<Kind<PureIO_, R>, F>, ? extends A>> map) {
+  default <F> PureIO<R, F, A> flatMapError(Function1<? super E, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, F>, ? extends A>> map) {
     return foldM(map, PureIO::pure);
   }
 
   default <F, B> PureIO<R, F, B> foldM(
-      Function1<? super E, ? extends Kind<Kind<Kind<PureIO_, R>, F>, ? extends B>> left,
-      Function1<? super A, ? extends Kind<Kind<Kind<PureIO_, R>, F>, ? extends B>> right) {
+      Function1<? super E, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, F>, ? extends B>> left,
+      Function1<? super A, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, F>, ? extends B>> right) {
     return new FlatMapped<>(this, left, right);
   }
 
   @Override
-  default <B> PureIO<R, E, B> andThen(Kind<Kind<Kind<PureIO_, R>, E>, ? extends B> next) {
+  default <B> PureIO<R, E, B> andThen(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B> next) {
     return flatMap(ignore -> next);
   }
 
   @Override
-  default <B> PureIO<R, E, B> ap(Kind<Kind<Kind<PureIO_, R>, E>, ? extends Function1<? super A, ? extends B>> apply) {
+  default <B> PureIO<R, E, B> ap(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends Function1<? super A, ? extends B>> apply) {
     return parMap2(this, apply.fix(PureIOOf.toPureIO()), (v, a) -> a.apply(v));
   }
 
@@ -118,27 +118,27 @@ default URIO<R, A> recover(Function1<? super E, ? extends A> mapError) {
     return fold(mapError, identity());
   }
 
-  default PureIO<R, E, A> orElse(Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> other) {
+  default PureIO<R, E, A> orElse(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> other) {
     return foldM(Function1.cons(other), Function1.cons(this));
   }
 
   @Override
-  default <B> PureIO<R, E, Tuple2<A, B>> zip(Kind<Kind<Kind<PureIO_, R>, E>, ? extends B> other) {
+  default <B> PureIO<R, E, Tuple2<A, B>> zip(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B> other) {
     return zipWith(other, Tuple::of);
   }
 
   @Override
-  default <B> PureIO<R, E, A> zipLeft(Kind<Kind<Kind<PureIO_, R>, E>, ? extends B> other) {
+  default <B> PureIO<R, E, A> zipLeft(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B> other) {
     return zipWith(other, first());
   }
 
   @Override
-  default <B> PureIO<R, E, B> zipRight(Kind<Kind<Kind<PureIO_, R>, E>, ? extends B> other) {
+  default <B> PureIO<R, E, B> zipRight(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B> other) {
     return zipWith(other, second());
   }
 
   @Override
-  default <B, C> PureIO<R, E, C> zipWith(Kind<Kind<Kind<PureIO_, R>, E>, ? extends B> other,
+  default <B, C> PureIO<R, E, C> zipWith(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B> other,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(this, other.fix(PureIOOf.toPureIO()), mapper);
   }
@@ -189,7 +189,7 @@ default PureIO<R, E, Tuple2<Duration, A>> timed() {
       start -> map(result -> Tuple.of(Duration.ofNanos(System.nanoTime() - start), result)));
   }
 
-  default PureIO<R, E, Fiber<Kind<Kind<PureIO_, R>, E>, A>> fork() {
+  default PureIO<R, E, Fiber<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A>> fork() {
     return async((env, callback) -> {
       PureIOConnection connection = PureIOConnection.cancellable();
       Promise<Either<E, A>> promise = runAsync(env, this, connection);
@@ -243,7 +243,7 @@ default Managed<R, E, A> toManaged(Consumer1<? super A> release) {
     return Managed.from(this, release);
   }
 
-  static <R, E, A> PureIO<R, E, A> accessM(Function1<? super R, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>> map) {
+  static <R, E, A> PureIO<R, E, A> accessM(Function1<? super R, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>> map) {
     return new AccessM<>(value -> map.apply(value).fix(PureIOOf::narrowK));
   }
 
@@ -259,12 +259,12 @@ static <R, E> PureIO<R, E, Unit> forked(Executor executor) {
     return async((env, callback) -> executor.execute(() -> callback.accept(Try.success(Either.right(Unit.unit())))));
   }
 
-  static <R, E, A, B, C> PureIO<R, E, C> parMap2(Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> za, Kind<Kind<Kind<PureIO_, R>, E>, ? extends B> zb,
+  static <R, E, A, B, C> PureIO<R, E, C> parMap2(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> za, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(Future.DEFAULT_EXECUTOR, za, zb, mapper);
   }
 
-  static <R, E, A, B, C> PureIO<R, E, C> parMap2(Executor executor, Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> za, Kind<Kind<Kind<PureIO_, R>, E>, ? extends B> zb,
+  static <R, E, A, B, C> PureIO<R, E, C> parMap2(Executor executor, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> za, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return cancellable((env, callback) -> {
 
@@ -287,18 +287,18 @@ static <R, E, A, B, C> PureIO<R, E, C> parMap2(Executor executor, Kind<Kind<Kind
     });
   }
 
-  static <R, E, A, B> PureIO<R, E, Either<A, B>> race(Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> fa, Kind<Kind<Kind<PureIO_, R>, E>, ? extends B> fb) {
+  static <R, E, A, B> PureIO<R, E, Either<A, B>> race(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> fa, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B> fb) {
     return race(Future.DEFAULT_EXECUTOR, fa, fb);
   }
 
-  static <R, E, A, B> PureIO<R, E, Either<A, B>> race(Executor executor, Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> fa, Kind<Kind<Kind<PureIO_, R>, E>, ? extends B> fb) {
+  static <R, E, A, B> PureIO<R, E, Either<A, B>> race(Executor executor, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> fa, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B> fb) {
     return racePair(executor, fa, fb).flatMap(either -> either.fold(
         ta -> ta.get2().cancel().fix(PureIOOf.toPureIO()).map(x -> Either.left(ta.get1())),
         tb -> tb.get1().cancel().fix(PureIOOf.toPureIO()).map(x -> Either.right(tb.get2()))));
   }
 
-  static <R, E, A, B> PureIO<R, E, Either<Tuple2<A, Fiber<Kind<Kind<PureIO_, R>, E>, B>>, Tuple2<Fiber<Kind<Kind<PureIO_, R>, E>, A>, B>>>
-      racePair(Executor executor, Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> fa, Kind<Kind<Kind<PureIO_, R>, E>, ? extends B> fb) {
+  static <R, E, A, B> PureIO<R, E, Either<Tuple2<A, Fiber<Kind<Kind<PureIO<?, ?, ?>, R>, E>, B>>, Tuple2<Fiber<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A>, B>>>
+      racePair(Executor executor, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> fa, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B> fb) {
     return cancellable((env, callback) -> {
 
       PureIOConnection connection1 = PureIOConnection.cancellable();
@@ -310,7 +310,7 @@ static <R, E, A, B> PureIO<R, E, Either<A, B>> race(Executor executor, Kind<Kind
       promiseA.onComplete(result -> {
         PureIO<R, E, B> fromPromiseB = PureIO.fromPromise(promiseB);
         PureIO<R, E, Unit> cancelB = PureIO.run(connection2::cancel);
-        Fiber<Kind<Kind<PureIO_, R>, E>, B> fiberB = Fiber.of(fromPromiseB, cancelB);
+        Fiber<Kind<Kind<PureIO<?, ?, ?>, R>, E>, B> fiberB = Fiber.of(fromPromiseB, cancelB);
         callback.accept(result.map(
           either -> either.map(
             a -> Either.left(Tuple.of(a, fiberB)))));
@@ -319,7 +319,7 @@ static <R, E, A, B> PureIO<R, E, Either<A, B>> race(Executor executor, Kind<Kind
       promiseB.onComplete(result -> {
         PureIO<R, E, A> fromPromiseA = PureIO.fromPromise(promiseA);
         PureIO<R, E, Unit> cancelA = PureIO.run(connection2::cancel);
-        Fiber<Kind<Kind<PureIO_, R>, E>, A> fiberA = Fiber.of(fromPromiseA, cancelA);
+        Fiber<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A> fiberA = Fiber.of(fromPromiseA, cancelA);
         callback.accept(result.map(
           either -> either.map(
             b -> Either.right(Tuple.of(fiberA, b)))));
@@ -335,7 +335,7 @@ static <R, E, A, B> PureIO<R, E, Either<A, B>> race(Executor executor, Kind<Kind
     });
   }
 
-  static <R, E, A> PureIO<R, E, A> absorb(Kind<Kind<Kind<PureIO_, R>, E>, Either<E, A>> value) {
+  static <R, E, A> PureIO<R, E, A> absorb(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, Either<E, A>> value) {
     return value.fix(PureIOOf::narrowK).flatMap(either -> either.fold(PureIO::raiseError, PureIO::pure));
   }
 
@@ -396,7 +396,7 @@ static <R, E, A> PureIO<R, E, A> pure(A value) {
     return new Pure<>(value);
   }
 
-  static <R, E, A> PureIO<R, E, A> defer(Producer<Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>> lazy) {
+  static <R, E, A> PureIO<R, E, A> defer(Producer<Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>> lazy) {
     return new Suspend<>(() -> lazy.get().fix(PureIOOf::narrowK));
   }
 
@@ -428,7 +428,7 @@ static <R, E, A> PureIO<R, E, A> throwError(Throwable error) {
     return new Throw<>(error);
   }
 
-  static <R, A> PureIO<R, Throwable, A> redeem(Kind<Kind<Kind<PureIO_, R>, Void>, ? extends A> value) {
+  static <R, A> PureIO<R, Throwable, A> redeem(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, Void>, ? extends A> value) {
     return new Recover<>(value.fix(PureIOOf::narrowK), PartialFunction1.of(always(), PureIO::raiseError));
   }
 
@@ -444,29 +444,29 @@ static <R, E> PureIO<R, E, Unit> sleep(Executor executor, Duration delay) {
     });
   }
 
-  static <R, E, A> PureIO<R, E, Sequence<A>> traverse(Sequence<? extends Kind<Kind<Kind<PureIO_, R>, E>, A>> sequence) {
+  static <R, E, A> PureIO<R, E, Sequence<A>> traverse(Sequence<? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A>> sequence) {
     return traverse(Future.DEFAULT_EXECUTOR, sequence);
   }
 
-  static <R, E, A> PureIO<R, E, Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<Kind<Kind<PureIO_, R>, E>, A>> sequence) {
+  static <R, E, A> PureIO<R, E, Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A>> sequence) {
     return sequence.foldLeft(PureIO.<R, E, Sequence<A>>pure(ImmutableList.empty()),
-        (Kind<Kind<Kind<PureIO_, R>, E>, Sequence<A>> xs, Kind<Kind<Kind<PureIO_, R>, E>, A> a) -> parMap2(executor, xs, a, Sequence::append));
+        (Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, Sequence<A>> xs, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A> a) -> parMap2(executor, xs, a, Sequence::append));
   }
 
-  static <R, E, A extends AutoCloseable, B> PureIO<R, E, B> bracket(Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> acquire,
-                                                                 Function1<? super A, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends B>> use) {
+  static <R, E, A extends AutoCloseable, B> PureIO<R, E, B> bracket(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> acquire,
+                                                                 Function1<? super A, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B>> use) {
     return bracket(acquire, use, AutoCloseable::close);
   }
 
-  static <R, E, A, B> PureIO<R, E, B> bracket(Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> acquire,
-                                           Function1<? super A, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends B>> use,
+  static <R, E, A, B> PureIO<R, E, B> bracket(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> acquire,
+                                           Function1<? super A, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B>> use,
                                            Consumer1<? super A> release) {
     return bracket(acquire, use, release.asFunction().andThen(PureIO::pure));
   }
 
-  static <R, E, A, B> PureIO<R, E, B> bracket(Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> acquire,
-                                           Function1<? super A, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends B>> use,
-                                           Function1<? super A, ? extends Kind<Kind<Kind<PureIO_, R>, E>, Unit>> release) {
+  static <R, E, A, B> PureIO<R, E, B> bracket(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> acquire,
+                                           Function1<? super A, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B>> use,
+                                           Function1<? super A, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, Unit>> release) {
     // TODO: cancel
     return cancellable((env, callback) -> {
 
@@ -516,7 +516,7 @@ private static <R, E, A> Promise<Either<E, A>> runAsync(@Nullable R env, PureIO<
 
   @SuppressWarnings("unchecked")
   private static <R, E, F, G, A, B, C> Promise<Either<E, A>> runAsync(
-      @Nullable R env, Kind<Kind<Kind<PureIO_, R>, E>, A> current, PureIOConnection connection, CallStack<R, E, A> stack, Promise<Either<E, A>> promise) {
+      @Nullable R env, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A> current, PureIOConnection connection, CallStack<R, E, A> stack, Promise<Either<E, A>> promise) {
     while (true) {
       try {
         current = unwrap(env, current, stack, identity());
@@ -537,7 +537,7 @@ private static <R, E, F, G, A, B, C> Promise<Either<E, A>> runAsync(
           stack.push();
 
           var flatMapped = (FlatMapped<R, F, B, E, A>) current;
-          Kind<Kind<Kind<PureIO_, R>, F>, B> source = unwrap(env, flatMapped.current, stack,
+          Kind<Kind<Kind<PureIO<?, ?, ?>, R>, F>, B> source = unwrap(env, flatMapped.current, stack,
               b -> b.fix(PureIOOf::narrowK).foldM(flatMapped.nextError, flatMapped.next));
 
           if (source instanceof Async<R, F, B> async) {
@@ -582,9 +582,9 @@ private static <R, E, F, G, A, B, C> Promise<Either<E, A>> runAsync(
   }
 
   @SuppressWarnings("unchecked")
-  private static <R, E, F, A, B> Kind<Kind<Kind<PureIO_, R>, E>, A> unwrap(
-      @Nullable R env, Kind<Kind<Kind<PureIO_, R>, E>, A> current, CallStack<R, F, B> stack,
-      Function1<Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>, Kind<Kind<Kind<PureIO_, R>, F>, ? extends B>> next) {
+  private static <R, E, F, A, B> Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A> unwrap(
+      @Nullable R env, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A> current, CallStack<R, F, B> stack,
+      Function1<Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, F>, ? extends B>> next) {
     while (true) {
       if (current instanceof Failure) {
         return current;
@@ -616,7 +616,7 @@ private static <R, E, F, A, B> Kind<Kind<Kind<PureIO_, R>, E>, A> unwrap(
   }
 
   @SuppressWarnings("NullAway")
-  static <R, E, A> Kind<Kind<Kind<PureIO_, R>, E>, A> accessM(@Nullable R env, AccessM<R, E, A> accessM) {
+  static <R, E, A> Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A> accessM(@Nullable R env, AccessM<R, E, A> accessM) {
     return accessM.function.apply(env).fix(PureIOOf::<R, E, A>narrowK);
   }
 
@@ -686,13 +686,13 @@ public String toString() {
 
   final class FlatMapped<R, E, A, F, B> implements PureIO<R, F, B> {
 
-    private final Kind<Kind<Kind<PureIO_, R>, E>, A> current;
-    private final Function1<? super E, ? extends Kind<Kind<Kind<PureIO_, R>, F>, ? extends B>> nextError;
-    private final Function1<? super A, ? extends Kind<Kind<Kind<PureIO_, R>, F>, ? extends B>> next;
+    private final Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A> current;
+    private final Function1<? super E, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, F>, ? extends B>> nextError;
+    private final Function1<? super A, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, F>, ? extends B>> next;
 
     private FlatMapped(PureIO<R, E, A> current,
-                         Function1<? super E, ? extends Kind<Kind<Kind<PureIO_, R>, F>, ? extends B>> nextError,
-                         Function1<? super A, ? extends Kind<Kind<Kind<PureIO_, R>, F>, ? extends B>> next) {
+                         Function1<? super E, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, F>, ? extends B>> nextError,
+                         Function1<? super A, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, F>, ? extends B>> next) {
       this.current = checkNonNull(current);
       this.nextError = checkNonNull(nextError);
       this.next = checkNonNull(next);
@@ -720,9 +720,9 @@ public String toString() {
 
   final class Suspend<R, E, A> implements PureIO<R, E, A> {
 
-    private final Producer<Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>> lazy;
+    private final Producer<Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>> lazy;
 
-    private Suspend(Producer<Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>> lazy) {
+    private Suspend(Producer<Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>> lazy) {
       this.lazy = checkNonNull(lazy);
     }
 
@@ -778,9 +778,9 @@ public String toString() {
 
   final class AccessM<R, E, A> implements PureIO<R, E, A> {
 
-    private final Function1<? super R, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>> function;
+    private final Function1<? super R, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>> function;
 
-    private AccessM(Function1<? super R, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>> function) {
+    private AccessM(Function1<? super R, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>> function) {
       this.function = checkNonNull(function);
     }
 
@@ -943,7 +943,7 @@ public void pop() {
     }
   }
 
-  public void add(PartialFunction1<? super Throwable, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>> mapError) {
+  public void add(PartialFunction1<? super Throwable, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>> mapError) {
     if (top == null) {
       return;
     }
@@ -972,7 +972,7 @@ public Option<PureIO<R, E, A>> tryHandle(Throwable error) {
 final class StackItem<R, E, A> {
 
   private int count = 0;
-  private final Deque<PartialFunction1<? super Throwable, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>>> recover = new ArrayDeque<>();
+  private final Deque<PartialFunction1<? super Throwable, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>>> recover = new ArrayDeque<>();
 
   @Nullable
   private final StackItem<R, E, A> prev;
@@ -1006,7 +1006,7 @@ public void reset() {
     count = 0;
   }
 
-  public void add(PartialFunction1<? super Throwable, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>> mapError) {
+  public void add(PartialFunction1<? super Throwable, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>> mapError) {
     recover.addFirst(mapError);
   }
 
diff --git a/effect/src/main/java/com/github/tonivade/purefun/effect/RIO.java b/effect/src/main/java/com/github/tonivade/purefun/effect/RIO.java
index 202de5970..00d03446f 100644
--- a/effect/src/main/java/com/github/tonivade/purefun/effect/RIO.java
+++ b/effect/src/main/java/com/github/tonivade/purefun/effect/RIO.java
@@ -37,7 +37,7 @@
 import com.github.tonivade.purefun.typeclasses.FunctionK;
 
 @HigherKind
-public final class RIO<R, A> implements RIOOf<R, A>, Effect<Kind<RIO_, R>, A>, Recoverable {
+public final class RIO<R, A> implements RIOOf<R, A>, Effect<Kind<RIO<?, ?>, R>, A>, Recoverable {
 
   private static final RIO<?, Unit> UNIT = new RIO<>(PureIO.unit());
 
@@ -82,7 +82,7 @@ public <B> RIO<R, B> map(Function1<? super A, ? extends B> map) {
   }
 
   @Override
-  public <B> RIO<R, B> flatMap(Function1<? super A, ? extends Kind<Kind<RIO_, R>, ? extends B>> map) {
+  public <B> RIO<R, B> flatMap(Function1<? super A, ? extends Kind<Kind<RIO<?, ?>, R>, ? extends B>> map) {
     return new RIO<>(instance.flatMap(x -> {
       RIO<R, ? extends B> apply = map.andThen(RIOOf::narrowK).apply(x);
       return apply.instance;
@@ -90,12 +90,12 @@ public <B> RIO<R, B> flatMap(Function1<? super A, ? extends Kind<Kind<RIO_, R>,
   }
 
   @Override
-  public <B> RIO<R, B> andThen(Kind<Kind<RIO_, R>, ? extends B> next) {
+  public <B> RIO<R, B> andThen(Kind<Kind<RIO<?, ?>, R>, ? extends B> next) {
     return new RIO<>(instance.andThen(next.fix(RIOOf.toRIO()).instance));
   }
 
   @Override
-  public <B> RIO<R, B> ap(Kind<Kind<RIO_, R>, ? extends Function1<? super A, ? extends B>> apply) {
+  public <B> RIO<R, B> ap(Kind<Kind<RIO<?, ?>, R>, ? extends Function1<? super A, ? extends B>> apply) {
     return new RIO<>(instance.ap(apply.fix(RIOOf.toRIO()).instance));
   }
 
@@ -119,42 +119,42 @@ public <B> URIO<R, B> fold(
   }
 
   public <B> RIO<R, B> foldM(
-      Function1<? super Throwable, ? extends Kind<Kind<RIO_, R>, ? extends B>> mapError,
-      Function1<? super A, ? extends Kind<Kind<RIO_, R>, ? extends B>> map) {
+      Function1<? super Throwable, ? extends Kind<Kind<RIO<?, ?>, R>, ? extends B>> mapError,
+      Function1<? super A, ? extends Kind<Kind<RIO<?, ?>, R>, ? extends B>> map) {
     return new RIO<>(instance.foldM(
         error -> mapError.andThen(RIOOf::narrowK).apply(error).instance,
         value -> map.andThen(RIOOf::narrowK).apply(value).instance));
   }
 
-  public RIO<R, A> orElse(Kind<Kind<RIO_, R>, ? extends A> other) {
+  public RIO<R, A> orElse(Kind<Kind<RIO<?, ?>, R>, ? extends A> other) {
     return foldM(Function1.cons(other), Function1.cons(this));
   }
 
   @Override
-  public <B> RIO<R, Tuple2<A, B>> zip(Kind<Kind<RIO_, R>, ? extends B> other) {
+  public <B> RIO<R, Tuple2<A, B>> zip(Kind<Kind<RIO<?, ?>, R>, ? extends B> other) {
     return zipWith(other, Tuple::of);
   }
 
   @Override
-  public <B> RIO<R, A> zipLeft(Kind<Kind<RIO_, R>, ? extends B> other) {
+  public <B> RIO<R, A> zipLeft(Kind<Kind<RIO<?, ?>, R>, ? extends B> other) {
     return zipWith(other, first());
   }
 
   @Override
-  public <B> RIO<R, B> zipRight(Kind<Kind<RIO_, R>, ? extends B> other) {
+  public <B> RIO<R, B> zipRight(Kind<Kind<RIO<?, ?>, R>, ? extends B> other) {
     return zipWith(other, second());
   }
 
   @Override
-  public <B, C> RIO<R, C> zipWith(Kind<Kind<RIO_, R>, ? extends B> other,
+  public <B, C> RIO<R, C> zipWith(Kind<Kind<RIO<?, ?>, R>, ? extends B> other,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(this, other.fix(RIOOf.toRIO()), mapper);
   }
 
-  public RIO<R, Fiber<Kind<RIO_, R>, A>> fork() {
+  public RIO<R, Fiber<Kind<RIO<?, ?>, R>, A>> fork() {
     return new RIO<>(instance.fork().map(f -> f.mapK(new FunctionK<>() {
       @Override
-      public <T> RIO<R, T> apply(Kind<Kind<Kind<PureIO_, R>, Throwable>, ? extends T> from) {
+      public <T> RIO<R, T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>, ? extends T> from) {
         return new RIO<>(from.fix(PureIOOf::narrowK));
       }
     })));
@@ -220,7 +220,7 @@ public static <R> RIO<R, Unit> forked(Executor executor) {
     return async((env, callback) -> executor.execute(() -> callback.accept(Try.success(Unit.unit()))));
   }
 
-  public static <R, A> RIO<R, A> accessM(Function1<? super R, ? extends Kind<Kind<RIO_, R>, ? extends A>> map) {
+  public static <R, A> RIO<R, A> accessM(Function1<? super R, ? extends Kind<Kind<RIO<?, ?>, R>, ? extends A>> map) {
     return new RIO<>(PureIO.accessM(map.andThen(RIOOf::narrowK).andThen(RIO::toPureIO)));
   }
 
@@ -236,39 +236,39 @@ public static <R, A> RIO<R, A> absorb(RIO<R, Either<Throwable, A>> value) {
     return new RIO<>(PureIO.absorb(value.instance));
   }
 
-  public static <R, A, B, C> RIO<R, C> parMap2(Kind<Kind<RIO_, R>, ? extends A> za, Kind<Kind<RIO_, R>, ? extends B> zb,
+  public static <R, A, B, C> RIO<R, C> parMap2(Kind<Kind<RIO<?, ?>, R>, ? extends A> za, Kind<Kind<RIO<?, ?>, R>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(Future.DEFAULT_EXECUTOR, za, zb, mapper);
   }
 
-  public static <R, A, B, C> RIO<R, C> parMap2(Executor executor, Kind<Kind<RIO_, R>, ? extends A> za, Kind<Kind<RIO_, R>, ? extends B> zb,
+  public static <R, A, B, C> RIO<R, C> parMap2(Executor executor, Kind<Kind<RIO<?, ?>, R>, ? extends A> za, Kind<Kind<RIO<?, ?>, R>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return new RIO<>(PureIO.parMap2(executor, za.fix(RIOOf::narrowK).instance, zb.fix(RIOOf::narrowK).instance, mapper));
   }
 
-  public static <R, A, B> RIO<R, Either<A, B>> race(Kind<Kind<RIO_, R>, ? extends A> fa, Kind<Kind<RIO_, R>, ? extends B> fb) {
+  public static <R, A, B> RIO<R, Either<A, B>> race(Kind<Kind<RIO<?, ?>, R>, ? extends A> fa, Kind<Kind<RIO<?, ?>, R>, ? extends B> fb) {
     return race(Future.DEFAULT_EXECUTOR, fa, fb);
   }
 
-  public static <R, A, B> RIO<R, Either<A, B>> race(Executor executor, Kind<Kind<RIO_, R>, ? extends A> fa, Kind<Kind<RIO_, R>, ? extends B> fb) {
+  public static <R, A, B> RIO<R, Either<A, B>> race(Executor executor, Kind<Kind<RIO<?, ?>, R>, ? extends A> fa, Kind<Kind<RIO<?, ?>, R>, ? extends B> fb) {
     return racePair(executor, fa, fb).flatMap(either -> either.fold(
         ta -> ta.get2().cancel().fix(RIOOf.toRIO()).map(x -> Either.left(ta.get1())),
         tb -> tb.get1().cancel().fix(RIOOf.toRIO()).map(x -> Either.right(tb.get2()))));
   }
 
-  public static <R, A, B> RIO<R, Either<Tuple2<A, Fiber<Kind<RIO_, R>, B>>, Tuple2<Fiber<Kind<RIO_, R>, A>, B>>>
-      racePair(Executor executor, Kind<Kind<RIO_, R>, ? extends A> fa, Kind<Kind<RIO_, R>, ? extends B> fb) {
+  public static <R, A, B> RIO<R, Either<Tuple2<A, Fiber<Kind<RIO<?, ?>, R>, B>>, Tuple2<Fiber<Kind<RIO<?, ?>, R>, A>, B>>>
+      racePair(Executor executor, Kind<Kind<RIO<?, ?>, R>, ? extends A> fa, Kind<Kind<RIO<?, ?>, R>, ? extends B> fb) {
     PureIO<R, Throwable, A> instance1 = fa.fix(RIOOf.toRIO()).instance.fix(PureIOOf::narrowK);
     PureIO<R, Throwable, B> instance2 = fb.fix(RIOOf.toRIO()).instance.fix(PureIOOf::narrowK);
     return new RIO<>(PureIO.racePair(executor, instance1, instance2).map(
       either -> either.bimap(a -> a.map2(f -> f.mapK(new FunctionK<>() {
         @Override
-        public <T> RIO<R, T> apply(Kind<Kind<Kind<PureIO_, R>, Throwable>, ? extends T> from) {
+        public <T> RIO<R, T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>, ? extends T> from) {
           return new RIO<>(from.fix(PureIOOf::narrowK));
         }
       })), b -> b.map1(f -> f.mapK(new FunctionK<>() {
         @Override
-        public <T> RIO<R, T> apply(Kind<Kind<Kind<PureIO_, R>, Throwable>, ? extends T> from) {
+        public <T> RIO<R, T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>, ? extends T> from) {
           return new RIO<>(from.fix(PureIOOf::narrowK));
         }
       })))));
@@ -334,7 +334,7 @@ public static <R, A> RIO<R, A> raiseError(Throwable throwable) {
     return new RIO<>(PureIO.raiseError(throwable));
   }
 
-  public static <R, A> RIO<R, A> defer(Producer<Kind<Kind<RIO_, R>, ? extends A>> lazy) {
+  public static <R, A> RIO<R, A> defer(Producer<Kind<Kind<RIO<?, ?>, R>, ? extends A>> lazy) {
     return new RIO<>(PureIO.defer(() -> lazy.andThen(RIOOf::narrowK).get().instance));
   }
 
@@ -356,29 +356,29 @@ public static <R, A> RIO<R, A> cancellable(Function2<R, Consumer1<? super Try<?
       (env, cb1) -> consumer.andThen(RIO::toPureIO).apply(env, result -> cb1.accept(result.map(Either::right)))));
   }
 
-  public static <R, A> RIO<R, Sequence<A>> traverse(Sequence<? extends Kind<Kind<RIO_, R>, A>> sequence) {
+  public static <R, A> RIO<R, Sequence<A>> traverse(Sequence<? extends Kind<Kind<RIO<?, ?>, R>, A>> sequence) {
     return traverse(Future.DEFAULT_EXECUTOR, sequence);
   }
 
-  public static <R, A> RIO<R, Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<Kind<RIO_, R>, A>> sequence) {
+  public static <R, A> RIO<R, Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<Kind<RIO<?, ?>, R>, A>> sequence) {
     return sequence.foldLeft(pure(ImmutableList.empty()),
-        (Kind<Kind<RIO_, R>, Sequence<A>> xs, Kind<Kind<RIO_, R>, A> a) -> parMap2(executor, xs, a, Sequence::append));
+        (Kind<Kind<RIO<?, ?>, R>, Sequence<A>> xs, Kind<Kind<RIO<?, ?>, R>, A> a) -> parMap2(executor, xs, a, Sequence::append));
   }
 
-  public static <R, A extends AutoCloseable, B> RIO<R, B> bracket(Kind<Kind<RIO_, R>, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<Kind<RIO_, R>, ? extends B>> use) {
+  public static <R, A extends AutoCloseable, B> RIO<R, B> bracket(Kind<Kind<RIO<?, ?>, R>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<Kind<RIO<?, ?>, R>, ? extends B>> use) {
     return new RIO<>(PureIO.bracket(acquire.fix(RIOOf::narrowK).instance,
         resource -> use.andThen(RIOOf::narrowK).apply(resource).instance));
   }
 
-  public static <R, A, B> RIO<R, B> bracket(Kind<Kind<RIO_, R>, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<Kind<RIO_, R>, ? extends B>> use, Consumer1<? super A> release) {
+  public static <R, A, B> RIO<R, B> bracket(Kind<Kind<RIO<?, ?>, R>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<Kind<RIO<?, ?>, R>, ? extends B>> use, Consumer1<? super A> release) {
     return new RIO<>(PureIO.bracket(acquire.fix(RIOOf::narrowK).instance,
         resource -> use.andThen(RIOOf::narrowK).apply(resource).instance, release));
   }
 
-  public static <R, A, B> RIO<R, B> bracket(Kind<Kind<RIO_, R>, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<Kind<RIO_, R>, ? extends B>> use, Function1<? super A, ? extends Kind<Kind<RIO_, R>, Unit>> release) {
+  public static <R, A, B> RIO<R, B> bracket(Kind<Kind<RIO<?, ?>, R>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<Kind<RIO<?, ?>, R>, ? extends B>> use, Function1<? super A, ? extends Kind<Kind<RIO<?, ?>, R>, Unit>> release) {
     return new RIO<>(PureIO.bracket(acquire.fix(RIOOf::narrowK).instance,
         resource -> use.andThen(RIOOf::narrowK).apply(resource).instance, release.andThen(RIOOf::narrowK).andThen(RIO::toPureIO)));
   }
diff --git a/effect/src/main/java/com/github/tonivade/purefun/effect/Task.java b/effect/src/main/java/com/github/tonivade/purefun/effect/Task.java
index d9266cbac..2dcffd54c 100644
--- a/effect/src/main/java/com/github/tonivade/purefun/effect/Task.java
+++ b/effect/src/main/java/com/github/tonivade/purefun/effect/Task.java
@@ -35,7 +35,7 @@
 import com.github.tonivade.purefun.typeclasses.FunctionK;
 
 @HigherKind
-public final class Task<A> implements TaskOf<A>, Effect<Task_, A>, Recoverable {
+public final class Task<A> implements TaskOf<A>, Effect<Task<?>, A>, Recoverable {
 
   private static final Task<Unit> UNIT = new Task<>(PureIO.unit());
 
@@ -85,7 +85,7 @@ public <B> Task<B> map(Function1<? super A, ? extends B> map) {
   }
 
   @Override
-  public <B> Task<B> flatMap(Function1<? super A, ? extends Kind<Task_, ? extends B>> map) {
+  public <B> Task<B> flatMap(Function1<? super A, ? extends Kind<Task<?>, ? extends B>> map) {
     return new Task<>(instance.flatMap(value -> {
       Task<? extends B> apply = map.andThen(TaskOf::narrowK).apply(value);
       return apply.instance;
@@ -93,18 +93,18 @@ public <B> Task<B> flatMap(Function1<? super A, ? extends Kind<Task_, ? extends
   }
 
   @Override
-  public <B> Task<B> andThen(Kind<Task_, ? extends B> next) {
+  public <B> Task<B> andThen(Kind<Task<?>, ? extends B> next) {
     return new Task<>(instance.andThen(next.fix(TaskOf.toTask()).instance));
   }
 
   @Override
-  public <B> Task<B> ap(Kind<Task_, ? extends Function1<? super A, ? extends B>> apply) {
+  public <B> Task<B> ap(Kind<Task<?>, ? extends Function1<? super A, ? extends B>> apply) {
     return new Task<>(instance.ap(apply.fix(TaskOf.toTask()).instance));
   }
 
   public <B> Task<B> foldM(
-      Function1<? super Throwable, ? extends Kind<Task_, ? extends B>> mapError,
-      Function1<? super A, ? extends Kind<Task_, ? extends B>> map) {
+      Function1<? super Throwable, ? extends Kind<Task<?>, ? extends B>> mapError,
+      Function1<? super A, ? extends Kind<Task<?>, ? extends B>> map) {
     return new Task<>(instance.foldM(
         error -> mapError.andThen(TaskOf::narrowK).apply(error).instance,
         value -> map.andThen(TaskOf::narrowK).apply(value).instance));
@@ -129,35 +129,35 @@ public UIO<A> recover(Function1<? super Throwable, ? extends A> mapError) {
     return new UIO<>(instance.recover(mapError).toPureIO());
   }
 
-  public Task<A> orElse(Kind<Task_, ? extends A> other) {
+  public Task<A> orElse(Kind<Task<?>, ? extends A> other) {
     return new Task<>(instance.orElse(other.fix(TaskOf.toTask()).instance));
   }
 
   @Override
-  public <B> Task<Tuple2<A, B>> zip(Kind<Task_, ? extends B> other) {
+  public <B> Task<Tuple2<A, B>> zip(Kind<Task<?>, ? extends B> other) {
     return zipWith(other, Tuple::of);
   }
 
   @Override
-  public <B> Task<A> zipLeft(Kind<Task_, ? extends B> other) {
+  public <B> Task<A> zipLeft(Kind<Task<?>, ? extends B> other) {
     return zipWith(other, first());
   }
 
   @Override
-  public <B> Task<B> zipRight(Kind<Task_, ? extends B> other) {
+  public <B> Task<B> zipRight(Kind<Task<?>, ? extends B> other) {
     return zipWith(other, second());
   }
 
   @Override
-  public <B, C> Task<C> zipWith(Kind<Task_, ? extends B> other,
+  public <B, C> Task<C> zipWith(Kind<Task<?>, ? extends B> other,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(this, other.fix(TaskOf.toTask()), mapper);
   }
 
-  public Task<Fiber<Task_, A>> fork() {
+  public Task<Fiber<Task<?>, A>> fork() {
     return new Task<>(instance.fork().map(f -> f.mapK(new FunctionK<>() {
       @Override
-      public <T> Task<T> apply(Kind<Kind<Kind<PureIO_, Void>, Throwable>, ? extends T> from) {
+      public <T> Task<T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, ? extends T> from) {
         return new Task<>(from.fix(PureIOOf::narrowK));
       }
     })));
@@ -223,39 +223,39 @@ public static Task<Unit> forked(Executor executor) {
     return async(callback -> executor.execute(() -> callback.accept(Try.success(Unit.unit()))));
   }
 
-  public static <A, B, C> Task<C> parMap2(Kind<Task_, ? extends A> za, Kind<Task_, ? extends B> zb,
+  public static <A, B, C> Task<C> parMap2(Kind<Task<?>, ? extends A> za, Kind<Task<?>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(Future.DEFAULT_EXECUTOR, za, zb, mapper);
   }
 
-  public static <A, B, C> Task<C> parMap2(Executor executor, Kind<Task_, ? extends A> za, Kind<Task_, ? extends B> zb,
+  public static <A, B, C> Task<C> parMap2(Executor executor, Kind<Task<?>, ? extends A> za, Kind<Task<?>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return new Task<>(PureIO.parMap2(executor, za.fix(TaskOf::narrowK).instance, zb.fix(TaskOf::narrowK).instance, mapper));
   }
 
-  public static <A, B> Task<Either<A, B>> race(Kind<Task_, ? extends A> fa, Kind<Task_, ? extends B> fb) {
+  public static <A, B> Task<Either<A, B>> race(Kind<Task<?>, ? extends A> fa, Kind<Task<?>, ? extends B> fb) {
     return race(Future.DEFAULT_EXECUTOR, fa, fb);
   }
 
-  public static <A, B> Task<Either<A, B>> race(Executor executor, Kind<Task_, ? extends A> fa, Kind<Task_, ? extends B> fb) {
+  public static <A, B> Task<Either<A, B>> race(Executor executor, Kind<Task<?>, ? extends A> fa, Kind<Task<?>, ? extends B> fb) {
     return racePair(executor, fa, fb).flatMap(either -> either.fold(
         ta -> ta.get2().cancel().fix(TaskOf.toTask()).map(x -> Either.left(ta.get1())),
         tb -> tb.get1().cancel().fix(TaskOf.toTask()).map(x -> Either.right(tb.get2()))));
   }
 
-  public static <A, B> Task<Either<Tuple2<A, Fiber<Task_, B>>, Tuple2<Fiber<Task_, A>, B>>>
-      racePair(Executor executor, Kind<Task_, ? extends A> fa, Kind<Task_, ? extends B> fb) {
+  public static <A, B> Task<Either<Tuple2<A, Fiber<Task<?>, B>>, Tuple2<Fiber<Task<?>, A>, B>>>
+      racePair(Executor executor, Kind<Task<?>, ? extends A> fa, Kind<Task<?>, ? extends B> fb) {
     PureIO<Void, Throwable, A> instance1 = fa.fix(TaskOf.toTask()).instance.fix(PureIOOf::narrowK);
     PureIO<Void, Throwable, B> instance2 = fb.fix(TaskOf.toTask()).instance.fix(PureIOOf::narrowK);
     return new Task<>(PureIO.racePair(executor, instance1, instance2).map(
       either -> either.bimap(a -> a.map2(f -> f.mapK(new FunctionK<>() {
         @Override
-        public <T> Task<T> apply(Kind<Kind<Kind<PureIO_, Void>, Throwable>, ? extends T> from) {
+        public <T> Task<T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, ? extends T> from) {
           return new Task<>(from.fix(PureIOOf::narrowK));
         }
       })), b -> b.map1(f -> f.mapK(new FunctionK<>() {
         @Override
-        public <T> Task<T> apply(Kind<Kind<Kind<PureIO_, Void>, Throwable>, ? extends T> from) {
+        public <T> Task<T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, ? extends T> from) {
           return new Task<>(from.fix(PureIOOf::narrowK));
         }
       })))));
@@ -321,7 +321,7 @@ public static <A> Task<A> pure(A value) {
     return new Task<>(PureIO.pure(value));
   }
 
-  public static <A> Task<A> defer(Producer<? extends Kind<Task_, ? extends A>> lazy) {
+  public static <A> Task<A> defer(Producer<? extends Kind<Task<?>, ? extends A>> lazy) {
     return new Task<>(PureIO.defer(() -> lazy.andThen(TaskOf::narrowK).get().instance));
   }
 
@@ -347,27 +347,27 @@ public static <A> Task<A> raiseError(Throwable error) {
     return new Task<>(PureIO.raiseError(error));
   }
 
-  public static <A> Task<Sequence<A>> traverse(Sequence<? extends Kind<Task_, A>> sequence) {
+  public static <A> Task<Sequence<A>> traverse(Sequence<? extends Kind<Task<?>, A>> sequence) {
     return traverse(Future.DEFAULT_EXECUTOR, sequence);
   }
 
-  public static <A> Task<Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<Task_, A>> sequence) {
+  public static <A> Task<Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<Task<?>, A>> sequence) {
     return sequence.foldLeft(pure(ImmutableList.empty()),
-        (Kind<Task_, Sequence<A>> xs, Kind<Task_, A> a) -> parMap2(executor, xs, a, Sequence::append));
+        (Kind<Task<?>, Sequence<A>> xs, Kind<Task<?>, A> a) -> parMap2(executor, xs, a, Sequence::append));
   }
 
   public static <A extends AutoCloseable, B> Task<B> bracket(
-      Kind<Task_, ? extends A> acquire, Function1<? super A, ? extends Kind<Task_, ? extends B>> use) {
+      Kind<Task<?>, ? extends A> acquire, Function1<? super A, ? extends Kind<Task<?>, ? extends B>> use) {
     return new Task<>(PureIO.bracket(acquire.fix(TaskOf::narrowK).instance, resource -> use.andThen(TaskOf::narrowK).apply(resource).instance));
   }
 
   public static <A, B> Task<B> bracket(
-      Kind<Task_, ? extends A> acquire, Function1<? super A, ? extends Kind<Task_, ? extends B>> use, Consumer1<? super A> release) {
+      Kind<Task<?>, ? extends A> acquire, Function1<? super A, ? extends Kind<Task<?>, ? extends B>> use, Consumer1<? super A> release) {
     return new Task<>(PureIO.bracket(acquire.fix(TaskOf::narrowK).instance, resource -> use.andThen(TaskOf::narrowK).apply(resource).instance, release));
   }
 
   public static <A, B> Task<B> bracket(
-      Kind<Task_, ? extends A> acquire, Function1<? super A, ? extends Kind<Task_, ? extends B>> use, Function1<? super A, ? extends Kind<Task_, Unit>> release) {
+      Kind<Task<?>, ? extends A> acquire, Function1<? super A, ? extends Kind<Task<?>, ? extends B>> use, Function1<? super A, ? extends Kind<Task<?>, Unit>> release) {
     return new Task<>(PureIO.bracket(acquire.fix(TaskOf::narrowK).instance, resource -> use.andThen(TaskOf::narrowK).apply(resource).instance, release.andThen(TaskOf::narrowK).andThen(Task::toPureIO)));
   }
 
diff --git a/effect/src/main/java/com/github/tonivade/purefun/effect/UIO.java b/effect/src/main/java/com/github/tonivade/purefun/effect/UIO.java
index 16b166632..b96457678 100644
--- a/effect/src/main/java/com/github/tonivade/purefun/effect/UIO.java
+++ b/effect/src/main/java/com/github/tonivade/purefun/effect/UIO.java
@@ -37,7 +37,7 @@
 import com.github.tonivade.purefun.typeclasses.FunctionK;
 
 @HigherKind
-public final class UIO<A> implements UIOOf<A>, Effect<UIO_, A>, Recoverable {
+public final class UIO<A> implements UIOOf<A>, Effect<UIO<?>, A>, Recoverable {
 
   private static final UIO<Unit> UNIT = new UIO<>(PureIO.unit());
 
@@ -101,7 +101,7 @@ public <B> UIO<B> map(Function1<? super A, ? extends B> map) {
   }
 
   @Override
-  public <B> UIO<B> flatMap(Function1<? super A, ? extends Kind<UIO_, ? extends B>> map) {
+  public <B> UIO<B> flatMap(Function1<? super A, ? extends Kind<UIO<?>, ? extends B>> map) {
     return new UIO<>(instance.flatMap(x -> {
       UIO<? extends B> apply = map.andThen(UIOOf::narrowK).apply(x);
       return apply.instance;
@@ -109,12 +109,12 @@ public <B> UIO<B> flatMap(Function1<? super A, ? extends Kind<UIO_, ? extends B>
   }
 
   @Override
-  public <B> UIO<B> andThen(Kind<UIO_, ? extends B> next) {
+  public <B> UIO<B> andThen(Kind<UIO<?>, ? extends B> next) {
     return new UIO<>(instance.andThen(next.fix(UIOOf.toUIO()).instance));
   }
 
   @Override
-  public <B> UIO<B> ap(Kind<UIO_, ? extends Function1<? super A, ? extends B>> apply) {
+  public <B> UIO<B> ap(Kind<UIO<?>, ? extends Function1<? super A, ? extends B>> apply) {
     return new UIO<>(instance.ap(apply.fix(UIOOf.toUIO()).instance));
   }
 
@@ -138,38 +138,38 @@ public <B> UIO<B> redeem(
   }
 
   public <B> UIO<B> redeemWith(
-      Function1<? super Throwable, ? extends Kind<UIO_, ? extends B>> mapError,
-      Function1<? super A, ? extends Kind<UIO_, ? extends B>> map) {
+      Function1<? super Throwable, ? extends Kind<UIO<?>, ? extends B>> mapError,
+      Function1<? super A, ? extends Kind<UIO<?>, ? extends B>> map) {
     return new UIO<>(PureIO.redeem(instance).foldM(
         error -> mapError.andThen(UIOOf::narrowK).apply(error).instance,
         value -> map.andThen(UIOOf::narrowK).apply(value).instance));
   }
 
   @Override
-  public <B> UIO<Tuple2<A, B>> zip(Kind<UIO_, ? extends B> other) {
+  public <B> UIO<Tuple2<A, B>> zip(Kind<UIO<?>, ? extends B> other) {
     return zipWith(other, Tuple::of);
   }
 
   @Override
-  public <B> UIO<A> zipLeft(Kind<UIO_, ? extends B> other) {
+  public <B> UIO<A> zipLeft(Kind<UIO<?>, ? extends B> other) {
     return zipWith(other, first());
   }
 
   @Override
-  public <B> UIO<B> zipRight(Kind<UIO_, ? extends B> other) {
+  public <B> UIO<B> zipRight(Kind<UIO<?>, ? extends B> other) {
     return zipWith(other, second());
   }
 
   @Override
-  public <B, C> UIO<C> zipWith(Kind<UIO_, ? extends B> other,
+  public <B, C> UIO<C> zipWith(Kind<UIO<?>, ? extends B> other,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(this, other.fix(UIOOf.toUIO()), mapper);
   }
 
-  public UIO<Fiber<UIO_, A>> fork() {
+  public UIO<Fiber<UIO<?>, A>> fork() {
     return new UIO<>(instance.fork().map(f -> f.mapK(new FunctionK<>() {
       @Override
-      public <T> UIO<T> apply(Kind<Kind<Kind<PureIO_, Void>, Void>, ? extends T> from) {
+      public <T> UIO<T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Void>, ? extends T> from) {
         return new UIO<>(from.fix(PureIOOf::narrowK));
       }
     })));
@@ -235,39 +235,39 @@ public static UIO<Unit> forked(Executor executor) {
     return async(callback -> executor.execute(() -> callback.accept(Try.success(Unit.unit()))));
   }
 
-  public static <A, B, C> UIO<C> parMap2(Kind<UIO_, ? extends A> za, Kind<UIO_, ? extends B> zb,
+  public static <A, B, C> UIO<C> parMap2(Kind<UIO<?>, ? extends A> za, Kind<UIO<?>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(Future.DEFAULT_EXECUTOR, za, zb, mapper);
   }
 
-  public static <A, B, C> UIO<C> parMap2(Executor executor, Kind<UIO_, ? extends A> za, Kind<UIO_, ? extends B> zb,
+  public static <A, B, C> UIO<C> parMap2(Executor executor, Kind<UIO<?>, ? extends A> za, Kind<UIO<?>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return new UIO<>(PureIO.parMap2(executor, za.fix(UIOOf::narrowK).instance, zb.fix(UIOOf::narrowK).instance, mapper));
   }
 
-  public static <A, B> UIO<Either<A, B>> race(Kind<UIO_, ? extends A> fa, Kind<UIO_, ? extends B> fb) {
+  public static <A, B> UIO<Either<A, B>> race(Kind<UIO<?>, ? extends A> fa, Kind<UIO<?>, ? extends B> fb) {
     return race(Future.DEFAULT_EXECUTOR, fa, fb);
   }
 
-  public static <A, B> UIO<Either<A, B>> race(Executor executor, Kind<UIO_, ? extends A> fa, Kind<UIO_, ? extends B> fb) {
+  public static <A, B> UIO<Either<A, B>> race(Executor executor, Kind<UIO<?>, ? extends A> fa, Kind<UIO<?>, ? extends B> fb) {
     return racePair(executor, fa, fb).flatMap(either -> either.fold(
         ta -> ta.get2().cancel().fix(UIOOf.toUIO()).map(x -> Either.left(ta.get1())),
         tb -> tb.get1().cancel().fix(UIOOf.toUIO()).map(x -> Either.right(tb.get2()))));
   }
 
-  public static <A, B> UIO<Either<Tuple2<A, Fiber<UIO_, B>>, Tuple2<Fiber<UIO_, A>, B>>>
-      racePair(Executor executor, Kind<UIO_, ? extends A> fa, Kind<UIO_, ? extends B> fb) {
+  public static <A, B> UIO<Either<Tuple2<A, Fiber<UIO<?>, B>>, Tuple2<Fiber<UIO<?>, A>, B>>>
+      racePair(Executor executor, Kind<UIO<?>, ? extends A> fa, Kind<UIO<?>, ? extends B> fb) {
     PureIO<Void, Void, A> instance1 = fa.fix(UIOOf.toUIO()).instance.fix(PureIOOf::narrowK);
     PureIO<Void, Void, B> instance2 = fb.fix(UIOOf.toUIO()).instance.fix(PureIOOf::narrowK);
     return new UIO<>(PureIO.racePair(executor, instance1, instance2).map(
       either -> either.bimap(a -> a.map2(f -> f.mapK(new FunctionK<>() {
         @Override
-        public <T> UIO<T> apply(Kind<Kind<Kind<PureIO_, Void>, Void>, ? extends T> from) {
+        public <T> UIO<T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Void>, ? extends T> from) {
           return new UIO<>(from.fix(PureIOOf::narrowK));
         }
       })), b -> b.map1(f -> f.mapK(new FunctionK<>() {
         @Override
-        public <T> UIO<T> apply(Kind<Kind<Kind<PureIO_, Void>, Void>, ? extends T> from) {
+        public <T> UIO<T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Void>, ? extends T> from) {
           return new UIO<>(from.fix(PureIOOf::narrowK));
         }
       })))));
@@ -309,7 +309,7 @@ public static <A> UIO<A> raiseError(Throwable throwable) {
     return new UIO<>(PureIO.fromEither(() -> { throw throwable; }));
   }
 
-  public static <A> UIO<A> defer(Producer<Kind<UIO_, ? extends A>> lazy) {
+  public static <A> UIO<A> defer(Producer<Kind<UIO<?>, ? extends A>> lazy) {
     return new UIO<>(PureIO.defer(() -> lazy.andThen(UIOOf::narrowK).get().instance));
   }
 
@@ -364,29 +364,29 @@ public static <A, T> UIO<Function1<A, UIO<T>>> memoize(Executor executor, Functi
     });
   }
 
-  public static <A> UIO<Sequence<A>> traverse(Sequence<? extends Kind<UIO_, A>> sequence) {
+  public static <A> UIO<Sequence<A>> traverse(Sequence<? extends Kind<UIO<?>, A>> sequence) {
     return traverse(Future.DEFAULT_EXECUTOR, sequence);
   }
 
-  public static <A> UIO<Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<UIO_, A>> sequence) {
+  public static <A> UIO<Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<UIO<?>, A>> sequence) {
     return sequence.foldLeft(pure(ImmutableList.empty()),
-        (Kind<UIO_, Sequence<A>> xs, Kind<UIO_, A> a) -> parMap2(executor, xs, a, Sequence::append));
+        (Kind<UIO<?>, Sequence<A>> xs, Kind<UIO<?>, A> a) -> parMap2(executor, xs, a, Sequence::append));
   }
 
   public static <A extends AutoCloseable, B> UIO<B> bracket(
-      Kind<UIO_, ? extends A> acquire, Function1<? super A, ? extends Kind<UIO_, ? extends B>> use) {
+      Kind<UIO<?>, ? extends A> acquire, Function1<? super A, ? extends Kind<UIO<?>, ? extends B>> use) {
     return fold(PureIO.bracket(PureIO.redeem(acquire.fix(UIOOf::narrowK).instance),
         resource -> PureIO.redeem(use.andThen(UIOOf::narrowK).apply(resource).instance)));
   }
 
-  public static <A, B> UIO<B> bracket(Kind<UIO_, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<UIO_, ? extends B>> use, Consumer1<? super A> release) {
+  public static <A, B> UIO<B> bracket(Kind<UIO<?>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<UIO<?>, ? extends B>> use, Consumer1<? super A> release) {
     return fold(PureIO.bracket(PureIO.redeem(acquire.fix(UIOOf::narrowK).instance),
         resource -> PureIO.redeem(use.andThen(UIOOf::narrowK).apply(resource).instance), release));
   }
 
-  public static <A, B> UIO<B> bracket(Kind<UIO_, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<UIO_, ? extends B>> use, Function1<? super A, ? extends Kind<UIO_, Unit>> release) {
+  public static <A, B> UIO<B> bracket(Kind<UIO<?>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<UIO<?>, ? extends B>> use, Function1<? super A, ? extends Kind<UIO<?>, Unit>> release) {
     return fold(PureIO.bracket(PureIO.redeem(acquire.fix(UIOOf::narrowK).instance),
         resource -> PureIO.redeem(use.andThen(UIOOf::narrowK).apply(resource).instance), release.andThen(UIOOf::narrowK).andThen(UIO::toPureIO)));
   }
diff --git a/effect/src/main/java/com/github/tonivade/purefun/effect/URIO.java b/effect/src/main/java/com/github/tonivade/purefun/effect/URIO.java
index d2929993b..21583364d 100644
--- a/effect/src/main/java/com/github/tonivade/purefun/effect/URIO.java
+++ b/effect/src/main/java/com/github/tonivade/purefun/effect/URIO.java
@@ -36,7 +36,7 @@
 import com.github.tonivade.purefun.typeclasses.FunctionK;
 
 @HigherKind
-public final class URIO<R, A> implements URIOOf<R, A>, Effect<Kind<URIO_, R>, A>, Recoverable {
+public final class URIO<R, A> implements URIOOf<R, A>, Effect<Kind<URIO<?, ?>, R>, A>, Recoverable {
 
   private static final URIO<?, Unit> UNIT = new URIO<>(PureIO.unit());
 
@@ -86,7 +86,7 @@ public <B> URIO<R, B> map(Function1<? super A, ? extends B> map) {
   }
 
   @Override
-  public <B> URIO<R, B> flatMap(Function1<? super A, ? extends Kind<Kind<URIO_, R>, ? extends B>> map) {
+  public <B> URIO<R, B> flatMap(Function1<? super A, ? extends Kind<Kind<URIO<?, ?>, R>, ? extends B>> map) {
     return new URIO<>(instance.flatMap(x -> {
       URIO<R, ? extends B> apply = map.andThen(URIOOf::narrowK).apply(x);
       return apply.instance;
@@ -94,12 +94,12 @@ public <B> URIO<R, B> flatMap(Function1<? super A, ? extends Kind<Kind<URIO_, R>
   }
 
   @Override
-  public <B> URIO<R, B> andThen(Kind<Kind<URIO_, R>, ? extends B> next) {
+  public <B> URIO<R, B> andThen(Kind<Kind<URIO<?, ?>, R>, ? extends B> next) {
     return new URIO<>(instance.andThen(next.fix(URIOOf.toURIO()).instance));
   }
 
   @Override
-  public <B> URIO<R, B> ap(Kind<Kind<URIO_, R>, ? extends Function1<? super A, ? extends B>> apply) {
+  public <B> URIO<R, B> ap(Kind<Kind<URIO<?, ?>, R>, ? extends Function1<? super A, ? extends B>> apply) {
     return new URIO<>(instance.ap(apply.fix(URIOOf.toURIO()).instance));
   }
 
@@ -124,38 +124,38 @@ public <B> URIO<R, B> redeem(
   }
 
   public <B> URIO<R, B> redeemWith(
-      Function1<? super Throwable, ? extends Kind<Kind<URIO_, R>, ? extends B>> mapError,
-      Function1<? super A, ? extends Kind<Kind<URIO_, R>, ? extends B>> map) {
+      Function1<? super Throwable, ? extends Kind<Kind<URIO<?, ?>, R>, ? extends B>> mapError,
+      Function1<? super A, ? extends Kind<Kind<URIO<?, ?>, R>, ? extends B>> map) {
     return new URIO<>(PureIO.redeem(instance).foldM(
         error -> mapError.andThen(URIOOf::narrowK).apply(error).instance,
         value -> map.andThen(URIOOf::narrowK).apply(value).instance));
   }
 
   @Override
-  public <B> URIO<R, Tuple2<A, B>> zip(Kind<Kind<URIO_, R>, ? extends B> other) {
+  public <B> URIO<R, Tuple2<A, B>> zip(Kind<Kind<URIO<?, ?>, R>, ? extends B> other) {
     return zipWith(other, Tuple::of);
   }
 
   @Override
-  public <B> URIO<R, A> zipLeft(Kind<Kind<URIO_, R>, ? extends B> other) {
+  public <B> URIO<R, A> zipLeft(Kind<Kind<URIO<?, ?>, R>, ? extends B> other) {
     return zipWith(other, first());
   }
 
   @Override
-  public <B> URIO<R, B> zipRight(Kind<Kind<URIO_, R>, ? extends B> other) {
+  public <B> URIO<R, B> zipRight(Kind<Kind<URIO<?, ?>, R>, ? extends B> other) {
     return zipWith(other, second());
   }
 
   @Override
-  public <B, C> URIO<R, C> zipWith(Kind<Kind<URIO_, R>, ? extends B> other,
+  public <B, C> URIO<R, C> zipWith(Kind<Kind<URIO<?, ?>, R>, ? extends B> other,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(this, other.fix(URIOOf.toURIO()), mapper);
   }
 
-  public URIO<R, Fiber<Kind<URIO_, R>, A>> fork() {
+  public URIO<R, Fiber<Kind<URIO<?, ?>, R>, A>> fork() {
     return new URIO<>(instance.fork().map(f -> f.mapK(new FunctionK<>() {
       @Override
-      public <T> URIO<R, T> apply(Kind<Kind<Kind<PureIO_, R>, Void>, ? extends T> from) {
+      public <T> URIO<R, T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, Void>, ? extends T> from) {
         return new URIO<>(from.fix(PureIOOf::narrowK));
       }
     })));
@@ -221,7 +221,7 @@ public static <R> URIO<R, Unit> forked(Executor executor) {
     return async((env, callback) -> executor.execute(() -> callback.accept(Try.success(Unit.unit()))));
   }
 
-  public static <R, A> URIO<R, A> accessM(Function1<? super R, ? extends Kind<Kind<URIO_, R>, ? extends A>> map) {
+  public static <R, A> URIO<R, A> accessM(Function1<? super R, ? extends Kind<Kind<URIO<?, ?>, R>, ? extends A>> map) {
     return new URIO<>(PureIO.accessM(map.andThen(URIOOf::narrowK).andThen(URIO::toPureIO)));
   }
 
@@ -233,39 +233,39 @@ public static <R> URIO<R, R> env() {
     return access(identity());
   }
 
-  public static <R, A, B, C> URIO<R, C> parMap2(Kind<Kind<URIO_, R>, ? extends A> za, Kind<Kind<URIO_, R>, ? extends B> zb,
+  public static <R, A, B, C> URIO<R, C> parMap2(Kind<Kind<URIO<?, ?>, R>, ? extends A> za, Kind<Kind<URIO<?, ?>, R>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(Future.DEFAULT_EXECUTOR, za, zb, mapper);
   }
 
-  public static <R, A, B, C> URIO<R, C> parMap2(Executor executor, Kind<Kind<URIO_, R>, ? extends A> za, Kind<Kind<URIO_, R>, ? extends B> zb,
+  public static <R, A, B, C> URIO<R, C> parMap2(Executor executor, Kind<Kind<URIO<?, ?>, R>, ? extends A> za, Kind<Kind<URIO<?, ?>, R>, ? extends B> zb,
       Function2<? super A, ? super B, ? extends C> mapper) {
     return new URIO<>(PureIO.parMap2(executor, za.fix(URIOOf::narrowK).instance, zb.fix(URIOOf::narrowK).instance, mapper));
   }
 
-  public static <R, A, B> URIO<R, Either<A, B>> race(Kind<Kind<URIO_, R>, ? extends A> fa, Kind<Kind<URIO_, R>, ? extends B> fb) {
+  public static <R, A, B> URIO<R, Either<A, B>> race(Kind<Kind<URIO<?, ?>, R>, ? extends A> fa, Kind<Kind<URIO<?, ?>, R>, ? extends B> fb) {
     return race(Future.DEFAULT_EXECUTOR, fa, fb);
   }
 
-  public static <R, A, B> URIO<R, Either<A, B>> race(Executor executor, Kind<Kind<URIO_, R>, ? extends A> fa, Kind<Kind<URIO_, R>, ? extends B> fb) {
+  public static <R, A, B> URIO<R, Either<A, B>> race(Executor executor, Kind<Kind<URIO<?, ?>, R>, ? extends A> fa, Kind<Kind<URIO<?, ?>, R>, ? extends B> fb) {
     return racePair(executor, fa, fb).flatMap(either -> either.fold(
         ta -> ta.get2().cancel().fix(URIOOf.toURIO()).map(x -> Either.left(ta.get1())),
         tb -> tb.get1().cancel().fix(URIOOf.toURIO()).map(x -> Either.right(tb.get2()))));
   }
 
-  public static <R, A, B> URIO<R, Either<Tuple2<A, Fiber<Kind<URIO_, R>, B>>, Tuple2<Fiber<Kind<URIO_, R>, A>, B>>>
-      racePair(Executor executor, Kind<Kind<URIO_, R>, ? extends A> fa, Kind<Kind<URIO_, R>, ? extends B> fb) {
+  public static <R, A, B> URIO<R, Either<Tuple2<A, Fiber<Kind<URIO<?, ?>, R>, B>>, Tuple2<Fiber<Kind<URIO<?, ?>, R>, A>, B>>>
+      racePair(Executor executor, Kind<Kind<URIO<?, ?>, R>, ? extends A> fa, Kind<Kind<URIO<?, ?>, R>, ? extends B> fb) {
     PureIO<R, Void, A> instance1 = fa.fix(URIOOf.toURIO()).instance.fix(PureIOOf::narrowK);
     PureIO<R, Void, B> instance2 = fb.fix(URIOOf.toURIO()).instance.fix(PureIOOf::narrowK);
     return new URIO<>(PureIO.racePair(executor, instance1, instance2).map(
       either -> either.bimap(a -> a.map2(f -> f.mapK(new FunctionK<>() {
         @Override
-        public <T> URIO<R, T> apply(Kind<Kind<Kind<PureIO_, R>, Void>, ? extends T> from) {
+        public <T> URIO<R, T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, Void>, ? extends T> from) {
           return new URIO<>(from.fix(PureIOOf::narrowK));
         }
       })), b -> b.map1(f -> f.mapK(new FunctionK<>() {
         @Override
-        public <T> URIO<R, T> apply(Kind<Kind<Kind<PureIO_, R>, Void>, ? extends T> from) {
+        public <T> URIO<R, T> apply(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, Void>, ? extends T> from) {
           return new URIO<>(from.fix(PureIOOf::narrowK));
         }
       })))));
@@ -307,7 +307,7 @@ public static <R, A> URIO<R, A> raiseError(Throwable throwable) {
     return new URIO<>(PureIO.fromEither(() -> { throw throwable; }));
   }
 
-  public static <R, A> URIO<R, A> defer(Producer<Kind<Kind<URIO_, R>, ? extends A>> lazy) {
+  public static <R, A> URIO<R, A> defer(Producer<Kind<Kind<URIO<?, ?>, R>, ? extends A>> lazy) {
     return new URIO<>(PureIO.defer(() -> lazy.andThen(URIOOf::narrowK).get().instance));
   }
 
@@ -341,29 +341,29 @@ public static <R, A> URIO<R, A> cancellable(Function2<R, Consumer1<? super Try<?
         (env, cb1) -> consumer.andThen(URIO::<Throwable>toPureIO).apply(env, result -> cb1.accept(result.map(Either::right)))));
   }
 
-  public static <R, A> URIO<R, Sequence<A>> traverse(Sequence<? extends Kind<Kind<URIO_, R>, A>> sequence) {
+  public static <R, A> URIO<R, Sequence<A>> traverse(Sequence<? extends Kind<Kind<URIO<?, ?>, R>, A>> sequence) {
     return traverse(Future.DEFAULT_EXECUTOR, sequence);
   }
 
-  public static <R, A> URIO<R, Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<Kind<URIO_, R>, A>> sequence) {
+  public static <R, A> URIO<R, Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<Kind<URIO<?, ?>, R>, A>> sequence) {
     return sequence.foldLeft(pure(ImmutableList.empty()),
-        (Kind<Kind<URIO_, R>, Sequence<A>> xs, Kind<Kind<URIO_, R>, A> a) -> parMap2(executor, xs, a, Sequence::append));
+        (Kind<Kind<URIO<?, ?>, R>, Sequence<A>> xs, Kind<Kind<URIO<?, ?>, R>, A> a) -> parMap2(executor, xs, a, Sequence::append));
   }
 
   public static <R, A extends AutoCloseable, B> URIO<R, B> bracket(
-    Kind<Kind<URIO_, R>, ? extends A> acquire, Function1<? super A, ? extends Kind<Kind<URIO_, R>, ? extends B>> use) {
+    Kind<Kind<URIO<?, ?>, R>, ? extends A> acquire, Function1<? super A, ? extends Kind<Kind<URIO<?, ?>, R>, ? extends B>> use) {
     return fold(PureIO.bracket(PureIO.redeem(acquire.fix(URIOOf::narrowK).instance),
         resource -> PureIO.redeem(use.andThen(URIOOf::narrowK).apply(resource).instance)));
   }
 
-  public static <R, A, B> URIO<R, B> bracket(Kind<Kind<URIO_, R>, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<Kind<URIO_, R>, ? extends B>> use, Consumer1<? super A> release) {
+  public static <R, A, B> URIO<R, B> bracket(Kind<Kind<URIO<?, ?>, R>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<Kind<URIO<?, ?>, R>, ? extends B>> use, Consumer1<? super A> release) {
     return fold(PureIO.bracket(PureIO.redeem(acquire.fix(URIOOf::narrowK).instance),
         resource -> PureIO.redeem(use.andThen(URIOOf::narrowK).apply(resource).instance), release));
   }
 
-  public static <R, A, B> URIO<R, B> bracket(Kind<Kind<URIO_, R>, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<Kind<URIO_, R>, ? extends B>> use, Function1<? super A, ? extends Kind<Kind<URIO_, R>, Unit>> release) {
+  public static <R, A, B> URIO<R, B> bracket(Kind<Kind<URIO<?, ?>, R>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<Kind<URIO<?, ?>, R>, ? extends B>> use, Function1<? super A, ? extends Kind<Kind<URIO<?, ?>, R>, Unit>> release) {
     return fold(PureIO.bracket(PureIO.redeem(acquire.fix(URIOOf::narrowK).instance),
         resource -> PureIO.redeem(use.andThen(URIOOf::narrowK).apply(resource).instance), release.andThen(URIOOf::narrowK).andThen(URIO::toPureIO)));
   }
diff --git a/free/src/main/java/com/github/tonivade/purefun/free/Cofree.java b/free/src/main/java/com/github/tonivade/purefun/free/Cofree.java
index b4713ad61..7458fef81 100644
--- a/free/src/main/java/com/github/tonivade/purefun/free/Cofree.java
+++ b/free/src/main/java/com/github/tonivade/purefun/free/Cofree.java
@@ -21,7 +21,7 @@
 import com.github.tonivade.purefun.typeclasses.Traverse;
 
 @HigherKind
-public final class Cofree<F, A> implements CofreeOf<F, A>, Mappable<Kind<Cofree_, F>, A> {
+public final class Cofree<F, A> implements CofreeOf<F, A>, Mappable<Kind<Cofree<?, ?>, F>, A> {
 
   private final Functor<F> functor;
   private final A head;
@@ -77,7 +77,7 @@ public Eval<String> reduceToString(Traverse<F> traverse, Operator2<String> join)
   }
 
   public <B> Cofree<F, B> transform(Function1<? super A, ? extends B> headMap, 
-      Function1<? super Cofree<F, ? extends A>, ? extends Kind<Kind<Cofree_, F>, ? extends B>> tailMap) {
+      Function1<? super Cofree<F, ? extends A>, ? extends Kind<Kind<Cofree<?, ?>, F>, ? extends B>> tailMap) {
     return of(functor, transformHead(headMap), transformTail(tailMap));
   }
 
@@ -86,7 +86,7 @@ private <B> B transformHead(Function1<? super A, ? extends B> headMap) {
   }
 
   private <B> Eval<Kind<F, Cofree<F, B>>> transformTail(
-      Function1<? super Cofree<F, ? extends A>, ? extends Kind<Kind<Cofree_, F>, ? extends B>> tailMap) {
+      Function1<? super Cofree<F, ? extends A>, ? extends Kind<Kind<Cofree<?, ?>, F>, ? extends B>> tailMap) {
     return tail.map(t -> functor.map(t, tailMap.andThen(CofreeOf::narrowK)));
   }
 
diff --git a/free/src/main/java/com/github/tonivade/purefun/free/Coyoneda.java b/free/src/main/java/com/github/tonivade/purefun/free/Coyoneda.java
index 129c69fb1..37d82d9be 100644
--- a/free/src/main/java/com/github/tonivade/purefun/free/Coyoneda.java
+++ b/free/src/main/java/com/github/tonivade/purefun/free/Coyoneda.java
@@ -15,7 +15,7 @@
 import com.github.tonivade.purefun.typeclasses.Functor;
 
 @HigherKind
-public final class Coyoneda<F, A, B> implements CoyonedaOf<F, A, B>, Mappable<Kind<Kind<Coyoneda_, F>, A>, B> {
+public final class Coyoneda<F, A, B> implements CoyonedaOf<F, A, B>, Mappable<Kind<Kind<Coyoneda<?, ?, ?>, F>, A>, B> {
 
   private final Kind<F, ? extends A> value;
   private final Function1<? super A, ? extends B> map;
diff --git a/free/src/main/java/com/github/tonivade/purefun/free/Free.java b/free/src/main/java/com/github/tonivade/purefun/free/Free.java
index 5d4ad6c13..25fe07077 100644
--- a/free/src/main/java/com/github/tonivade/purefun/free/Free.java
+++ b/free/src/main/java/com/github/tonivade/purefun/free/Free.java
@@ -21,7 +21,7 @@
 import com.github.tonivade.purefun.typeclasses.Monad;
 
 @HigherKind
-public sealed interface Free<F, A> extends FreeOf<F, A>, Bindable<Kind<Free_, F>, A> {
+public sealed interface Free<F, A> extends FreeOf<F, A>, Bindable<Kind<Free<?, ?>, F>, A> {
 
   static <F, T> Free<F, T> pure(T value) {
     return new Pure<>(value);
@@ -41,11 +41,11 @@ static <F, T> Free<F, T> defer(Producer<? extends Free<F, ? extends T>> value) {
   }
 
   @SuppressWarnings("unchecked")
-  static <F> Monad<Kind<Free_, F>> monadF() {
+  static <F> Monad<Kind<Free<?, ?>, F>> monadF() {
     return FreeMonad.INSTANCE;
   }
 
-  static <F, G> FunctionK<F, Kind<Free_, G>> functionKF(FunctionK<F, G> functionK) {
+  static <F, G> FunctionK<F, Kind<Free<?, ?>, G>> functionKF(FunctionK<F, G> functionK) {
     return new FunctionK<>() {
       @Override
       public <T> Free<G, T> apply(Kind<F, ? extends T> from) {
@@ -60,10 +60,10 @@ default <R> Free<F, R> map(Function1<? super A, ? extends R> map) {
   }
 
   @Override
-  <R> Free<F, R> flatMap(Function1<? super A, ? extends Kind<Kind<Free_, F>, ? extends R>> mapper);
+  <R> Free<F, R> flatMap(Function1<? super A, ? extends Kind<Kind<Free<?, ?>, F>, ? extends R>> mapper);
 
   @Override
-  default <R> Free<F, R> andThen(Kind<Kind<Free_, F>, ? extends R> next) {
+  default <R> Free<F, R> andThen(Kind<Kind<Free<?, ?>, F>, ? extends R> next) {
     return flatMap(ignore -> next);
   }
 
@@ -78,7 +78,7 @@ record Pure<F, A>(A value) implements Free<F, A> {
     }
 
     @Override
-    public <B> Free<F, B> flatMap(Function1<? super A, ? extends Kind<Kind<Free_, F>, ? extends B>> map) {
+    public <B> Free<F, B> flatMap(Function1<? super A, ? extends Kind<Kind<Free<?, ?>, F>, ? extends B>> map) {
       return new FlatMapped<>(this, map);
     }
   }
@@ -90,13 +90,13 @@ record Suspend<F, A>(Kind<F, ? extends A> value) implements Free<F, A> {
     }
 
     @Override
-    public <B> Free<F, B> flatMap(Function1<? super A, ? extends Kind<Kind<Free_, F>, ? extends B>> map) {
+    public <B> Free<F, B> flatMap(Function1<? super A, ? extends Kind<Kind<Free<?, ?>, F>, ? extends B>> map) {
       return new FlatMapped<>(this, map);
     }
   }
 
   record FlatMapped<F, A, B>(Free<F, ? extends A> value,
-      Function1<? super A, ? extends Kind<Kind<Free_, F>, ? extends B>> next) implements Free<F, B> {
+      Function1<? super A, ? extends Kind<Kind<Free<?, ?>, F>, ? extends B>> next) implements Free<F, B> {
 
     public FlatMapped {
       checkNonNull(value);
@@ -104,7 +104,7 @@ record FlatMapped<F, A, B>(Free<F, ? extends A> value,
     }
 
     @Override
-    public <C> Free<F, C> flatMap(Function1<? super B, ? extends Kind<Kind<Free_, F>, ? extends C>> map) {
+    public <C> Free<F, C> flatMap(Function1<? super B, ? extends Kind<Kind<Free<?, ?>, F>, ? extends C>> map) {
       return new FlatMapped<>(value, free -> new FlatMapped<>(next.andThen(FreeOf::<F, B>narrowK).apply(free), map));
     }
 
@@ -124,7 +124,7 @@ private <G> Kind<G, Either<Free<F, A>, A>> foldStep(Monad<G> monad, FunctionK<F,
   }
 }
 
-interface FreeMonad<F> extends Monad<Kind<Free_, F>> {
+interface FreeMonad<F> extends Monad<Kind<Free<?, ?>, F>> {
 
   @SuppressWarnings("rawtypes")
   FreeMonad INSTANCE = new FreeMonad() {};
@@ -136,7 +136,7 @@ default <T> Free<F, T> pure(T value) {
 
   @Override
   default <T, R> Free<F, R> flatMap(
-      Kind<Kind<Free_, F>, ? extends T> value, Function1<? super T, ? extends Kind<Kind<Free_, F>, ? extends R>> map) {
+      Kind<Kind<Free<?, ?>, F>, ? extends T> value, Function1<? super T, ? extends Kind<Kind<Free<?, ?>, F>, ? extends R>> map) {
     return value.fix(toFree()).flatMap(map.andThen(FreeOf::narrowK));
   }
 }
diff --git a/free/src/main/java/com/github/tonivade/purefun/free/FreeAp.java b/free/src/main/java/com/github/tonivade/purefun/free/FreeAp.java
index e857587f1..4f21dc9a0 100644
--- a/free/src/main/java/com/github/tonivade/purefun/free/FreeAp.java
+++ b/free/src/main/java/com/github/tonivade/purefun/free/FreeAp.java
@@ -17,12 +17,12 @@
 
 import com.github.tonivade.purefun.core.Applicable;
 import com.github.tonivade.purefun.core.Function1;
-import com.github.tonivade.purefun.type.Const_;
+import com.github.tonivade.purefun.type.Const;
 import com.github.tonivade.purefun.typeclasses.Applicative;
 import com.github.tonivade.purefun.typeclasses.FunctionK;
 
 @HigherKind
-public sealed interface FreeAp<F, A> extends FreeApOf<F, A>, Applicable<Kind<FreeAp_, F>, A> {
+public sealed interface FreeAp<F, A> extends FreeApOf<F, A>, Applicable<Kind<FreeAp<?, ?>, F>, A> {
 
   @Override
   default <B> FreeAp<F, B> map(Function1<? super A, ? extends B> mapper) {
@@ -34,7 +34,7 @@ default <B> FreeAp<F, B> map(Function1<? super A, ? extends B> mapper) {
   }
 
   @Override
-  default <B> FreeAp<F, B> ap(Kind<Kind<FreeAp_, F>, ? extends Function1<? super A, ? extends B>> apply) {
+  default <B> FreeAp<F, B> ap(Kind<Kind<FreeAp<?, ?>, F>, ? extends Function1<? super A, ? extends B>> apply) {
     if (apply instanceof Pure<F, ? extends Function1<? super A, ? extends B>> pure) {
       return map(pure.value);
     }
@@ -50,11 +50,11 @@ default <G> FreeAp<G, A> compile(FunctionK<F, G> transformer) {
   }
 
   default <G> FreeAp<G, A> flatCompile(
-      FunctionK<F, Kind<FreeAp_, G>> functionK, Applicative<Kind<FreeAp_, G>> applicative) {
+      FunctionK<F, Kind<FreeAp<?, ?>, G>> functionK, Applicative<Kind<FreeAp<?, ?>, G>> applicative) {
     return foldMap(functionK, applicative).fix(toFreeAp());
   }
 
-  default <M> M analyze(FunctionK<F, Kind<Const_, M>> functionK, Applicative<Kind<Const_, M>> applicative) {
+  default <M> M analyze(FunctionK<F, Kind<Const<?, ?>, M>> functionK, Applicative<Kind<Const<?, ?>, M>> applicative) {
     return foldMap(functionK, applicative).fix(toConst()).value();
   }
 
@@ -123,12 +123,12 @@ static <F, T> FreeAp<F, T> lift(Kind<F, T> value) {
     return new Lift<>(value);
   }
 
-  static <F, T, R> FreeAp<F, R> apply(Kind<Kind<FreeAp_, F>, ? extends T> value,
-      Kind<Kind<FreeAp_, F>, ? extends Function1<? super T, ? extends R>> mapper) {
+  static <F, T, R> FreeAp<F, R> apply(Kind<Kind<FreeAp<?, ?>, F>, ? extends T> value,
+      Kind<Kind<FreeAp<?, ?>, F>, ? extends Function1<? super T, ? extends R>> mapper) {
     return new Apply<>(value.fix(toFreeAp()), mapper.fix(toFreeAp()));
   }
 
-  static <F, G> FunctionK<F, Kind<FreeAp_, G>> functionKF(FunctionK<F, G> functionK) {
+  static <F, G> FunctionK<F, Kind<FreeAp<?, ?>, G>> functionKF(FunctionK<F, G> functionK) {
     return new FunctionK<>() {
       @Override
       public <T> FreeAp<G, T> apply(Kind<F, ? extends T> from) {
@@ -138,7 +138,7 @@ public <T> FreeAp<G, T> apply(Kind<F, ? extends T> from) {
   }
 
   @SuppressWarnings("unchecked")
-  static <F> Applicative<Kind<FreeAp_, F>> applicativeF() {
+  static <F> Applicative<Kind<FreeAp<?, ?>, F>> applicativeF() {
     return FreeApplicative.INSTANCE;
   }
 
@@ -200,7 +200,7 @@ record CurriedFunction<G, A, B>(Kind<G, Function1<A, B>> value, int remaining) {
   }
 }
 
-interface FreeApplicative<F> extends Applicative<Kind<FreeAp_, F>> {
+interface FreeApplicative<F> extends Applicative<Kind<FreeAp<?, ?>, F>> {
 
   @SuppressWarnings("rawtypes")
   FreeApplicative INSTANCE = new FreeApplicative() {};
@@ -212,8 +212,8 @@ default <T> FreeAp<F, T> pure(T value) {
 
   @Override
   default <T, R> FreeAp<F, R> ap(
-      Kind<Kind<FreeAp_, F>, ? extends T> value,
-      Kind<Kind<FreeAp_, F>, ? extends Function1<? super T, ? extends R>> apply) {
+      Kind<Kind<FreeAp<?, ?>, F>, ? extends T> value,
+      Kind<Kind<FreeAp<?, ?>, F>, ? extends Function1<? super T, ? extends R>> apply) {
     return FreeAp.apply(value, apply);
   }
 }
diff --git a/free/src/main/java/com/github/tonivade/purefun/free/Trampoline.java b/free/src/main/java/com/github/tonivade/purefun/free/Trampoline.java
index 26fe11f7a..1dfee12a4 100644
--- a/free/src/main/java/com/github/tonivade/purefun/free/Trampoline.java
+++ b/free/src/main/java/com/github/tonivade/purefun/free/Trampoline.java
@@ -18,7 +18,7 @@
 import com.github.tonivade.purefun.type.Either;
 
 @HigherKind
-public sealed interface Trampoline<T> extends TrampolineOf<T>, Bindable<Trampoline_, T> {
+public sealed interface Trampoline<T> extends TrampolineOf<T>, Bindable<Trampoline<?>, T> {
 
   @Override
   default <R> Trampoline<R> map(Function1<? super T, ? extends R> map) {
@@ -28,7 +28,7 @@ default <R> Trampoline<R> map(Function1<? super T, ? extends R> map) {
   }
 
   @Override
-  default <R> Trampoline<R> flatMap(Function1<? super T, ? extends Kind<Trampoline_, ? extends R>> map) {
+  default <R> Trampoline<R> flatMap(Function1<? super T, ? extends Kind<Trampoline<?>, ? extends R>> map) {
     return resume().fold(
         next -> more(() -> next.flatMap(map)),
         map.andThen(TrampolineOf::narrowK));
diff --git a/free/src/main/java/com/github/tonivade/purefun/free/Yoneda.java b/free/src/main/java/com/github/tonivade/purefun/free/Yoneda.java
index e85fc0d59..a19bfe569 100644
--- a/free/src/main/java/com/github/tonivade/purefun/free/Yoneda.java
+++ b/free/src/main/java/com/github/tonivade/purefun/free/Yoneda.java
@@ -15,7 +15,7 @@
 import com.github.tonivade.purefun.typeclasses.Functor;
 
 @HigherKind
-public sealed interface Yoneda<F, A> extends YonedaOf<F, A>, Mappable<Kind<Yoneda_, F>, A> {
+public sealed interface Yoneda<F, A> extends YonedaOf<F, A>, Mappable<Kind<Yoneda<?, ?>, F>, A> {
 
   <B> Kind<F, B> apply(Function1<? super A, ? extends B> map);
 
diff --git a/free/src/test/java/com/github/tonivade/purefun/free/CofreeTest.java b/free/src/test/java/com/github/tonivade/purefun/free/CofreeTest.java
index 06c2738c4..9594c2c43 100644
--- a/free/src/test/java/com/github/tonivade/purefun/free/CofreeTest.java
+++ b/free/src/test/java/com/github/tonivade/purefun/free/CofreeTest.java
@@ -25,9 +25,7 @@
 import com.github.tonivade.purefun.instances.OptionInstances;
 import com.github.tonivade.purefun.type.Eval;
 import com.github.tonivade.purefun.type.Id;
-import com.github.tonivade.purefun.type.Id_;
 import com.github.tonivade.purefun.type.Option;
-import com.github.tonivade.purefun.type.Option_;
 import com.github.tonivade.purefun.typeclasses.For;
 
 @ExtendWith(MockitoExtension.class)
@@ -35,9 +33,9 @@ public class CofreeTest {
 
   @Test
   public void testMap() {
-    Cofree<Id_, Integer> cofree = Cofree.unfold(IdInstances.functor(), 0, a -> Id.of(a + 1)).map(x -> x * 2);
+    Cofree<Id<?>, Integer> cofree = Cofree.unfold(IdInstances.functor(), 0, a -> Id.of(a + 1)).map(x -> x * 2);
 
-    Id<Tuple4<Cofree<Id_, Integer>, Cofree<Id_, Integer>, Cofree<Id_, Integer>, Cofree<Id_, Integer>>> tuple4Id =
+    Id<Tuple4<Cofree<Id<?>, Integer>, Cofree<Id<?>, Integer>, Cofree<Id<?>, Integer>, Cofree<Id<?>, Integer>>> tuple4Id =
         For.with(IdInstances.monad())
           .then(cofree.tailForced())
           .flatMap(Cofree::tailForced)
@@ -50,7 +48,7 @@ public void testMap() {
 
   @Test
   public void testFold() {
-    Cofree<Option_, Integer> cofree = Cofree.unfold(OptionInstances.functor(), 0,
+    Cofree<Option<?>, Integer> cofree = Cofree.unfold(OptionInstances.functor(), 0,
         a -> (a > 100) ? Option.<Integer>none() : Option.some(a + 1));
 
     assertEquals(5151,
@@ -63,7 +61,7 @@ public void testRun(@Mock Operator1<Integer> plus1) {
     when(plus1.apply(anyInt()))
         .thenReturn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 
-    Cofree<Option_, Integer> cofree = Cofree.unfold(OptionInstances.functor(), 0,
+    Cofree<Option<?>, Integer> cofree = Cofree.unfold(OptionInstances.functor(), 0,
         a -> (a < 10) ? Option.some(plus1.apply(a)) : Option.<Integer>none());
 
     verify(plus1, never()).apply(anyInt()); // nothing executed
diff --git a/free/src/test/java/com/github/tonivade/purefun/free/CoyonedaTest.java b/free/src/test/java/com/github/tonivade/purefun/free/CoyonedaTest.java
index 1eb22e44a..9d187b0cd 100644
--- a/free/src/test/java/com/github/tonivade/purefun/free/CoyonedaTest.java
+++ b/free/src/test/java/com/github/tonivade/purefun/free/CoyonedaTest.java
@@ -12,17 +12,16 @@
 
 import com.github.tonivade.purefun.core.Operator1;
 import com.github.tonivade.purefun.type.Option;
-import com.github.tonivade.purefun.type.Option_;
 
 public class CoyonedaTest {
-  
+
   private final Operator1<String> concat = string -> string.concat(string);
 
   @Test
   public void coyoneda() {
-    Coyoneda<Option_, String, String> coyoneda = Coyoneda.of(Option.some("string"), identity());
+    Coyoneda<Option<?>, String, String> coyoneda = Coyoneda.of(Option.some("string"), identity());
 
-    Coyoneda<Option_, String, String> result = coyoneda.map(concat).map(concat);
+    Coyoneda<Option<?>, String, String> result = coyoneda.map(concat).map(concat);
 
     assertEquals(Option.some("stringstringstringstring"), result.run(functor()));
   }
diff --git a/free/src/test/java/com/github/tonivade/purefun/free/EitherKTest.java b/free/src/test/java/com/github/tonivade/purefun/free/EitherKTest.java
index 0e719931d..aa0a5fb0d 100644
--- a/free/src/test/java/com/github/tonivade/purefun/free/EitherKTest.java
+++ b/free/src/test/java/com/github/tonivade/purefun/free/EitherKTest.java
@@ -13,26 +13,22 @@
 import org.junit.jupiter.api.Test;
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.core.Producer;
-import com.github.tonivade.purefun.core.Producer_;
 import com.github.tonivade.purefun.instances.IdInstances;
 import com.github.tonivade.purefun.instances.OptionInstances;
 import com.github.tonivade.purefun.instances.ProducerInstances;
 import com.github.tonivade.purefun.instances.TryInstances;
 import com.github.tonivade.purefun.type.Id;
-import com.github.tonivade.purefun.type.Id_;
 import com.github.tonivade.purefun.type.Option;
 import com.github.tonivade.purefun.type.OptionOf;
-import com.github.tonivade.purefun.type.Option_;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.type.TryOf;
-import com.github.tonivade.purefun.type.Try_;
 import com.github.tonivade.purefun.typeclasses.FunctionK;
 
 class EitherKTest {
 
   @Test
   public void left() {
-    EitherK<Option_, Try_, String> left = EitherK.left(Option.some("hello"));
+    EitherK<Option<?>, Try<?>, String> left = EitherK.left(Option.some("hello"));
 
     assertAll(
         () -> assertTrue(left.isLeft()),
@@ -44,7 +40,7 @@ public void left() {
 
   @Test
   public void right() {
-    EitherK<Option_, Try_, String> right = EitherK.right(Try.success("hello"));
+    EitherK<Option<?>, Try<?>, String> right = EitherK.right(Try.success("hello"));
 
     assertAll(
         () -> assertFalse(right.isLeft()),
@@ -56,8 +52,8 @@ public void right() {
 
   @Test
   public void extract() {
-    EitherK<Id_, Producer_, String> left = EitherK.left(Id.of("hola"));
-    EitherK<Id_, Producer_, String> right = EitherK.right(Producer.cons("hola"));
+    EitherK<Id<?>, Producer<?>, String> left = EitherK.left(Id.of("hola"));
+    EitherK<Id<?>, Producer<?>, String> right = EitherK.right(Producer.cons("hola"));
 
     assertAll(
         () -> assertEquals("hola", left.extract(IdInstances.comonad(), ProducerInstances.comonad())),
@@ -67,7 +63,7 @@ public void extract() {
 
   @Test
   public void coflatMap() {
-    EitherK<Id_, Producer_, String> left = EitherK.left(Id.of("hola"));
+    EitherK<Id<?>, Producer<?>, String> left = EitherK.left(Id.of("hola"));
 
     assertAll(
         () -> assertEquals(
@@ -81,29 +77,29 @@ public void coflatMap() {
 
   @Test
   public void mapLeft() {
-    EitherK<Option_, Try_, String> eitherK = EitherK.left(Option.some("hello"));
+    EitherK<Option<?>, Try<?>, String> eitherK = EitherK.left(Option.some("hello"));
 
-    EitherK<Option_, Try_, Integer> result = eitherK.map(OptionInstances.functor(), TryInstances.functor(), String::length);
+    EitherK<Option<?>, Try<?>, Integer> result = eitherK.map(OptionInstances.functor(), TryInstances.functor(), String::length);
 
     assertEquals(Option.some(5), result.getLeft());
   }
 
   @Test
   public void mapRight() {
-    EitherK<Option_, Try_, String> eitherK = EitherK.right(Try.success("hello"));
+    EitherK<Option<?>, Try<?>, String> eitherK = EitherK.right(Try.success("hello"));
 
-    EitherK<Option_, Try_, Integer> result = eitherK.map(OptionInstances.functor(), TryInstances.functor(), String::length);
+    EitherK<Option<?>, Try<?>, Integer> result = eitherK.map(OptionInstances.functor(), TryInstances.functor(), String::length);
 
     assertEquals(Try.success(5), result.getRight());
   }
 
   @Test
   public void mapK() {
-    EitherK<Option_, Try_, String> eitherK = EitherK.right(Try.success("hello"));
+    EitherK<Option<?>, Try<?>, String> eitherK = EitherK.right(Try.success("hello"));
 
-    EitherK<Option_, Option_, String> result = eitherK.mapK(new FunctionK<>() {
+    EitherK<Option<?>, Option<?>, String> result = eitherK.mapK(new FunctionK<>() {
       @Override
-      public <T> Option<T> apply(Kind<Try_, ? extends T> from) {
+      public <T> Option<T> apply(Kind<Try<?>, ? extends T> from) {
         return from.fix(TryOf::<T>narrowK).toOption();
       }
     });
@@ -113,11 +109,11 @@ public <T> Option<T> apply(Kind<Try_, ? extends T> from) {
 
   @Test
   public void mapLeftK() {
-    EitherK<Option_, Try_, String> eitherK = EitherK.left(Option.some("hello"));
+    EitherK<Option<?>, Try<?>, String> eitherK = EitherK.left(Option.some("hello"));
 
-    EitherK<Try_, Try_, String> result = eitherK.mapLeftK(new FunctionK<>() {
+    EitherK<Try<?>, Try<?>, String> result = eitherK.mapLeftK(new FunctionK<>() {
       @Override
-      public <T> Try<T> apply(Kind<Option_, ? extends T> from) {
+      public <T> Try<T> apply(Kind<Option<?>, ? extends T> from) {
         return from.fix(OptionOf::<T>narrowK).fold(Try::failure, Try::success);
       }
     });
@@ -127,8 +123,8 @@ public <T> Try<T> apply(Kind<Option_, ? extends T> from) {
 
   @Test
   public void swap() {
-    EitherK<Option_, Try_, String> original = EitherK.left(Option.some("hello"));
-    EitherK<Try_, Option_, String> expected = EitherK.right(Option.some("hello"));
+    EitherK<Option<?>, Try<?>, String> original = EitherK.left(Option.some("hello"));
+    EitherK<Try<?>, Option<?>, String> expected = EitherK.right(Option.some("hello"));
 
     assertAll(
         () -> assertEquals(expected, original.swap()),
diff --git a/free/src/test/java/com/github/tonivade/purefun/free/FreeAlgTest.java b/free/src/test/java/com/github/tonivade/purefun/free/FreeAlgTest.java
index 7fefd7ae0..c3851296d 100644
--- a/free/src/test/java/com/github/tonivade/purefun/free/FreeAlgTest.java
+++ b/free/src/test/java/com/github/tonivade/purefun/free/FreeAlgTest.java
@@ -15,22 +15,22 @@
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.core.Unit;
 import com.github.tonivade.purefun.instances.IOInstances;
-import com.github.tonivade.purefun.monad.IO_;
+import com.github.tonivade.purefun.monad.IO;
 import com.github.tonivade.purefun.runtimes.ConsoleExecutor;
 import com.github.tonivade.purefun.typeclasses.Console;
 import com.github.tonivade.purefun.typeclasses.FunctionK;
 
 public class FreeAlgTest {
 
-  private static Free<Kind<Kind<EitherK_, ConsoleAlg_>, EmailAlg_>, String> read() {
+  private static Free<Kind<Kind<EitherK<?, ?, ?>, ConsoleAlg<?>>, EmailAlg<?>>, String> read() {
     return Free.inject(injectEitherKLeft(), new ConsoleAlg.ReadLine());
   }
 
-  private static Free<Kind<Kind<EitherK_, ConsoleAlg_>, EmailAlg_>, Unit> write(String value) {
+  private static Free<Kind<Kind<EitherK<?, ?, ?>, ConsoleAlg<?>>, EmailAlg<?>>, Unit> write(String value) {
     return Free.inject(injectEitherKLeft(), new ConsoleAlg.WriteLine(value));
   }
 
-  private static Free<Kind<Kind<EitherK_, ConsoleAlg_>, EmailAlg_>, Unit> send(String to, String content) {
+  private static Free<Kind<Kind<EitherK<?, ?, ?>, ConsoleAlg<?>>, EmailAlg<?>>, Unit> send(String to, String content) {
     return Free.inject(injectEitherKRight(injectReflexive()), new EmailAlg.SendEmail(to, content));
   }
 
@@ -48,31 +48,31 @@ public void algebra() {
   }
 
   @SuppressWarnings("unchecked")
-  private static FunctionK<Kind<Kind<EitherK_, ConsoleAlg_>, EmailAlg_>, IO_> interpreter() {
-    final Console<IO_> console = IOInstances.console();
+  private static FunctionK<Kind<Kind<EitherK<?, ?, ?>, ConsoleAlg<?>>, EmailAlg<?>>, IO<?>> interpreter() {
+    final Console<IO<?>> console = IOInstances.console();
     return new FunctionK<>() {
       @Override
-      public <T> Kind<IO_, T> apply(Kind<Kind<Kind<EitherK_, ConsoleAlg_>, EmailAlg_>, ? extends T> from) {
-        return from.fix(EitherKOf::<ConsoleAlg_, EmailAlg_, T>narrowK).foldK(
+      public <T> Kind<IO<?>, T> apply(Kind<Kind<Kind<EitherK<?, ?, ?>, ConsoleAlg<?>>, EmailAlg<?>>, ? extends T> from) {
+        return from.fix(EitherKOf::<ConsoleAlg<?>, EmailAlg<?>, T>narrowK).foldK(
           new FunctionK<>() {
             @Override
-            public <X> Kind<IO_, X> apply(Kind<ConsoleAlg_, ? extends X> kind) {
+            public <X> Kind<IO<?>, X> apply(Kind<ConsoleAlg<?>, ? extends X> kind) {
               ConsoleAlg<X> consoleAlg = kind.fix(ConsoleAlgOf::narrowK);
               if (consoleAlg instanceof ConsoleAlg.ReadLine) {
-                return (Kind<IO_, X>) console.readln();
+                return (Kind<IO<?>, X>) console.readln();
               }
               if (consoleAlg instanceof ConsoleAlg.WriteLine writeLine) {
-                return (Kind<IO_, X>) console.println(writeLine.line());
+                return (Kind<IO<?>, X>) console.println(writeLine.line());
               }
               throw new IllegalStateException();
             }
           },
             new FunctionK<>() {
               @Override
-              public <X> Kind<IO_, X> apply(Kind<EmailAlg_, ? extends X> kind) {
+              public <X> Kind<IO<?>, X> apply(Kind<EmailAlg<?>, ? extends X> kind) {
                 EmailAlg<X> emailAlg = kind.fix(EmailAlgOf::narrowK);
                 if (emailAlg instanceof EmailAlg.SendEmail sendEmail) {
-                  return (Kind<IO_, X>) console.println(
+                  return (Kind<IO<?>, X>) console.println(
                       "email to " + sendEmail.to() + " with content " + sendEmail.content());
                 }
                 throw new IllegalStateException();
diff --git a/free/src/test/java/com/github/tonivade/purefun/free/FreeApTest.java b/free/src/test/java/com/github/tonivade/purefun/free/FreeApTest.java
index 592d0d61a..60eb2d331 100644
--- a/free/src/test/java/com/github/tonivade/purefun/free/FreeApTest.java
+++ b/free/src/test/java/com/github/tonivade/purefun/free/FreeApTest.java
@@ -20,20 +20,18 @@
 import com.github.tonivade.purefun.instances.ConstInstances;
 import com.github.tonivade.purefun.instances.IdInstances;
 import com.github.tonivade.purefun.type.Const;
-import com.github.tonivade.purefun.type.Const_;
 import com.github.tonivade.purefun.type.Id;
-import com.github.tonivade.purefun.type.Id_;
 import com.github.tonivade.purefun.typeclasses.Applicative;
 import com.github.tonivade.purefun.typeclasses.FunctionK;
 import com.github.tonivade.purefun.typeclasses.Monoid;
 
 public class FreeApTest {
 
-  private final Applicative<Kind<FreeAp_, DSL_>> applicative = FreeAp.applicativeF();
+  private final Applicative<Kind<FreeAp<?, ?>, DSL<?>>> applicative = FreeAp.applicativeF();
 
   @Test
   public void map() {
-    FreeAp<DSL_, Integer> map = applicative.map(DSL.readInt(4), i -> i + 1).fix(toFreeAp());
+    FreeAp<DSL<?>, Integer> map = applicative.map(DSL.readInt(4), i -> i + 1).fix(toFreeAp());
 
     Id<Integer> foldMap = map.foldMap(idTransform(), IdInstances.applicative()).fix(toId());
 
@@ -42,8 +40,8 @@ public void map() {
 
   @Test
   public void ap() {
-    FreeAp<DSL_, Integer> freeAp = FreeAp.lift(new ReadInt(123));
-    FreeAp<DSL_, Function1<? super Integer, ? extends String>> apply = FreeAp.pure(Object::toString);
+    FreeAp<DSL<?>, Integer> freeAp = FreeAp.lift(new ReadInt(123));
+    FreeAp<DSL<?>, Function1<? super Integer, ? extends String>> apply = FreeAp.pure(Object::toString);
 
     Id<Integer> foldMap = freeAp.ap(apply)
         .map(String::length)
@@ -54,7 +52,7 @@ public void ap() {
 
   @Test
   public void lift() {
-    FreeAp<DSL_, Tuple5<Integer, Boolean, Double, String, Unit>> tuple =
+    FreeAp<DSL<?>, Tuple5<Integer, Boolean, Double, String, Unit>> tuple =
         applicative.mapN(
             DSL.readInt(2),
             DSL.readBoolean(false),
@@ -64,14 +62,14 @@ public void lift() {
             Tuple::of
         ).fix(toFreeAp());
 
-    Kind<Id_, Tuple5<Integer, Boolean, Double, String, Unit>> map =
+    Kind<Id<?>, Tuple5<Integer, Boolean, Double, String, Unit>> map =
         tuple.foldMap(idTransform(), IdInstances.applicative());
 
     assertEquals(Id.of(Tuple.of(2, false, 2.1, "hola mundo", unit())), map.fix(toId()));
   }
   @Test
   public void pure() {
-    FreeAp<DSL_, Tuple5<Integer, String, Double, Boolean, Unit>> tuple =
+    FreeAp<DSL<?>, Tuple5<Integer, String, Double, Boolean, Unit>> tuple =
         applicative.mapN(
             applicative.pure(1),
             applicative.pure("string"),
@@ -81,7 +79,7 @@ public void pure() {
             Tuple::of
         ).fix(toFreeAp());
 
-    Kind<Id_, Tuple5<Integer, String, Double, Boolean, Unit>> map =
+    Kind<Id<?>, Tuple5<Integer, String, Double, Boolean, Unit>> map =
         tuple.foldMap(idTransform(), IdInstances.applicative());
 
     assertEquals(Id.of(Tuple.of(1, "string", 1.1, true, unit())), map.fix(toId()));
@@ -89,9 +87,9 @@ public void pure() {
 
   @Test
   public void compile() {
-    FreeAp<DSL_, Integer> readInt = FreeAp.pure(5);
+    FreeAp<DSL<?>, Integer> readInt = FreeAp.pure(5);
 
-    FreeAp<Id_, Integer> compile = readInt.compile(idTransform());
+    FreeAp<Id<?>, Integer> compile = readInt.compile(idTransform());
     Id<Integer> fold = compile.fold(IdInstances.applicative()).fix(toId());
 
     assertEquals(5, fold.value());
@@ -99,7 +97,7 @@ public void compile() {
 
   @Test
   public void analyze() {
-    FreeAp<DSL_, Tuple5<Integer, Boolean, Double, String, Unit>> tuple =
+    FreeAp<DSL<?>, Tuple5<Integer, Boolean, Double, String, Unit>> tuple =
         applicative.mapN(
             DSL.readInt(2),
             DSL.readBoolean(false),
@@ -120,19 +118,19 @@ public void analyze() {
         """, analize);
   }
 
-  private FunctionK<DSL_, Id_> idTransform() {
+  private FunctionK<DSL<?>, Id<?>> idTransform() {
     return new FunctionK<>() {
       @Override
-      public <T> Kind<Id_, T> apply(Kind<DSL_, ? extends T> from) {
+      public <T> Kind<Id<?>, T> apply(Kind<DSL<?>, ? extends T> from) {
         return Id.of(from.fix(DSLOf::<T>narrowK).value());
       }
     };
   }
 
-  private FunctionK<DSL_, Kind<Const_, String>> constTransform() {
+  private FunctionK<DSL<?>, Kind<Const<?, ?>, String>> constTransform() {
     return new FunctionK<>() {
       @Override
-      public <T> Const<String, T> apply(Kind<DSL_, ? extends T> from) {
+      public <T> Const<String, T> apply(Kind<DSL<?>, ? extends T> from) {
         DSL<T> dsl = from.fix(DSLOf::narrowK);
         return Const.of(dsl.getClass().getSimpleName() + "(" + dsl.value() + ")\n");
       }
@@ -145,23 +143,23 @@ sealed interface DSL<A> extends DSLOf<A> {
 
   A value();
 
-  static FreeAp<DSL_, Integer> readInt(int value) {
+  static FreeAp<DSL<?>, Integer> readInt(int value) {
     return FreeAp.lift(new ReadInt(value));
   }
 
-  static FreeAp<DSL_, String> readString(String value) {
+  static FreeAp<DSL<?>, String> readString(String value) {
     return FreeAp.lift(new ReadString(value));
   }
 
-  static FreeAp<DSL_, Boolean> readBoolean(boolean value) {
+  static FreeAp<DSL<?>, Boolean> readBoolean(boolean value) {
     return FreeAp.lift(new ReadBoolean(value));
   }
 
-  static FreeAp<DSL_, Double> readDouble(double value) {
+  static FreeAp<DSL<?>, Double> readDouble(double value) {
     return FreeAp.lift(new ReadDouble(value));
   }
 
-  static FreeAp<DSL_, Unit> readUnit() {
+  static FreeAp<DSL<?>, Unit> readUnit() {
     return FreeAp.lift(new ReadUnit());
   }
 }
diff --git a/free/src/test/java/com/github/tonivade/purefun/free/FreeTest.java b/free/src/test/java/com/github/tonivade/purefun/free/FreeTest.java
index 8e4e76376..f79ce54d4 100644
--- a/free/src/test/java/com/github/tonivade/purefun/free/FreeTest.java
+++ b/free/src/test/java/com/github/tonivade/purefun/free/FreeTest.java
@@ -13,7 +13,7 @@
 import com.github.tonivade.purefun.core.Unit;
 import com.github.tonivade.purefun.data.ImmutableList;
 import com.github.tonivade.purefun.instances.StateInstances;
-import com.github.tonivade.purefun.monad.IO_;
+import com.github.tonivade.purefun.monad.IO;
 import com.github.tonivade.purefun.monad.State;
 import com.github.tonivade.purefun.monad.StateOf;
 import com.github.tonivade.purefun.runtimes.ConsoleExecutor;
@@ -21,7 +21,7 @@
 
 public class FreeTest {
 
-  private final Free<IOProgram_, Unit> echo =
+  private final Free<IOProgram<?>, Unit> echo =
       IOProgram.write("what's your name?")
         .andThen(IOProgram.read())
         .flatMap(text -> IOProgram.write("Hello " + text))
@@ -40,7 +40,7 @@ public void interpretState() {
 
   @Test
   public void interpretIO() {
-    var foldMap = echo.foldMap(Instances.<IO_>monad(), new IOProgramToIO());
+    var foldMap = echo.foldMap(Instances.<IO<?>>monad(), new IOProgramToIO());
 
     var executor = new ConsoleExecutor().read("Toni");
 
diff --git a/free/src/test/java/com/github/tonivade/purefun/free/IOProgram.java b/free/src/test/java/com/github/tonivade/purefun/free/IOProgram.java
index 865eb94dc..1c9f79b13 100644
--- a/free/src/test/java/com/github/tonivade/purefun/free/IOProgram.java
+++ b/free/src/test/java/com/github/tonivade/purefun/free/IOProgram.java
@@ -15,20 +15,18 @@
 import com.github.tonivade.purefun.instances.IOInstances;
 import com.github.tonivade.purefun.instances.StateInstances;
 import com.github.tonivade.purefun.monad.IO;
-import com.github.tonivade.purefun.monad.IO_;
 import com.github.tonivade.purefun.monad.State;
-import com.github.tonivade.purefun.monad.State_;
 import com.github.tonivade.purefun.typeclasses.Console;
 import com.github.tonivade.purefun.typeclasses.FunctionK;
 
 @HigherKind
 public sealed interface IOProgram<T> extends IOProgramOf<T> {
 
-  static Free<IOProgram_, String> read() {
+  static Free<IOProgram<?>, String> read() {
     return liftF(new IOProgram.Read());
   }
 
-  static Free<IOProgram_, Unit> write(String value) {
+  static Free<IOProgram<?>, Unit> write(String value) {
     return liftF(new IOProgram.Write(value));
   }
 
@@ -45,12 +43,12 @@ record Write(String value) implements IOProgram<Unit> {
 }
 
 @SuppressWarnings("unchecked")
-class IOProgramToState implements FunctionK<IOProgram_, Kind<State_, ImmutableList<String>>> {
+class IOProgramToState implements FunctionK<IOProgram<?>, Kind<State<?, ?>, ImmutableList<String>>> {
 
-  private final Console<Kind<State_, ImmutableList<String>>> console = StateInstances.console();
+  private final Console<Kind<State<?, ?>, ImmutableList<String>>> console = StateInstances.console();
 
   @Override
-  public <X> Kind<Kind<State_, ImmutableList<String>>, X> apply(Kind<IOProgram_, ? extends X> from) {
+  public <X> Kind<Kind<State<?, ?>, ImmutableList<String>>, X> apply(Kind<IOProgram<?>, ? extends X> from) {
     return switch (from.fix(toIOProgram())) {
       case IOProgram.Read() -> (State<ImmutableList<String>, X>) console.readln();
       case IOProgram.Write(var value) -> (State<ImmutableList<String>, X>) console.println(value);
@@ -59,12 +57,12 @@ public <X> Kind<Kind<State_, ImmutableList<String>>, X> apply(Kind<IOProgram_, ?
 }
 
 @SuppressWarnings("unchecked")
-class IOProgramToIO implements FunctionK<IOProgram_, IO_> {
+class IOProgramToIO implements FunctionK<IOProgram<?>, IO<?>> {
 
-  private final Console<IO_> console = IOInstances.console();
+  private final Console<IO<?>> console = IOInstances.console();
 
   @Override
-  public <X> Kind<IO_, X> apply(Kind<IOProgram_, ? extends X> from) {
+  public <X> Kind<IO<?>, X> apply(Kind<IOProgram<?>, ? extends X> from) {
     return switch (from.fix(toIOProgram())) {
       case IOProgram.Read() -> (IO<X>) console.readln();
       case IOProgram.Write(var value) -> (IO<X>) console.println(value);
diff --git a/free/src/test/java/com/github/tonivade/purefun/free/YonedaTest.java b/free/src/test/java/com/github/tonivade/purefun/free/YonedaTest.java
index 9434685d9..36038b627 100644
--- a/free/src/test/java/com/github/tonivade/purefun/free/YonedaTest.java
+++ b/free/src/test/java/com/github/tonivade/purefun/free/YonedaTest.java
@@ -12,7 +12,6 @@
 
 import com.github.tonivade.purefun.core.Operator1;
 import com.github.tonivade.purefun.type.Option;
-import com.github.tonivade.purefun.type.Option_;
 
 public class YonedaTest {
 
@@ -20,9 +19,9 @@ public class YonedaTest {
 
   @Test
   public void yoneda() {
-    Yoneda<Option_, String> yoneda = Yoneda.of(some("string"), functor());
+    Yoneda<Option<?>, String> yoneda = Yoneda.of(some("string"), functor());
 
-    Yoneda<Option_, String> result = yoneda.map(concat).map(concat);
+    Yoneda<Option<?>, String> result = yoneda.map(concat).map(concat);
 
     assertEquals(Option.some("stringstringstringstring"), result.lower());
   }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/CofreeInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/CofreeInstances.java
index ab790fbe1..ff0982ab6 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/CofreeInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/CofreeInstances.java
@@ -9,46 +9,45 @@
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.free.Cofree;
 import com.github.tonivade.purefun.free.CofreeOf;
-import com.github.tonivade.purefun.free.Cofree_;
 import com.github.tonivade.purefun.typeclasses.Comonad;
 import com.github.tonivade.purefun.typeclasses.Functor;
 
 @SuppressWarnings("unchecked")
 public interface CofreeInstances {
 
-  static <F> Functor<Kind<Cofree_, F>> functor() {
+  static <F> Functor<Kind<Cofree<?, ?>, F>> functor() {
     return CofreeFunctor.INSTANCE;
   }
 
-  static <F> Comonad<Kind<Cofree_, F>> comonad() {
+  static <F> Comonad<Kind<Cofree<?, ?>, F>> comonad() {
     return CofreeComonad.INSTANCE;
   }
 }
 
-interface CofreeFunctor<F> extends Functor<Kind<Cofree_, F>> {
+interface CofreeFunctor<F> extends Functor<Kind<Cofree<?, ?>, F>> {
 
   @SuppressWarnings("rawtypes")
   CofreeFunctor INSTANCE = new CofreeFunctor() {};
 
   @Override
-  default <T, R> Cofree<F, R> map(Kind<Kind<Cofree_, F>, ? extends T> value, Function1<? super T, ? extends R> map) {
+  default <T, R> Cofree<F, R> map(Kind<Kind<Cofree<?, ?>, F>, ? extends T> value, Function1<? super T, ? extends R> map) {
     return value.fix(CofreeOf::narrowK).map(map);
   }
 }
 
-interface CofreeComonad<F> extends Comonad<Kind<Cofree_, F>>, CofreeFunctor<F> {
+interface CofreeComonad<F> extends Comonad<Kind<Cofree<?, ?>, F>>, CofreeFunctor<F> {
 
   @SuppressWarnings("rawtypes")
   CofreeComonad INSTANCE = new CofreeComonad() { };
 
   @Override
-  default <A> A extract(Kind<Kind<Cofree_, F>, ? extends A> value) {
+  default <A> A extract(Kind<Kind<Cofree<?, ?>, F>, ? extends A> value) {
     return value.fix(CofreeOf::narrowK).extract();
   }
 
   @Override
   default <A, B> Cofree<F, B> coflatMap(
-      Kind<Kind<Cofree_, F>, ? extends A> value, Function1<? super Kind<Kind<Cofree_, F>, ? extends A>, ? extends B> map) {
+      Kind<Kind<Cofree<?, ?>, F>, ? extends A> value, Function1<? super Kind<Kind<Cofree<?, ?>, F>, ? extends A>, ? extends B> map) {
     return value.fix(CofreeOf::narrowK).coflatMap(map);
   }
 }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/ConstInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/ConstInstances.java
index 9519ae959..4bd29a3d9 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/ConstInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/ConstInstances.java
@@ -11,7 +11,6 @@
 import com.github.tonivade.purefun.core.Function2;
 import com.github.tonivade.purefun.type.Const;
 import com.github.tonivade.purefun.type.ConstOf;
-import com.github.tonivade.purefun.type.Const_;
 import com.github.tonivade.purefun.type.Eval;
 import com.github.tonivade.purefun.type.EvalOf;
 import com.github.tonivade.purefun.typeclasses.Applicative;
@@ -24,43 +23,43 @@
   @SuppressWarnings("unchecked")
 public interface ConstInstances {
 
-  static <T, A> Eq<Kind<Kind<Const_, T>, A>> eq(Eq<T> eq) {
+  static <T, A> Eq<Kind<Kind<Const<?, ?>, T>, A>> eq(Eq<T> eq) {
     return (a, b) -> eq.eqv(a.fix(ConstOf::narrowK).value(), a.fix(ConstOf::narrowK).value());
   }
 
-  static <T> Functor<Kind<Const_, T>> functor() {
+  static <T> Functor<Kind<Const<?, ?>, T>> functor() {
     return ConstFunctor.INSTANCE;
   }
 
-  static <T> Applicative<Kind<Const_, T>> applicative(Monoid<T> monoid) {
+  static <T> Applicative<Kind<Const<?, ?>, T>> applicative(Monoid<T> monoid) {
     return ConstApplicative.instance(monoid);
   }
 
-  static <T> Foldable<Kind<Const_, T>> foldable() {
+  static <T> Foldable<Kind<Const<?, ?>, T>> foldable() {
     return ConstFoldable.INSTANCE;
   }
 
-  static <T> Traverse<Kind<Const_, T>> traverse() {
+  static <T> Traverse<Kind<Const<?, ?>, T>> traverse() {
     return ConstTraverse.INSTANCE;
   }
 
-  static <T> Contravariant<Kind<Const_, T>> contravariant() {
+  static <T> Contravariant<Kind<Const<?, ?>, T>> contravariant() {
     return ConstContravariant.INSTANCE;
   }
 }
 
-interface ConstFunctor<T> extends Functor<Kind<Const_, T>> {
+interface ConstFunctor<T> extends Functor<Kind<Const<?, ?>, T>> {
 
   @SuppressWarnings("rawtypes")
   ConstFunctor INSTANCE = new ConstFunctor() {};
 
   @Override
-  default <A, B> Kind<Kind<Const_, T>, B> map(Kind<Kind<Const_, T>, ? extends A> value, Function1<? super A, ? extends B> map) {
+  default <A, B> Kind<Kind<Const<?, ?>, T>, B> map(Kind<Kind<Const<?, ?>, T>, ? extends A> value, Function1<? super A, ? extends B> map) {
     return value.fix(ConstOf::narrowK).retag();
   }
 }
 
-interface ConstApplicative<T> extends Applicative<Kind<Const_, T>> {
+interface ConstApplicative<T> extends Applicative<Kind<Const<?, ?>, T>> {
 
   static <T> ConstApplicative<T> instance(Monoid<T> monoid) {
     return () -> monoid;
@@ -75,52 +74,52 @@ default <A> Const<T, A> pure(A value) {
 
   @Override
   default <A, B> Const<T, B> ap(
-      Kind<Kind<Const_, T>, ? extends A> value, 
-      Kind<Kind<Const_, T>, ? extends Function1<? super A, ? extends B>> apply) {
+      Kind<Kind<Const<?, ?>, T>, ? extends A> value,
+      Kind<Kind<Const<?, ?>, T>, ? extends Function1<? super A, ? extends B>> apply) {
     return Const.of(monoid().combine(
             apply.fix(ConstOf::narrowK).<B>retag().value(),
             value.fix(ConstOf::narrowK).<B>retag().value()));
   }
 }
 
-interface ConstContravariant<T> extends Contravariant<Kind<Const_, T>> {
+interface ConstContravariant<T> extends Contravariant<Kind<Const<?, ?>, T>> {
 
   @SuppressWarnings("rawtypes")
   ConstContravariant INSTANCE = new ConstContravariant() {};
 
   @Override
-  default <A, B> Const<T, B> contramap(Kind<Kind<Const_, T>, ? extends A> value, Function1<? super B, ? extends A> map) {
+  default <A, B> Const<T, B> contramap(Kind<Kind<Const<?, ?>, T>, ? extends A> value, Function1<? super B, ? extends A> map) {
     return value.fix(ConstOf::narrowK).retag();
   }
 }
 
-interface ConstFoldable<T> extends Foldable<Kind<Const_, T>> {
+interface ConstFoldable<T> extends Foldable<Kind<Const<?, ?>, T>> {
 
   @SuppressWarnings("rawtypes")
   ConstFoldable INSTANCE = new ConstFoldable() {};
 
   @Override
-  default <A, B> B foldLeft(Kind<Kind<Const_, T>, ? extends A> value, B initial, 
+  default <A, B> B foldLeft(Kind<Kind<Const<?, ?>, T>, ? extends A> value, B initial,
       Function2<? super B, ? super A, ? extends B> mapper) {
     return initial;
   }
 
   @Override
   default <A, B> Eval<B> foldRight(
-      Kind<Kind<Const_, T>, ? extends A> value, Eval<? extends B> initial, 
+      Kind<Kind<Const<?, ?>, T>, ? extends A> value, Eval<? extends B> initial,
       Function2<? super A, ? super Eval<? extends B>, ? extends Eval<? extends B>> mapper) {
     return EvalOf.narrowK(initial);
   }
 }
 
-interface ConstTraverse<T> extends Traverse<Kind<Const_, T>>, ConstFoldable<T> {
+interface ConstTraverse<T> extends Traverse<Kind<Const<?, ?>, T>>, ConstFoldable<T> {
 
   @SuppressWarnings("rawtypes")
   ConstTraverse INSTANCE = new ConstTraverse() {};
 
   @Override
-  default <G, A, B> Kind<G, Kind<Kind<Const_, T>, B>> traverse(
-      Applicative<G> applicative, Kind<Kind<Const_, T>, A> value, Function1<? super A, ? extends Kind<G, ? extends B>> mapper) {
+  default <G, A, B> Kind<G, Kind<Kind<Const<?, ?>, T>, B>> traverse(
+      Applicative<G> applicative, Kind<Kind<Const<?, ?>, T>, A> value, Function1<? super A, ? extends Kind<G, ? extends B>> mapper) {
     return applicative.pure(value.fix(ConstOf::narrowK).retag());
   }
 }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/ControlInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/ControlInstances.java
index e0248de75..9d4123cd8 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/ControlInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/ControlInstances.java
@@ -9,18 +9,17 @@
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.control.Control;
 import com.github.tonivade.purefun.control.ControlOf;
-import com.github.tonivade.purefun.control.Control_;
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.typeclasses.Monad;
 
 public interface ControlInstances {
 
-  static Monad<Control_> monad() {
+  static Monad<Control<?>> monad() {
     return ControlMonad.INSTANCE;
   }
 }
 
-interface ControlMonad extends Monad<Control_> {
+interface ControlMonad extends Monad<Control<?>> {
 
   ControlMonad INSTANCE = new ControlMonad() {};
 
@@ -31,7 +30,7 @@ default <T> Control<T> pure(T value) {
 
   @Override
   default <T, R> Control<R> flatMap(
-      Kind<Control_, ? extends T> value, Function1<? super T, ? extends Kind<Control_, ? extends R>> map) {
+      Kind<Control<?>, ? extends T> value, Function1<? super T, ? extends Kind<Control<?>, ? extends R>> map) {
     return value.fix(toControl()).flatMap(map.andThen(ControlOf::narrowK));
   }
 }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/EIOInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/EIOInstances.java
index 4341b43bd..f0990defb 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/EIOInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/EIOInstances.java
@@ -18,7 +18,6 @@
 import com.github.tonivade.purefun.data.Sequence;
 import com.github.tonivade.purefun.effect.EIO;
 import com.github.tonivade.purefun.effect.EIOOf;
-import com.github.tonivade.purefun.effect.EIO_;
 import com.github.tonivade.purefun.effect.UIO;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.type.Try;
@@ -38,60 +37,60 @@
 @SuppressWarnings("unchecked")
 public interface EIOInstances {
 
-  static <E> Functor<Kind<EIO_, E>> functor() {
+  static <E> Functor<Kind<EIO<?, ?>, E>> functor() {
     return EIOFunctor.INSTANCE;
   }
 
-  static <E> Applicative<Kind<EIO_, E>> applicative() {
+  static <E> Applicative<Kind<EIO<?, ?>, E>> applicative() {
     return EIOApplicative.INSTANCE;
   }
 
-  static <E> Monad<Kind<EIO_, E>> monad() {
+  static <E> Monad<Kind<EIO<?, ?>, E>> monad() {
     return EIOMonad.INSTANCE;
   }
 
-  static <E> MonadError<Kind<EIO_, E>, E> monadError() {
+  static <E> MonadError<Kind<EIO<?, ?>, E>, E> monadError() {
     return EIOMonadError.INSTANCE;
   }
 
-  static MonadThrow<Kind<EIO_, Throwable>> monadThrow() {
+  static MonadThrow<Kind<EIO<?, ?>, Throwable>> monadThrow() {
     return EIOMonadThrow.INSTANCE;
   }
 
-  static MonadDefer<Kind<EIO_, Throwable>> monadDefer() {
+  static MonadDefer<Kind<EIO<?, ?>, Throwable>> monadDefer() {
     return EIOMonadDefer.INSTANCE;
   }
 
-  static Async<Kind<EIO_, Throwable>> async() {
+  static Async<Kind<EIO<?, ?>, Throwable>> async() {
     return EIOAsync.INSTANCE;
   }
 
-  static Concurrent<Kind<EIO_, Throwable>> concurrent() {
+  static Concurrent<Kind<EIO<?, ?>, Throwable>> concurrent() {
     return concurrent(Future.DEFAULT_EXECUTOR);
   }
 
-  static Concurrent<Kind<EIO_, Throwable>> concurrent(Executor executor) {
+  static Concurrent<Kind<EIO<?, ?>, Throwable>> concurrent(Executor executor) {
     return EIOConcurrent.instance(executor);
   }
 
-  static <E> Runtime<Kind<EIO_, E>> runtime() {
+  static <E> Runtime<Kind<EIO<?, ?>, E>> runtime() {
     return EIORuntime.INSTANCE;
   }
 }
 
-interface EIOFunctor<E> extends Functor<Kind<EIO_, E>> {
+interface EIOFunctor<E> extends Functor<Kind<EIO<?, ?>, E>> {
 
   @SuppressWarnings("rawtypes")
   EIOFunctor INSTANCE = new EIOFunctor() {};
 
   @Override
   default <A, B> EIO<E, B>
-          map(Kind<Kind<EIO_, E>, ? extends A> value, Function1<? super A, ? extends B> map) {
+          map(Kind<Kind<EIO<?, ?>, E>, ? extends A> value, Function1<? super A, ? extends B> map) {
     return EIOOf.narrowK(value).map(map);
   }
 }
 
-interface EIOPure<E> extends Applicative<Kind<EIO_, E>> {
+interface EIOPure<E> extends Applicative<Kind<EIO<?, ?>, E>> {
 
   @Override
   default <A> EIO<E, A> pure(A value) {
@@ -106,26 +105,26 @@ interface EIOApplicative<E> extends EIOPure<E> {
 
   @Override
   default <A, B> EIO<E, B>
-          ap(Kind<Kind<EIO_, E>, ? extends A> value,
-             Kind<Kind<EIO_, E>, ? extends Function1<? super A, ? extends B>> apply) {
+          ap(Kind<Kind<EIO<?, ?>, E>, ? extends A> value,
+             Kind<Kind<EIO<?, ?>, E>, ? extends Function1<? super A, ? extends B>> apply) {
     return value.fix(EIOOf::<E, A>narrowK).ap(apply.fix(EIOOf::narrowK));
   }
 }
 
-interface EIOMonad<E> extends EIOPure<E>, Monad<Kind<EIO_, E>> {
+interface EIOMonad<E> extends EIOPure<E>, Monad<Kind<EIO<?, ?>, E>> {
 
   @SuppressWarnings("rawtypes")
   EIOMonad INSTANCE = new EIOMonad() {};
 
   @Override
   default <A, B> EIO<E, B>
-          flatMap(Kind<Kind<EIO_, E>, ? extends A> value,
-                  Function1<? super A, ? extends Kind<Kind<EIO_, E>, ? extends B>> map) {
+          flatMap(Kind<Kind<EIO<?, ?>, E>, ? extends A> value,
+                  Function1<? super A, ? extends Kind<Kind<EIO<?, ?>, E>, ? extends B>> map) {
     return value.fix(toEIO()).flatMap(map.andThen(EIOOf::narrowK));
   }
 }
 
-interface EIOMonadError<E> extends EIOMonad<E>, MonadError<Kind<EIO_, E>, E> {
+interface EIOMonadError<E> extends EIOMonad<E>, MonadError<Kind<EIO<?, ?>, E>, E> {
 
   @SuppressWarnings("rawtypes")
   EIOMonadError INSTANCE = new EIOMonadError() {};
@@ -137,8 +136,8 @@ default <A> EIO<E, A> raiseError(E error) {
 
   @Override
   default <A> EIO<E, A> handleErrorWith(
-      Kind<Kind<EIO_,  E>, A> value,
-      Function1<? super E, ? extends Kind<Kind<EIO_, E>, ? extends A>> handler) {
+      Kind<Kind<EIO<?, ?>,  E>, A> value,
+      Function1<? super E, ? extends Kind<Kind<EIO<?, ?>, E>, ? extends A>> handler) {
     // XXX: java8 fails to infer types, I have to do this in steps
     Function1<? super E, EIO<E, A>> mapError = handler.andThen(EIOOf::narrowK);
     Function1<A, EIO<E, A>> map = EIO::pure;
@@ -149,33 +148,33 @@ default <A> EIO<E, A> handleErrorWith(
 
 interface EIOMonadThrow
     extends EIOMonadError<Throwable>,
-            MonadThrow<Kind<EIO_, Throwable>> {
+            MonadThrow<Kind<EIO<?, ?>, Throwable>> {
 
   EIOMonadThrow INSTANCE = new EIOMonadThrow() {};
 }
 
-interface EIODefer<E> extends Defer<Kind<EIO_, E>> {
+interface EIODefer<E> extends Defer<Kind<EIO<?, ?>, E>> {
 
   @Override
   default <A> EIO<E, A>
-          defer(Producer<? extends Kind<Kind<EIO_, E>, ? extends A>> defer) {
+          defer(Producer<? extends Kind<Kind<EIO<?, ?>, E>, ? extends A>> defer) {
     return EIO.defer(defer::get);
   }
 }
 
-interface EIOBracket<E> extends EIOMonadError<E>, Bracket<Kind<EIO_, E>, E> {
+interface EIOBracket<E> extends EIOMonadError<E>, Bracket<Kind<EIO<?, ?>, E>, E> {
 
   @Override
   default <A, B> EIO<E, B>
-          bracket(Kind<Kind<EIO_, E>, ? extends A> acquire,
-                  Function1<? super A, ? extends Kind<Kind<EIO_, E>, ? extends B>> use,
-                  Function1<? super A, ? extends Kind<Kind<EIO_, E>, Unit>> release) {
+          bracket(Kind<Kind<EIO<?, ?>, E>, ? extends A> acquire,
+                  Function1<? super A, ? extends Kind<Kind<EIO<?, ?>, E>, ? extends B>> use,
+                  Function1<? super A, ? extends Kind<Kind<EIO<?, ?>, E>, Unit>> release) {
     return EIO.bracket(acquire, use, release);
   }
 }
 
 interface EIOMonadDefer
-    extends MonadDefer<Kind<EIO_, Throwable>>, EIODefer<Throwable>, EIOBracket<Throwable> {
+    extends MonadDefer<Kind<EIO<?, ?>, Throwable>>, EIODefer<Throwable>, EIOBracket<Throwable> {
 
   EIOMonadDefer INSTANCE = new EIOMonadDefer() {};
 
@@ -185,17 +184,17 @@ default EIO<Throwable, Unit> sleep(Duration duration) {
   }
 }
 
-interface EIOAsync extends Async<Kind<EIO_, Throwable>>, EIOMonadDefer {
+interface EIOAsync extends Async<Kind<EIO<?, ?>, Throwable>>, EIOMonadDefer {
 
   EIOAsync INSTANCE = new EIOAsync() {};
 
   @Override
-  default <A> EIO<Throwable, A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<Kind<EIO_, Throwable>, Unit>> consumer) {
+  default <A> EIO<Throwable, A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<Kind<EIO<?, ?>, Throwable>, Unit>> consumer) {
     return EIO.cancellable(cb -> consumer.andThen(EIOOf::narrowK).apply(e -> cb.accept(Try.success(e.toEither()))));
   }
 }
 
-interface EIOConcurrent extends EIOAsync, Concurrent<Kind<EIO_, Throwable>> {
+interface EIOConcurrent extends EIOAsync, Concurrent<Kind<EIO<?, ?>, Throwable>> {
 
   static EIOConcurrent instance(Executor executor) {
     return () -> executor;
@@ -204,40 +203,40 @@ static EIOConcurrent instance(Executor executor) {
   Executor executor();
 
   @Override
-  default <A, B> EIO<Throwable, Either<Tuple2<A, Fiber<Kind<EIO_, Throwable>, B>>, Tuple2<Fiber<Kind<EIO_, Throwable>, A>, B>>> racePair(
-    Kind<Kind<EIO_, Throwable>, ? extends A> fa, Kind<Kind<EIO_, Throwable>, ? extends B> fb) {
+  default <A, B> EIO<Throwable, Either<Tuple2<A, Fiber<Kind<EIO<?, ?>, Throwable>, B>>, Tuple2<Fiber<Kind<EIO<?, ?>, Throwable>, A>, B>>> racePair(
+    Kind<Kind<EIO<?, ?>, Throwable>, ? extends A> fa, Kind<Kind<EIO<?, ?>, Throwable>, ? extends B> fb) {
     return EIO.racePair(executor(), fa, fb);
   }
 
   @Override
-  default <A> EIO<Throwable, Fiber<Kind<EIO_, Throwable>, A>> fork(Kind<Kind<EIO_, Throwable>, ? extends A> value) {
+  default <A> EIO<Throwable, Fiber<Kind<EIO<?, ?>, Throwable>, A>> fork(Kind<Kind<EIO<?, ?>, Throwable>, ? extends A> value) {
     EIO<Throwable, A> fix = value.fix(EIOOf::narrowK);
     return fix.fork();
   }
 }
 
-interface EIORuntime<E> extends Runtime<Kind<EIO_, E>> {
+interface EIORuntime<E> extends Runtime<Kind<EIO<?, ?>, E>> {
 
   @SuppressWarnings("rawtypes")
   EIORuntime INSTANCE = new EIORuntime() {};
 
   @Override
-  default <T> T run(Kind<Kind<EIO_, E>, T> value) {
+  default <T> T run(Kind<Kind<EIO<?, ?>, E>, T> value) {
     return value.fix(toEIO()).safeRunSync().getRight();
   }
 
   @Override
-  default <T> Sequence<T> run(Sequence<Kind<Kind<EIO_, E>, T>> values) {
+  default <T> Sequence<T> run(Sequence<Kind<Kind<EIO<?, ?>, E>, T>> values) {
     return run(EIO.traverse(values.map(EIOOf::<E, T>narrowK)));
   }
 
   @Override
-  default <T> Future<T> parRun(Kind<Kind<EIO_, E>, T> value, Executor executor) {
+  default <T> Future<T> parRun(Kind<Kind<EIO<?, ?>, E>, T> value, Executor executor) {
     return value.fix(toEIO()).runAsync().map(Either::get);
   }
 
   @Override
-  default <T> Future<Sequence<T>> parRun(Sequence<Kind<Kind<EIO_, E>, T>> values, Executor executor) {
+  default <T> Future<Sequence<T>> parRun(Sequence<Kind<Kind<EIO<?, ?>, E>, T>> values, Executor executor) {
     return parRun(EIO.traverse(values.map(EIOOf::<E, T>narrowK)), executor);
   }
 }
\ No newline at end of file
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/EitherInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/EitherInstances.java
index adfec599e..11cf86797 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/EitherInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/EitherInstances.java
@@ -14,7 +14,6 @@
 import com.github.tonivade.purefun.free.Trampoline;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.type.EitherOf;
-import com.github.tonivade.purefun.type.Either_;
 import com.github.tonivade.purefun.type.Eval;
 import com.github.tonivade.purefun.type.EvalOf;
 import com.github.tonivade.purefun.typeclasses.Applicative;
@@ -29,7 +28,7 @@
 @SuppressWarnings("unchecked")
 public interface EitherInstances {
 
-  static <L, R> Eq<Kind<Kind<Either_, L>, R>> eq(Eq<L> leftEq, Eq<R> rightEq) {
+  static <L, R> Eq<Kind<Kind<Either<?, ?>, L>, R>> eq(Eq<L> leftEq, Eq<R> rightEq) {
     return (a, b) -> {
       if (a instanceof Either.Left<L, R>(var leftA) && b instanceof Either.Left<L, R>(var leftB)) {
         return leftEq.eqv(leftA, leftB);
@@ -41,62 +40,62 @@ static <L, R> Eq<Kind<Kind<Either_, L>, R>> eq(Eq<L> leftEq, Eq<R> rightEq) {
     };
   }
 
-  static <L> Functor<Kind<Either_, L>> functor() {
+  static <L> Functor<Kind<Either<?, ?>, L>> functor() {
     return EitherFunctor.INSTANCE;
   }
 
-  static Bifunctor<Either_> bifunctor() {
+  static Bifunctor<Either<?, ?>> bifunctor() {
     return EitherBifunctor.INSTANCE;
   }
 
-  static <L> Applicative<Kind<Either_, L>> applicative() {
+  static <L> Applicative<Kind<Either<?, ?>, L>> applicative() {
     return EitherApplicative.INSTANCE;
   }
 
-  static <L> Monad<Kind<Either_, L>> monad() {
+  static <L> Monad<Kind<Either<?, ?>, L>> monad() {
     return EitherMonad.INSTANCE;
   }
 
-  static <L> MonadError<Kind<Either_, L>, L> monadError() {
+  static <L> MonadError<Kind<Either<?, ?>, L>, L> monadError() {
     return EitherMonadError.INSTANCE;
   }
 
-  static MonadThrow<Kind<Either_, Throwable>> monadThrow() {
+  static MonadThrow<Kind<Either<?, ?>, Throwable>> monadThrow() {
     return EitherMonadThrow.INSTANCE;
   }
 
-  static <L> Foldable<Kind<Either_, L>> foldable() {
+  static <L> Foldable<Kind<Either<?, ?>, L>> foldable() {
     return EitherFoldable.INSTANCE;
   }
 
-  static <L> Traverse<Kind<Either_, L>> traverse() {
+  static <L> Traverse<Kind<Either<?, ?>, L>> traverse() {
     return EitherTraverse.INSTANCE;
   }
 }
 
-interface EitherFunctor<L> extends Functor<Kind<Either_, L>> {
+interface EitherFunctor<L> extends Functor<Kind<Either<?, ?>, L>> {
 
   @SuppressWarnings("rawtypes")
   EitherFunctor INSTANCE = new EitherFunctor() {};
 
   @Override
-  default <T, R> Either<L, R> map(Kind<Kind<Either_, L>, ? extends T> value, Function1<? super T, ? extends R> map) {
+  default <T, R> Either<L, R> map(Kind<Kind<Either<?, ?>, L>, ? extends T> value, Function1<? super T, ? extends R> map) {
     return EitherOf.narrowK(value).map(map);
   }
 }
 
-interface EitherBifunctor extends Bifunctor<Either_> {
+interface EitherBifunctor extends Bifunctor<Either<?, ?>> {
 
   EitherBifunctor INSTANCE = new EitherBifunctor() {};
 
   @Override
-  default <A, B, C, D> Either<C, D> bimap(Kind<Kind<Either_, A>, ? extends B> value,
+  default <A, B, C, D> Either<C, D> bimap(Kind<Kind<Either<?, ?>, A>, ? extends B> value,
       Function1<? super A, ? extends C> leftMap, Function1<? super B, ? extends D> rightMap) {
     return EitherOf.narrowK(value).bimap(leftMap, rightMap);
   }
 }
 
-interface EitherPure<L> extends Applicative<Kind<Either_, L>> {
+interface EitherPure<L> extends Applicative<Kind<Either<?, ?>, L>> {
 
   @Override
   default <T> Either<L, T> pure(T value) {
@@ -110,30 +109,30 @@ interface EitherApplicative<L> extends EitherPure<L> {
   EitherApplicative INSTANCE = new EitherApplicative() {};
 
   @Override
-  default <T, R> Either<L, R> ap(Kind<Kind<Either_, L>, ? extends T> value,
-      Kind<Kind<Either_, L>, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Either<L, R> ap(Kind<Kind<Either<?, ?>, L>, ? extends T> value,
+      Kind<Kind<Either<?, ?>, L>, ? extends Function1<? super T, ? extends R>> apply) {
     return EitherOf.narrowK(value).flatMap(t -> EitherOf.narrowK(apply).map(f -> f.apply(t)));
   }
 }
 
-interface EitherMonad<L> extends EitherPure<L>, Monad<Kind<Either_, L>> {
+interface EitherMonad<L> extends EitherPure<L>, Monad<Kind<Either<?, ?>, L>> {
 
   @SuppressWarnings("rawtypes")
   EitherMonad INSTANCE = new EitherMonad() {};
 
   @Override
-  default <T, R> Either<L, R> flatMap(Kind<Kind<Either_, L>, ? extends T> value,
-      Function1<? super T, ? extends Kind<Kind<Either_, L>, ? extends R>> map) {
+  default <T, R> Either<L, R> flatMap(Kind<Kind<Either<?, ?>, L>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Kind<Either<?, ?>, L>, ? extends R>> map) {
     return EitherOf.narrowK(value).flatMap(map.andThen(EitherOf::narrowK));
   }
 
   @Override
-  default <T, R> Kind<Kind<Either_, L>, R> tailRecM(T value,
-      Function1<T, ? extends Kind<Kind<Either_, L>, Either<T, R>>> map) {
+  default <T, R> Kind<Kind<Either<?, ?>, L>, R> tailRecM(T value,
+      Function1<T, ? extends Kind<Kind<Either<?, ?>, L>, Either<T, R>>> map) {
     return loop(value, map).run();
   }
 
-  private <T, R> Trampoline<Kind<Kind<Either_, L>, R>> loop(T value, Function1<T, ? extends Kind<Kind<Either_, L>, Either<T, R>>> map) {
+  private <T, R> Trampoline<Kind<Kind<Either<?, ?>, L>, R>> loop(T value, Function1<T, ? extends Kind<Kind<Either<?, ?>, L>, Either<T, R>>> map) {
     return switch (map.andThen(EitherOf::narrowK).apply(value)) {
       case Either.Left<L, Either<T, R>>(var left) -> Trampoline.done(Either.left(left));
       case Either.Right<L, Either<T, R>>(Either.Right<T, R>(var right)) -> Trampoline.done(Either.right(right));
@@ -142,7 +141,7 @@ private <T, R> Trampoline<Kind<Kind<Either_, L>, R>> loop(T value, Function1<T,
   }
 }
 
-interface EitherMonadError<L> extends EitherMonad<L>, MonadError<Kind<Either_, L>, L> {
+interface EitherMonadError<L> extends EitherMonad<L>, MonadError<Kind<Either<?, ?>, L>, L> {
 
   @SuppressWarnings("rawtypes")
   EitherMonadError INSTANCE = new EitherMonadError() {};
@@ -153,29 +152,29 @@ default <A> Either<L, A> raiseError(L error) {
   }
 
   @Override
-  default <A> Either<L, A> handleErrorWith(Kind<Kind<Either_, L>, A> value,
-      Function1<? super L, ? extends Kind<Kind<Either_, L>, ? extends A>> handler) {
+  default <A> Either<L, A> handleErrorWith(Kind<Kind<Either<?, ?>, L>, A> value,
+      Function1<? super L, ? extends Kind<Kind<Either<?, ?>, L>, ? extends A>> handler) {
     return EitherOf.narrowK(value).fold(handler.andThen(EitherOf::narrowK), Either::right);
   }
 }
 
-interface EitherMonadThrow extends EitherMonadError<Throwable>, MonadThrow<Kind<Either_, Throwable>> {
+interface EitherMonadThrow extends EitherMonadError<Throwable>, MonadThrow<Kind<Either<?, ?>, Throwable>> {
 
   EitherMonadThrow INSTANCE = new EitherMonadThrow() {};
 }
 
-interface EitherFoldable<L> extends Foldable<Kind<Either_, L>> {
+interface EitherFoldable<L> extends Foldable<Kind<Either<?, ?>, L>> {
 
   @SuppressWarnings("rawtypes")
   EitherFoldable INSTANCE = new EitherFoldable() {};
 
   @Override
-  default <A, B> B foldLeft(Kind<Kind<Either_, L>, ? extends A> value, B initial, Function2<? super B, ? super A, ? extends B> mapper) {
+  default <A, B> B foldLeft(Kind<Kind<Either<?, ?>, L>, ? extends A> value, B initial, Function2<? super B, ? super A, ? extends B> mapper) {
     return EitherOf.narrowK(value).fold(cons(initial), a -> mapper.apply(initial, a));
   }
 
   @Override
-  default <A, B> Eval<B> foldRight(Kind<Kind<Either_, L>, ? extends A> value, Eval<? extends B> initial,
+  default <A, B> Eval<B> foldRight(Kind<Kind<Either<?, ?>, L>, ? extends A> value, Eval<? extends B> initial,
       Function2<? super A, ? super Eval<? extends B>, ? extends Eval<? extends B>> mapper) {
     return EitherOf.<L, A>narrowK(value).fold(
         cons(initial).andThen(EvalOf::<B>narrowK),
@@ -183,14 +182,14 @@ default <A, B> Eval<B> foldRight(Kind<Kind<Either_, L>, ? extends A> value, Eval
   }
 }
 
-interface EitherTraverse<L> extends Traverse<Kind<Either_, L>>, EitherFoldable<L> {
+interface EitherTraverse<L> extends Traverse<Kind<Either<?, ?>, L>>, EitherFoldable<L> {
 
   @SuppressWarnings("rawtypes")
   EitherTraverse INSTANCE = new EitherTraverse() {};
 
   @Override
-  default <G, T, R> Kind<G, Kind<Kind<Either_, L>, R>> traverse(
-      Applicative<G> applicative, Kind<Kind<Either_, L>, T> value,
+  default <G, T, R> Kind<G, Kind<Kind<Either<?, ?>, L>, R>> traverse(
+      Applicative<G> applicative, Kind<Kind<Either<?, ?>, L>, T> value,
       Function1<? super T, ? extends Kind<G, ? extends R>> mapper) {
     return EitherOf.narrowK(value).fold(
       l -> applicative.pure(Either.<L, R>left(l).kind()),
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/EitherKInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/EitherKInstances.java
index a22da9254..9ad0c8a32 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/EitherKInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/EitherKInstances.java
@@ -12,7 +12,6 @@
 import com.github.tonivade.purefun.core.Pattern2;
 import com.github.tonivade.purefun.free.EitherK;
 import com.github.tonivade.purefun.free.EitherKOf;
-import com.github.tonivade.purefun.free.EitherK_;
 import com.github.tonivade.purefun.typeclasses.Comonad;
 import com.github.tonivade.purefun.typeclasses.Contravariant;
 import com.github.tonivade.purefun.typeclasses.Functor;
@@ -20,7 +19,7 @@
 
 public interface EitherKInstances {
 
-  static <F, G, T> Eq<Kind<Kind<Kind<EitherK_, F>, G>, T>> eq(
+  static <F, G, T> Eq<Kind<Kind<Kind<EitherK<?, ?, ?>, F>, G>, T>> eq(
       Eq<Kind<F, T>> leftEq, Eq<Kind<G, T>> rightEq) {
     return (a, b) -> Pattern2.<EitherK<F, G, T>, EitherK<F, G, T>, Boolean>build()
         .when((x, y) -> x.isLeft() && y.isLeft())
@@ -32,33 +31,33 @@ static <F, G, T> Eq<Kind<Kind<Kind<EitherK_, F>, G>, T>> eq(
         .apply(EitherKOf.narrowK(a), EitherKOf.narrowK(b));
   }
 
-  static <F, G> Functor<Kind<Kind<EitherK_, F>, G>> functor(
+  static <F, G> Functor<Kind<Kind<EitherK<?, ?, ?>, F>, G>> functor(
       Functor<F> functorF, Functor<G> functorG) {
     return EitherKFunctor.instance(checkNonNull(functorF), checkNonNull(functorG));
   }
 
-  static <F, G> Contravariant<Kind<Kind<EitherK_, F>, G>> contravariant(
+  static <F, G> Contravariant<Kind<Kind<EitherK<?, ?, ?>, F>, G>> contravariant(
       Contravariant<F> contravariantF, Contravariant<G> contravariantG) {
     return EitherKContravariant.instance(checkNonNull(contravariantF), checkNonNull(contravariantG));
   }
 
-  static <F, G> Comonad<Kind<Kind<EitherK_, F>, G>> comonad(
+  static <F, G> Comonad<Kind<Kind<EitherK<?, ?, ?>, F>, G>> comonad(
       Comonad<F> comonadF, Comonad<G> comonadG) {
     return EitherKComonad.instance(checkNonNull(comonadF), checkNonNull(comonadG));
   }
 
   @SuppressWarnings("unchecked")
-  static <F, G> InjectK<F, Kind<Kind<EitherK_, F>, G>> injectEitherKLeft() {
+  static <F, G> InjectK<F, Kind<Kind<EitherK<?, ?, ?>, F>, G>> injectEitherKLeft() {
     return EitherKInjectKLeft.INSTANCE;
   }
 
   static <F, R, G>
-      InjectK<F, Kind<Kind<EitherK_, G>, R>> injectEitherKRight(InjectK<F, R> inject) {
+      InjectK<F, Kind<Kind<EitherK<?, ?, ?>, G>, R>> injectEitherKRight(InjectK<F, R> inject) {
     return EitherKInjectKRight.instance(checkNonNull(inject));
   }
 }
 
-interface EitherKFunctor<F, G> extends Functor<Kind<Kind<EitherK_, F>, G>> {
+interface EitherKFunctor<F, G> extends Functor<Kind<Kind<EitherK<?, ?, ?>, F>, G>> {
 
   static <F, G> EitherKFunctor<F, G> instance(Functor<F> functorF, Functor<G> functorG) {
     return new EitherKFunctor<>() {
@@ -74,13 +73,13 @@ static <F, G> EitherKFunctor<F, G> instance(Functor<F> functorF, Functor<G> func
 
   @Override
   default <T, R> EitherK<F, G, R> map(
-      Kind<Kind<Kind<EitherK_, F>, G>, ? extends T> value, Function1<? super T, ? extends R> map) {
+      Kind<Kind<Kind<EitherK<?, ?, ?>, F>, G>, ? extends T> value, Function1<? super T, ? extends R> map) {
     return value.fix(EitherKOf::narrowK).map(f(), g(), map);
   }
 }
 
 interface EitherKContravariant<F, G>
-    extends Contravariant<Kind<Kind<EitherK_, F>, G>> {
+    extends Contravariant<Kind<Kind<EitherK<?, ?, ?>, F>, G>> {
 
   static <F, G> EitherKContravariant<F, G> instance(
       Contravariant<F> contravariantF, Contravariant<G> contravariantG) {
@@ -97,13 +96,13 @@ static <F, G> EitherKContravariant<F, G> instance(
 
   @Override
   default <A, B> EitherK<F, G, B> contramap(
-      Kind<Kind<Kind<EitherK_, F>, G>, ? extends A> value, Function1<? super B, ? extends A> map) {
+      Kind<Kind<Kind<EitherK<?, ?, ?>, F>, G>, ? extends A> value, Function1<? super B, ? extends A> map) {
     return value.fix(EitherKOf::<F, G, A>narrowK).contramap(f(), g(), map);
   }
 }
 
 interface EitherKComonad<F, G>
-    extends Comonad<Kind<Kind<EitherK_, F>, G>>, EitherKFunctor<F, G> {
+    extends Comonad<Kind<Kind<EitherK<?, ?, ?>, F>, G>>, EitherKFunctor<F, G> {
 
   static <F, G> EitherKComonad<F, G> instance(Comonad<F> comonadF, Comonad<G> comonadG) {
     return new EitherKComonad<>() {
@@ -121,19 +120,19 @@ static <F, G> EitherKComonad<F, G> instance(Comonad<F> comonadF, Comonad<G> como
 
   @Override
   default <A, B> EitherK<F, G, B> coflatMap(
-      Kind<Kind<Kind<EitherK_, F>, G>, ? extends A> value,
-      Function1<? super Kind<Kind<Kind<EitherK_, F>, G>, ? extends A>, ? extends B> map) {
+      Kind<Kind<Kind<EitherK<?, ?, ?>, F>, G>, ? extends A> value,
+      Function1<? super Kind<Kind<Kind<EitherK<?, ?, ?>, F>, G>, ? extends A>, ? extends B> map) {
     return value.fix(EitherKOf::narrowK).coflatMap(f(), g(), map);
   }
 
   @Override
-  default <A> A extract(Kind<Kind<Kind<EitherK_, F>, G>, ? extends A> value) {
+  default <A> A extract(Kind<Kind<Kind<EitherK<?, ?, ?>, F>, G>, ? extends A> value) {
     return value.fix(EitherKOf::narrowK).extract(f(), g());
   }
 }
 
 interface EitherKInjectKRight<F, G, R>
-    extends InjectK<F, Kind<Kind<EitherK_, G>, R>> {
+    extends InjectK<F, Kind<Kind<EitherK<?, ?, ?>, G>, R>> {
 
   static <F, X, R> EitherKInjectKRight<F, X, R> instance(InjectK<F, R> injectK) {
     return () -> injectK;
@@ -147,7 +146,7 @@ default  <T> EitherK<G, R, T> inject(Kind<F, ? extends T> value) {
   }
 }
 
-interface EitherKInjectKLeft<F, G> extends InjectK<F, Kind<Kind<EitherK_, F>, G>> {
+interface EitherKInjectKLeft<F, G> extends InjectK<F, Kind<Kind<EitherK<?, ?, ?>, F>, G>> {
 
   @SuppressWarnings("rawtypes")
   EitherKInjectKLeft INSTANCE = new EitherKInjectKLeft() {};
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/EitherTInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/EitherTInstances.java
index e15e362df..2c1684801 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/EitherTInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/EitherTInstances.java
@@ -20,7 +20,6 @@
 import com.github.tonivade.purefun.core.Unit;
 import com.github.tonivade.purefun.transformer.EitherT;
 import com.github.tonivade.purefun.transformer.EitherTOf;
-import com.github.tonivade.purefun.transformer.EitherT_;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.typeclasses.Bracket;
 import com.github.tonivade.purefun.typeclasses.Defer;
@@ -33,42 +32,42 @@
 
 public interface EitherTInstances {
 
-  static <F, L, R> Eq<Kind<Kind<Kind<EitherT_, F>, L>, R>> eq(Eq<Kind<F, Either<L, R>>> eq) {
+  static <F, L, R> Eq<Kind<Kind<Kind<EitherT<?, ?, ?>, F>, L>, R>> eq(Eq<Kind<F, Either<L, R>>> eq) {
     return (a, b) -> eq.eqv(EitherTOf.narrowK(a).value(), EitherTOf.narrowK(b).value());
   }
 
-  static <F, L> Monad<Kind<Kind<EitherT_, F>, L>> monad(Monad<F> monadF) {
+  static <F, L> Monad<Kind<Kind<EitherT<?, ?, ?>, F>, L>> monad(Monad<F> monadF) {
     return EitherTMonad.instance(checkNonNull(monadF));
   }
 
-  static <F, L> MonadError<Kind<Kind<EitherT_, F>, L>, L> monadError(Monad<F> monadF) {
+  static <F, L> MonadError<Kind<Kind<EitherT<?, ?, ?>, F>, L>, L> monadError(Monad<F> monadF) {
     return EitherTMonadErrorFromMonad.instance(checkNonNull(monadF));
   }
 
-  static <F, L> MonadError<Kind<Kind<EitherT_, F>, L>, L> monadError(MonadError<F, L> monadErrorF) {
+  static <F, L> MonadError<Kind<Kind<EitherT<?, ?, ?>, F>, L>, L> monadError(MonadError<F, L> monadErrorF) {
     return EitherTMonadErrorFromMonadError.instance(checkNonNull(monadErrorF));
   }
 
-  static <F> MonadThrow<Kind<Kind<EitherT_, F>, Throwable>> monadThrow(Monad<F> monadF) {
+  static <F> MonadThrow<Kind<Kind<EitherT<?, ?, ?>, F>, Throwable>> monadThrow(Monad<F> monadF) {
     return EitherTMonadThrowFromMonad.instance(checkNonNull(monadF));
   }
 
-  static <F> MonadThrow<Kind<Kind<EitherT_, F>, Throwable>> monadThrow(MonadThrow<F> monadF) {
+  static <F> MonadThrow<Kind<Kind<EitherT<?, ?, ?>, F>, Throwable>> monadThrow(MonadThrow<F> monadF) {
     return EitherTMonadThrowFromMonadThrow.instance(checkNonNull(monadF));
   }
 
-  static <F> MonadDefer<Kind<Kind<EitherT_, F>, Throwable>> monadDefer(MonadDefer<F> monadDeferF) {
+  static <F> MonadDefer<Kind<Kind<EitherT<?, ?, ?>, F>, Throwable>> monadDefer(MonadDefer<F> monadDeferF) {
     return EitherTMonadDefer.instance(checkNonNull(monadDeferF));
   }
 
   static <F, A>
-         Reference<Kind<Kind<EitherT_, F>, Throwable>, A>
+         Reference<Kind<Kind<EitherT<?, ?, ?>, F>, Throwable>, A>
          refFromMonadThrow(MonadDefer<F> monadDeferF, A value) {
     return Reference.of(monadDefer(monadDeferF), value);
   }
 }
 
-interface EitherTMonad<F, L> extends Monad<Kind<Kind<EitherT_, F>, L>> {
+interface EitherTMonad<F, L> extends Monad<Kind<Kind<EitherT<?, ?, ?>, F>, L>> {
 
   static <F, L> EitherTMonad<F, L> instance(Monad<F> monadF) {
     return () -> monadF;
@@ -82,14 +81,14 @@ default <T> EitherT<F, L, T> pure(T value) {
   }
 
   @Override
-  default <T, R> EitherT<F, L, R> flatMap(Kind<Kind<Kind<EitherT_, F>, L>, ? extends T> value,
-      Function1<? super T, ? extends Kind<Kind<Kind<EitherT_, F>, L>, ? extends R>> map) {
+  default <T, R> EitherT<F, L, R> flatMap(Kind<Kind<Kind<EitherT<?, ?, ?>, F>, L>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Kind<Kind<EitherT<?, ?, ?>, F>, L>, ? extends R>> map) {
     return EitherTOf.narrowK(value).flatMap(map.andThen(EitherTOf::narrowK));
   }
 }
 
 interface EitherTMonadErrorFromMonad<F, E>
-    extends MonadError<Kind<Kind<EitherT_, F>, E>, E>, EitherTMonad<F, E> {
+    extends MonadError<Kind<Kind<EitherT<?, ?, ?>, F>, E>, E>, EitherTMonad<F, E> {
 
   static <F, L> EitherTMonadErrorFromMonad<F, L> instance(Monad<F> monadF) {
     return () -> monadF;
@@ -101,8 +100,8 @@ default <A> EitherT<F, E, A> raiseError(E error) {
   }
 
   @Override
-  default <A> EitherT<F, E, A> handleErrorWith(Kind<Kind<Kind<EitherT_, F>, E>, A> value,
-      Function1<? super E, ? extends Kind<Kind<Kind<EitherT_, F>, E>, ? extends A>> handler) {
+  default <A> EitherT<F, E, A> handleErrorWith(Kind<Kind<Kind<EitherT<?, ?, ?>, F>, E>, A> value,
+      Function1<? super E, ? extends Kind<Kind<Kind<EitherT<?, ?, ?>, F>, E>, ? extends A>> handler) {
     return EitherT.of(monadF(),
         monadF().flatMap(EitherTOf.narrowK(value).value(),
             either -> either.fold(
@@ -112,7 +111,7 @@ default <A> EitherT<F, E, A> handleErrorWith(Kind<Kind<Kind<EitherT_, F>, E>, A>
 }
 
 interface EitherTMonadErrorFromMonadError<F, E>
-    extends MonadError<Kind<Kind<EitherT_, F>, E>, E>,
+    extends MonadError<Kind<Kind<EitherT<?, ?, ?>, F>, E>, E>,
             EitherTMonad<F, E> {
 
   static <F, E> EitherTMonadErrorFromMonadError<F, E> instance(MonadError<F, E> monadErrorF) {
@@ -128,8 +127,8 @@ default <A> EitherT<F, E, A> raiseError(E error) {
   }
 
   @Override
-  default <A> EitherT<F, E, A> handleErrorWith(Kind<Kind<Kind<EitherT_, F>, E>, A> value,
-      Function1<? super E, ? extends Kind<Kind<Kind<EitherT_, F>, E>, ? extends A>> handler) {
+  default <A> EitherT<F, E, A> handleErrorWith(Kind<Kind<Kind<EitherT<?, ?, ?>, F>, E>, A> value,
+      Function1<? super E, ? extends Kind<Kind<Kind<EitherT<?, ?, ?>, F>, E>, ? extends A>> handler) {
     return EitherT.of(monadF(),
                       monadF().handleErrorWith(EitherTOf.narrowK(value).value(),
                                                error -> handler.andThen(EitherTOf::<F, E, A>narrowK).apply(error).value()));
@@ -138,7 +137,7 @@ default <A> EitherT<F, E, A> handleErrorWith(Kind<Kind<Kind<EitherT_, F>, E>, A>
 
 interface EitherTMonadThrowFromMonad<F>
     extends EitherTMonadErrorFromMonad<F, Throwable>,
-            MonadThrow<Kind<Kind<EitherT_, F>, Throwable>> {
+            MonadThrow<Kind<Kind<EitherT<?, ?, ?>, F>, Throwable>> {
 
   static <F> EitherTMonadThrowFromMonad<F> instance(Monad<F> monadF) {
     return () -> monadF;
@@ -147,24 +146,24 @@ static <F> EitherTMonadThrowFromMonad<F> instance(Monad<F> monadF) {
 
 interface EitherTMonadThrowFromMonadThrow<F>
     extends EitherTMonadErrorFromMonadError<F, Throwable>,
-            MonadThrow<Kind<Kind<EitherT_, F>, Throwable>> {
+            MonadThrow<Kind<Kind<EitherT<?, ?, ?>, F>, Throwable>> {
 
   static <F> EitherTMonadThrowFromMonadThrow<F> instance(MonadThrow<F> monadThrowF) {
     return () -> monadThrowF;
   }
 }
 
-interface EitherTDefer<F, E> extends Defer<Kind<Kind<EitherT_, F>, E>> {
+interface EitherTDefer<F, E> extends Defer<Kind<Kind<EitherT<?, ?, ?>, F>, E>> {
 
   MonadDefer<F> monadF();
 
   @Override
-  default <A> EitherT<F, E, A> defer(Producer<? extends Kind<Kind<Kind<EitherT_, F>, E>, ? extends A>> defer) {
+  default <A> EitherT<F, E, A> defer(Producer<? extends Kind<Kind<Kind<EitherT<?, ?, ?>, F>, E>, ? extends A>> defer) {
     return EitherT.of(monadF(), monadF().defer(() -> defer.map(EitherTOf::<F, E, A>narrowK).get().value()));
   }
 }
 
-interface EitherTBracket<F, E> extends Bracket<Kind<Kind<EitherT_, F>, E>, E> {
+interface EitherTBracket<F, E> extends Bracket<Kind<Kind<EitherT<?, ?, ?>, F>, E>, E> {
 
   MonadDefer<F> monadF();
 
@@ -172,9 +171,9 @@ interface EitherTBracket<F, E> extends Bracket<Kind<Kind<EitherT_, F>, E>, E> {
 
   @Override
   default <A, B> EitherT<F, E, B>
-          bracket(Kind<Kind<Kind<EitherT_, F>, E>, ? extends A> acquire,
-                  Function1<? super A, ? extends Kind<Kind<Kind<EitherT_, F>, E>, ? extends B>> use,
-                  Function1<? super A, ? extends Kind<Kind<Kind<EitherT_, F>, E>, Unit>> release) {
+          bracket(Kind<Kind<Kind<EitherT<?, ?, ?>, F>, E>, ? extends A> acquire,
+                  Function1<? super A, ? extends Kind<Kind<Kind<EitherT<?, ?, ?>, F>, E>, ? extends B>> use,
+                  Function1<? super A, ? extends Kind<Kind<Kind<EitherT<?, ?, ?>, F>, E>, Unit>> release) {
     Kind<F, Either<E, B>> bracket =
         monadF().bracket(
             acquire.fix(EitherTOf::<F, E, A>narrowK).value(),
@@ -182,7 +181,7 @@ interface EitherTBracket<F, E> extends Bracket<Kind<Kind<EitherT_, F>, E>, E> {
                 this::acquireRecover,
                 value -> use.andThen(EitherTOf::<F, E, B>narrowK).apply(value).value()),
             either -> {
-              Kind<Kind<Kind<EitherT_, F>, E>, Unit> fold = either.fold(error -> EitherT.left(monadF(), error), release);
+              Kind<Kind<Kind<EitherT<?, ?, ?>, F>, E>, Unit> fold = either.fold(error -> EitherT.left(monadF(), error), release);
               Kind<F, Either<E, Unit>> value = fold.fix(toEitherT()).value();
               return monadF().map(value, x -> x.fold(cons(unit()), identity()));
             });
@@ -190,7 +189,7 @@ interface EitherTBracket<F, E> extends Bracket<Kind<Kind<EitherT_, F>, E>, E> {
   }
 }
 
-interface EitherTTimer<F> extends Timer<Kind<Kind<EitherT_, F>, Throwable>> {
+interface EitherTTimer<F> extends Timer<Kind<Kind<EitherT<?, ?, ?>, F>, Throwable>> {
 
   MonadDefer<F> monadF();
 
@@ -205,7 +204,7 @@ interface EitherTMonadDefer<F>
             EitherTDefer<F, Throwable>,
             EitherTBracket<F, Throwable>,
             EitherTTimer<F>,
-            MonadDefer<Kind<Kind<EitherT_, F>, Throwable>> {
+            MonadDefer<Kind<Kind<EitherT<?, ?, ?>, F>, Throwable>> {
 
   static <F> EitherTMonadDefer<F> instance(MonadDefer<F> monadDeferF) {
     return () -> monadDeferF;
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/EvalInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/EvalInstances.java
index 8af5af966..6d1f350e5 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/EvalInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/EvalInstances.java
@@ -9,7 +9,6 @@
 import com.github.tonivade.purefun.core.Producer;
 import com.github.tonivade.purefun.type.Eval;
 import com.github.tonivade.purefun.type.EvalOf;
-import com.github.tonivade.purefun.type.Eval_;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.typeclasses.Applicative;
 import com.github.tonivade.purefun.typeclasses.Comonad;
@@ -21,49 +20,49 @@
 
 public interface EvalInstances {
 
-  static Functor<Eval_> functor() {
+  static Functor<Eval<?>> functor() {
     return EvalFunctor.INSTANCE;
   }
 
-  static Applicative<Eval_> applicative() {
+  static Applicative<Eval<?>> applicative() {
     return EvalApplicative.INSTANCE;
   }
 
-  static Monad<Eval_> monad() {
+  static Monad<Eval<?>> monad() {
     return EvalMonad.INSTANCE;
   }
 
-  static MonadError<Eval_, Throwable> monadError() {
+  static MonadError<Eval<?>, Throwable> monadError() {
     return EvalMonadError.INSTANCE;
   }
 
-  static MonadThrow<Eval_> monadThrow() {
+  static MonadThrow<Eval<?>> monadThrow() {
     return EvalMonadThrow.INSTANCE;
   }
 
-  static Comonad<Eval_> comonad() {
+  static Comonad<Eval<?>> comonad() {
     return EvalComonad.INSTANCE;
   }
 
-  static Defer<Eval_> defer() {
+  static Defer<Eval<?>> defer() {
     return EvalDefer.INSTANCE;
   }
 }
 
-interface EvalFunctor extends Functor<Eval_> {
+interface EvalFunctor extends Functor<Eval<?>> {
 
   EvalFunctor INSTANCE = new EvalFunctor() {};
 
   @Override
-  default <T, R> Eval<R> map(Kind<Eval_, ? extends T> value, Function1<? super T, ? extends R> mapper) {
+  default <T, R> Eval<R> map(Kind<Eval<?>, ? extends T> value, Function1<? super T, ? extends R> mapper) {
     return EvalOf.narrowK(value).map(mapper);
   }
 }
 
-interface EvalPure extends Applicative<Eval_> {
+interface EvalPure extends Applicative<Eval<?>> {
 
   @Override
-  default <T> Kind<Eval_, T> pure(T value) {
+  default <T> Kind<Eval<?>, T> pure(T value) {
     return Eval.now(value);
   }
 }
@@ -73,65 +72,65 @@ interface EvalApplicative extends EvalPure {
   EvalApplicative INSTANCE = new EvalApplicative() {};
 
   @Override
-  default <T, R> Kind<Eval_, R> ap(Kind<Eval_, ? extends T> value,
-      Kind<Eval_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Kind<Eval<?>, R> ap(Kind<Eval<?>, ? extends T> value,
+      Kind<Eval<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return EvalOf.narrowK(value).flatMap(t -> EvalOf.narrowK(apply).map(f -> f.apply(t)));
   }
 }
 
-interface EvalMonad extends EvalPure, Monad<Eval_> {
+interface EvalMonad extends EvalPure, Monad<Eval<?>> {
 
   EvalMonad INSTANCE = new EvalMonad() {};
 
   @Override
-  default <T, R> Kind<Eval_, R> flatMap(Kind<Eval_, ? extends T> value, Function1<? super T, ? extends Kind<Eval_, ? extends R>> map) {
+  default <T, R> Kind<Eval<?>, R> flatMap(Kind<Eval<?>, ? extends T> value, Function1<? super T, ? extends Kind<Eval<?>, ? extends R>> map) {
     return EvalOf.narrowK(value).flatMap(map.andThen(EvalOf::<R>narrowK));
   }
 }
 
-interface EvalMonadError extends EvalMonad, MonadError<Eval_, Throwable> {
+interface EvalMonadError extends EvalMonad, MonadError<Eval<?>, Throwable> {
 
   EvalMonadError INSTANCE = new EvalMonadError() {};
 
   @Override
-  default <A> Kind<Eval_, A> raiseError(Throwable error) {
+  default <A> Kind<Eval<?>, A> raiseError(Throwable error) {
     return Eval.raiseError(error);
   }
 
   @Override
-  default <A> Kind<Eval_, A> handleErrorWith(
-      Kind<Eval_, A> value, Function1<? super Throwable, ? extends Kind<Eval_, ? extends A>> handler) {
+  default <A> Kind<Eval<?>, A> handleErrorWith(
+      Kind<Eval<?>, A> value, Function1<? super Throwable, ? extends Kind<Eval<?>, ? extends A>> handler) {
     Eval<Try<A>> attempt = Eval.always(() -> Try.of(value.fix(EvalOf::narrowK)::value));
     return attempt.flatMap(try_ -> try_.fold(handler.andThen(EvalOf::narrowK), Eval::now));
   }
 }
 
-interface EvalMonadThrow extends EvalMonadError, MonadThrow<Eval_> {
+interface EvalMonadThrow extends EvalMonadError, MonadThrow<Eval<?>> {
 
   EvalMonadThrow INSTANCE = new EvalMonadThrow() {};
 }
 
-interface EvalComonad extends EvalFunctor, Comonad<Eval_> {
+interface EvalComonad extends EvalFunctor, Comonad<Eval<?>> {
 
   EvalComonad INSTANCE = new EvalComonad() {};
 
   @Override
-  default <A, B> Kind<Eval_, B> coflatMap(Kind<Eval_, ? extends A> value, Function1<? super Kind<Eval_, ? extends A>, ? extends B> map) {
+  default <A, B> Kind<Eval<?>, B> coflatMap(Kind<Eval<?>, ? extends A> value, Function1<? super Kind<Eval<?>, ? extends A>, ? extends B> map) {
     return Eval.later(() -> map.apply(value));
   }
 
   @Override
-  default <A> A extract(Kind<Eval_, ? extends A> value) {
+  default <A> A extract(Kind<Eval<?>, ? extends A> value) {
     return EvalOf.narrowK(value).value();
   }
 }
 
-interface EvalDefer extends Defer<Eval_> {
+interface EvalDefer extends Defer<Eval<?>> {
 
   EvalDefer INSTANCE = new EvalDefer() {};
 
   @Override
-  default <A> Kind<Eval_, A> defer(Producer<? extends Kind<Eval_, ? extends A>> defer) {
+  default <A> Kind<Eval<?>, A> defer(Producer<? extends Kind<Eval<?>, ? extends A>> defer) {
     return Eval.defer(defer.map(EvalOf::narrowK));
   }
 }
\ No newline at end of file
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/Function1Instances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/Function1Instances.java
index 93c7713f7..ab09e38e9 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/Function1Instances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/Function1Instances.java
@@ -9,7 +9,6 @@
 import static com.github.tonivade.purefun.typeclasses.Conested.counnest;
 
 import com.github.tonivade.purefun.core.Function1Of;
-import com.github.tonivade.purefun.core.Function1_;
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.typeclasses.Applicative;
@@ -22,41 +21,41 @@
 @SuppressWarnings("unchecked")
 public interface Function1Instances {
 
-  static <T> Functor<Kind<Function1_, T>> functor() {
+  static <T> Functor<Kind<Function1<?, ?>, T>> functor() {
     return Function1Functor.INSTANCE;
   }
 
-  static <T> Applicative<Kind<Function1_, T>> applicative() {
+  static <T> Applicative<Kind<Function1<?, ?>, T>> applicative() {
     return Function1Applicative.INSTANCE;
   }
 
-  static <T> Monad<Kind<Function1_, T>> monad() {
+  static <T> Monad<Kind<Function1<?, ?>, T>> monad() {
     return Function1Monad.INSTANCE;
   }
 
-  static <T> Contravariant<Conested<Function1_, T>> contravariant() {
+  static <T> Contravariant<Conested<Function1<?, ?>, T>> contravariant() {
     return Function1Contravariant.INSTANCE;
   }
 
-  static Profunctor<Function1_> profunctor() {
+  static Profunctor<Function1<?, ?>> profunctor() {
     return Function1Profunctor.INSTANCE;
   }
 }
 
-interface Function1Functor<T> extends Functor<Kind<Function1_, T>> {
+interface Function1Functor<T> extends Functor<Kind<Function1<?, ?>, T>> {
 
   @SuppressWarnings("rawtypes")
   Function1Functor INSTANCE = new Function1Functor() {};
 
   @Override
-  default <A, R> Function1<T, R> map(Kind<Kind<Function1_, T>, ? extends A> value,
+  default <A, R> Function1<T, R> map(Kind<Kind<Function1<?, ?>, T>, ? extends A> value,
       Function1<? super A, ? extends R> map) {
     Function1<T, A> function = value.fix(Function1Of::narrowK);
     return function.andThen(map);
   }
 }
 
-interface Function1Pure<T> extends Applicative<Kind<Function1_, T>> {
+interface Function1Pure<T> extends Applicative<Kind<Function1<?, ?>, T>> {
 
   @Override
   default <A> Function1<T, A> pure(A value) {
@@ -70,45 +69,45 @@ interface Function1Applicative<T> extends Function1Pure<T> {
   Function1Applicative INSTANCE = new Function1Applicative() {};
 
   @Override
-  default <A, R> Function1<T, R> ap(Kind<Kind<Function1_, T>, ? extends A> value,
-      Kind<Kind<Function1_, T>, ? extends Function1<? super A, ? extends R>> apply) {
+  default <A, R> Function1<T, R> ap(Kind<Kind<Function1<?, ?>, T>, ? extends A> value,
+      Kind<Kind<Function1<?, ?>, T>, ? extends Function1<? super A, ? extends R>> apply) {
     return value.fix(toFunction1())
         .flatMap(a -> apply.fix(Function1Of::narrowK).andThen(f -> f.apply(a)));
   }
 }
 
-interface Function1Monad<T> extends Function1Pure<T>, Monad<Kind<Function1_, T>> {
+interface Function1Monad<T> extends Function1Pure<T>, Monad<Kind<Function1<?, ?>, T>> {
 
   @SuppressWarnings("rawtypes")
   Function1Monad INSTANCE = new Function1Monad() {};
 
   @Override
-  default <A, R> Function1<T, R> flatMap(Kind<Kind<Function1_, T>, ? extends A> value,
-      Function1<? super A, ? extends Kind<Kind<Function1_, T>, ? extends R>> map) {
+  default <A, R> Function1<T, R> flatMap(Kind<Kind<Function1<?, ?>, T>, ? extends A> value,
+      Function1<? super A, ? extends Kind<Kind<Function1<?, ?>, T>, ? extends R>> map) {
     Function1<T, A> function = value.fix(Function1Of::narrowK);
     return function.flatMap(map.andThen(Function1Of::narrowK));
   }
 }
 
-interface Function1Contravariant<R> extends Contravariant<Conested<Function1_, R>> {
+interface Function1Contravariant<R> extends Contravariant<Conested<Function1<?, ?>, R>> {
 
   @SuppressWarnings("rawtypes")
   Function1Contravariant INSTANCE = new Function1Contravariant() {};
 
   @Override
-  default <A, B> Kind<Conested<Function1_, R>, B> contramap(Kind<Conested<Function1_, R>, ? extends A> value, Function1<? super B, ? extends A> map) {
-    Kind<Kind<Function1_, A>, R> counnest = counnest(value);
+  default <A, B> Kind<Conested<Function1<?, ?>, R>, B> contramap(Kind<Conested<Function1<?, ?>, R>, ? extends A> value, Function1<? super B, ? extends A> map) {
+    Kind<Kind<Function1<?, ?>, A>, R> counnest = counnest(value);
     Function1<A, R> function = counnest.fix(Function1Of::narrowK);
     return conest(function.compose(map));
   }
 }
 
-interface Function1Profunctor extends Profunctor<Function1_> {
+interface Function1Profunctor extends Profunctor<Function1<?, ?>> {
 
   Function1Profunctor INSTANCE = new Function1Profunctor() {};
 
   @Override
-  default <A, B, C, D> Function1<C, D> dimap(Kind<Kind<Function1_, A>, ? extends B> value, Function1<? super C, ? extends A> contramap, Function1<? super B, ? extends D> map) {
+  default <A, B, C, D> Function1<C, D> dimap(Kind<Kind<Function1<?, ?>, A>, ? extends B> value, Function1<? super C, ? extends A> contramap, Function1<? super B, ? extends D> map) {
     return value.fix(Function1Of::<A, B>narrowK).dimap(contramap, map);
   }
 }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/FutureInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/FutureInstances.java
index 17a07ac3b..0b0feb7a3 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/FutureInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/FutureInstances.java
@@ -13,7 +13,6 @@
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.concurrent.Future;
 import com.github.tonivade.purefun.concurrent.FutureOf;
-import com.github.tonivade.purefun.concurrent.Future_;
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.typeclasses.Applicative;
 import com.github.tonivade.purefun.typeclasses.Functor;
@@ -23,41 +22,41 @@
 
 public interface FutureInstances {
 
-  static Functor<Future_> functor() {
+  static Functor<Future<?>> functor() {
     return FutureFunctor.INSTANCE;
   }
 
-  static Applicative<Future_> applicative() {
+  static Applicative<Future<?>> applicative() {
     return applicative(Future.DEFAULT_EXECUTOR);
   }
 
-  static Applicative<Future_> applicative(Executor executor) {
+  static Applicative<Future<?>> applicative(Executor executor) {
     return FutureApplicative.instance(checkNonNull(executor));
   }
 
-  static Monad<Future_> monad() {
+  static Monad<Future<?>> monad() {
     return monad(Future.DEFAULT_EXECUTOR);
   }
 
-  static Monad<Future_> monad(Executor executor) {
+  static Monad<Future<?>> monad(Executor executor) {
     return FutureMonad.instance(checkNonNull(executor));
   }
 
-  static MonadError<Future_, Throwable> monadError() {
+  static MonadError<Future<?>, Throwable> monadError() {
     return monadError(Future.DEFAULT_EXECUTOR);
   }
 
-  static MonadError<Future_, Throwable> monadError(Executor executor) {
+  static MonadError<Future<?>, Throwable> monadError(Executor executor) {
     return FutureMonadThrow.instance(checkNonNull(executor));
   }
 }
 
-interface FutureFunctor extends Functor<Future_> {
+interface FutureFunctor extends Functor<Future<?>> {
 
   FutureFunctor INSTANCE = new FutureFunctor() {};
 
   @Override
-  default <T, R> Kind<Future_, R> map(Kind<Future_, ? extends T> value, Function1<? super T, ? extends R> mapper) {
+  default <T, R> Kind<Future<?>, R> map(Kind<Future<?>, ? extends T> value, Function1<? super T, ? extends R> mapper) {
     return value.fix(toFuture()).map(mapper);
   }
 }
@@ -66,10 +65,10 @@ interface ExecutorHolder {
   Executor executor();
 }
 
-interface FuturePure extends Applicative<Future_>, ExecutorHolder {
+interface FuturePure extends Applicative<Future<?>>, ExecutorHolder {
 
   @Override
-  default <T> Kind<Future_, T> pure(T value) {
+  default <T> Kind<Future<?>, T> pure(T value) {
     return Future.success(executor(), value);
   }
 }
@@ -81,21 +80,21 @@ static FutureApplicative instance(Executor executor) {
   }
 
   @Override
-  default <T, R> Kind<Future_, R> ap(Kind<Future_, ? extends T> value, 
-      Kind<Future_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Kind<Future<?>, R> ap(Kind<Future<?>, ? extends T> value,
+      Kind<Future<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return value.fix(FutureOf::<T>narrowK).ap(apply.fix(FutureOf::narrowK));
   }
 }
 
-interface FutureMonad extends FuturePure, Monad<Future_> {
+interface FutureMonad extends FuturePure, Monad<Future<?>> {
 
   static FutureMonad instance(Executor executor) {
     return () -> executor;
   }
 
   @Override
-  default <T, R> Kind<Future_, R> flatMap(Kind<Future_, ? extends T> value,
-      Function1<? super T, ? extends Kind<Future_, ? extends R>> map) {
+  default <T, R> Kind<Future<?>, R> flatMap(Kind<Future<?>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Future<?>, ? extends R>> map) {
     return value.fix(toFuture()).flatMap(map.andThen(FutureOf::narrowK));
   }
 
@@ -104,27 +103,27 @@ default <T, R> Kind<Future_, R> flatMap(Kind<Future_, ? extends T> value,
    * applicative version of the ap method
    */
   @Override
-  default <T, R> Kind<Future_, R> ap(Kind<Future_, ? extends T> value, 
-      Kind<Future_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Kind<Future<?>, R> ap(Kind<Future<?>, ? extends T> value,
+      Kind<Future<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return FutureInstances.applicative(executor()).ap(value, apply);
   }
 }
 
-interface FutureMonadThrow extends FutureMonad, MonadThrow<Future_> {
+interface FutureMonadThrow extends FutureMonad, MonadThrow<Future<?>> {
 
   static FutureMonadThrow instance(Executor executor) {
     return () -> executor;
   }
 
   @Override
-  default <A> Kind<Future_, A> raiseError(Throwable error) {
+  default <A> Kind<Future<?>, A> raiseError(Throwable error) {
     return Future.failure(executor(), error);
   }
 
   @Override
-  default <A> Kind<Future_, A> handleErrorWith(
-      Kind<Future_, A> value,
-      Function1<? super Throwable, ? extends Kind<Future_, ? extends A>> handler) {
+  default <A> Kind<Future<?>, A> handleErrorWith(
+      Kind<Future<?>, A> value,
+      Function1<? super Throwable, ? extends Kind<Future<?>, ? extends A>> handler) {
     return value.fix(toFuture()).fold(handler.andThen(FutureOf::narrowK),
                                       success -> Future.success(executor(), success)).flatMap(identity());
   }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/IOInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/IOInstances.java
index 8ea47aba1..23c835481 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/IOInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/IOInstances.java
@@ -18,7 +18,6 @@
 import com.github.tonivade.purefun.data.Sequence;
 import com.github.tonivade.purefun.monad.IO;
 import com.github.tonivade.purefun.monad.IOOf;
-import com.github.tonivade.purefun.monad.IO_;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.typeclasses.Applicative;
@@ -38,70 +37,70 @@
 
 public interface IOInstances {
 
-  static Functor<IO_> functor() {
+  static Functor<IO<?>> functor() {
     return IOFunctor.INSTANCE;
   }
 
-  static Applicative<IO_> applicative() {
+  static Applicative<IO<?>> applicative() {
     return applicative(Future.DEFAULT_EXECUTOR);
   }
 
-  static Applicative<IO_> applicative(Executor executor) {
+  static Applicative<IO<?>> applicative(Executor executor) {
     return IOApplicative.instance(executor);
   }
 
-  static Monad<IO_> monad() {
+  static Monad<IO<?>> monad() {
     return IOMonad.INSTANCE;
   }
 
-  static MonadError<IO_, Throwable> monadError() {
+  static MonadError<IO<?>, Throwable> monadError() {
     return IOMonadError.INSTANCE;
   }
 
-  static MonadThrow<IO_> monadThrow() {
+  static MonadThrow<IO<?>> monadThrow() {
     return IOMonadThrow.INSTANCE;
   }
 
-  static Timer<IO_> timer() {
+  static Timer<IO<?>> timer() {
     return IOMonadDefer.INSTANCE;
   }
 
-  static MonadDefer<IO_> monadDefer() {
+  static MonadDefer<IO<?>> monadDefer() {
     return IOMonadDefer.INSTANCE;
   }
 
-  static Async<IO_> async() {
+  static Async<IO<?>> async() {
     return IOAsync.INSTANCE;
   }
 
-  static Concurrent<IO_> concurrent() {
+  static Concurrent<IO<?>> concurrent() {
     return concurrent(Future.DEFAULT_EXECUTOR);
   }
 
-  static Concurrent<IO_> concurrent(Executor executor) {
+  static Concurrent<IO<?>> concurrent(Executor executor) {
     return IOConcurrent.instance(executor);
   }
 
-  static Console<IO_> console() {
+  static Console<IO<?>> console() {
     return IOConsole.INSTANCE;
   }
-  
-  static Runtime<IO_> runtime() {
+
+  static Runtime<IO<?>> runtime() {
     return IORuntime.INSTANCE;
   }
 }
 
-interface IOFunctor extends Functor<IO_> {
+interface IOFunctor extends Functor<IO<?>> {
 
   IOFunctor INSTANCE = new IOFunctor() {};
 
   @Override
-  default <T, R> Kind<IO_, R> map(Kind<IO_, ? extends T> value, Function1<? super T, ? extends R> map) {
+  default <T, R> Kind<IO<?>, R> map(Kind<IO<?>, ? extends T> value, Function1<? super T, ? extends R> map) {
     return value.fix(toIO()).map(map);
   }
 }
 
-interface IOPure extends Applicative<IO_> {
+interface IOPure extends Applicative<IO<?>> {
 
   @Override
   default <T> IO<T> pure(T value) {
@@ -109,8 +108,8 @@ default <T> IO<T> pure(T value) {
   }
 }
 
-interface IOApplicative extends IOPure, Applicative<IO_> {
-  
+interface IOApplicative extends IOPure, Applicative<IO<?>> {
+
   static IOApplicative instance(Executor executor) {
     return () -> executor;
   }
@@ -118,25 +117,25 @@ static IOApplicative instance(Executor executor) {
   Executor executor();
 
   @Override
-  default <T, R> IO<R> ap(Kind<IO_, ? extends T> value, 
-      Kind<IO_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> IO<R> ap(Kind<IO<?>, ? extends T> value,
+      Kind<IO<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return IO.parMap2(executor(), value.fix(toIO()), apply.fix(toIO()), (v, a) -> a.apply(v));
   }
 }
 
-interface IOMonad extends Monad<IO_>, IOPure {
+interface IOMonad extends Monad<IO<?>>, IOPure {
 
   IOMonad INSTANCE = new IOMonad() {};
 
   @Override
   default <T, R> IO<R> flatMap(
-      Kind<IO_, ? extends T> value, 
-      Function1<? super T, ? extends Kind<IO_, ? extends R>> map) {
+      Kind<IO<?>, ? extends T> value,
+      Function1<? super T, ? extends Kind<IO<?>, ? extends R>> map) {
     return value.fix(toIO()).flatMap(map.andThen(IOOf::narrowK));
   }
 }
 
-interface IOMonadError extends MonadError<IO_, Throwable>, IOMonad {
+interface IOMonadError extends MonadError<IO<?>, Throwable>, IOMonad {
 
   IOMonadError INSTANCE = new IOMonadError() {};
 
@@ -147,37 +146,37 @@ default <A> IO<A> raiseError(Throwable error) {
 
   @Override
   default <A> IO<A> handleErrorWith(
-      Kind<IO_, A> value, 
-      Function1<? super Throwable, ? extends Kind<IO_, ? extends A>> handler) {
+      Kind<IO<?>, A> value,
+      Function1<? super Throwable, ? extends Kind<IO<?>, ? extends A>> handler) {
     return IOOf.narrowK(value).redeemWith(handler.andThen(IOOf::narrowK), IO::pure);
   }
 }
 
-interface IOMonadThrow extends MonadThrow<IO_>, IOMonadError {
+interface IOMonadThrow extends MonadThrow<IO<?>>, IOMonadError {
 
   IOMonadThrow INSTANCE = new IOMonadThrow() {};
 }
 
-interface IODefer extends Defer<IO_> {
+interface IODefer extends Defer<IO<?>> {
 
   @Override
-  default <A> IO<A> defer(Producer<? extends Kind<IO_, ? extends A>> defer) {
+  default <A> IO<A> defer(Producer<? extends Kind<IO<?>, ? extends A>> defer) {
     return IO.suspend(defer.map(IOOf::narrowK));
   }
 }
 
-interface IOBracket extends IOMonadError, Bracket<IO_, Throwable> {
+interface IOBracket extends IOMonadError, Bracket<IO<?>, Throwable> {
 
   @Override
   default <A, B> IO<B> bracket(
-      Kind<IO_, ? extends A> acquire, 
-      Function1<? super A, ? extends Kind<IO_, ? extends B>> use, 
-      Function1<? super A, ? extends Kind<IO_, Unit>> release) {
+      Kind<IO<?>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<IO<?>, ? extends B>> use,
+      Function1<? super A, ? extends Kind<IO<?>, Unit>> release) {
     return IO.bracket(acquire, use, release);
   }
 }
 
-interface IOMonadDefer extends MonadDefer<IO_>, IODefer, IOBracket {
+interface IOMonadDefer extends MonadDefer<IO<?>>, IODefer, IOBracket {
 
   IOMonadDefer INSTANCE = new IOMonadDefer() {};
 
@@ -187,37 +186,37 @@ default IO<Unit> sleep(Duration duration) {
   }
 }
 
-interface IOAsync extends Async<IO_>, IOMonadDefer {
+interface IOAsync extends Async<IO<?>>, IOMonadDefer {
 
   IOAsync INSTANCE = new IOAsync() {};
-  
+
   @Override
-  default <A> IO<A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<IO_, Unit>> consumer) {
+  default <A> IO<A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<IO<?>, Unit>> consumer) {
     return IO.cancellable(consumer.andThen(IOOf::narrowK));
   }
 }
 
-interface IOConcurrent extends Concurrent<IO_>, IOAsync {
-  
+interface IOConcurrent extends Concurrent<IO<?>>, IOAsync {
+
   static IOConcurrent instance(Executor executor) {
     return () -> executor;
   }
-  
+
   Executor executor();
-  
+
   @Override
-  default <A, B> IO<Either<Tuple2<A, Fiber<IO_, B>>, Tuple2<Fiber<IO_, A>, B>>> racePair(Kind<IO_, ? extends A> fa, Kind<IO_, ? extends B> fb) {
+  default <A, B> IO<Either<Tuple2<A, Fiber<IO<?>, B>>, Tuple2<Fiber<IO<?>, A>, B>>> racePair(Kind<IO<?>, ? extends A> fa, Kind<IO<?>, ? extends B> fb) {
     return IO.racePair(executor(), fa, fb);
   }
-  
+
   @Override
-  default <A> IO<Fiber<IO_, A>> fork(Kind<IO_, ? extends A> value) {
+  default <A> IO<Fiber<IO<?>, A>> fork(Kind<IO<?>, ? extends A> value) {
     IO<A> fix = value.fix(IOOf::narrowK);
     return fix.fork();
   }
 }
 
-final class IOConsole implements Console<IO_> {
+final class IOConsole implements Console<IO<?>> {
 
   public static final IOConsole INSTANCE = new IOConsole();
 
@@ -234,27 +233,27 @@ public IO<Unit> println(String text) {
   }
 }
 
-interface IORuntime extends Runtime<IO_> {
-  
+interface IORuntime extends Runtime<IO<?>> {
+
   IORuntime INSTANCE = new IORuntime() {};
 
   @Override
-  default <T> T run(Kind<IO_, T> value) {
+  default <T> T run(Kind<IO<?>, T> value) {
     return value.fix(toIO()).unsafeRunSync();
   }
-  
+
   @Override
-  default <T> Sequence<T> run(Sequence<Kind<IO_, T>> values) {
+  default <T> Sequence<T> run(Sequence<Kind<IO<?>, T>> values) {
     return run(IO.traverse(values.map(IOOf::<T>narrowK)));
   }
 
   @Override
-  default <T> Future<T> parRun(Kind<IO_, T> value, Executor executor) {
+  default <T> Future<T> parRun(Kind<IO<?>, T> value, Executor executor) {
     return value.fix(toIO()).runAsync(executor);
   }
-  
+
   @Override
-  default <T> Future<Sequence<T>> parRun(Sequence<Kind<IO_, T>> values, Executor executor) {
+  default <T> Future<Sequence<T>> parRun(Sequence<Kind<IO<?>, T>> values, Executor executor) {
     return parRun(IO.traverse(values.map(IOOf::<T>narrowK)), executor);
   }
 }
\ No newline at end of file
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/IdInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/IdInstances.java
index 2d716a447..c2affd711 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/IdInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/IdInstances.java
@@ -15,7 +15,6 @@
 import com.github.tonivade.purefun.type.EvalOf;
 import com.github.tonivade.purefun.type.Id;
 import com.github.tonivade.purefun.type.IdOf;
-import com.github.tonivade.purefun.type.Id_;
 import com.github.tonivade.purefun.typeclasses.Applicative;
 import com.github.tonivade.purefun.typeclasses.Comonad;
 import com.github.tonivade.purefun.typeclasses.Foldable;
@@ -25,49 +24,49 @@
 
 public interface IdInstances {
 
-  static <T> Eq<Kind<Id_, T>> eq(Eq<T> idEq) {
+  static <T> Eq<Kind<Id<?>, T>> eq(Eq<T> idEq) {
     return (a, b) -> idEq.eqv(IdOf.narrowK(a).value(), IdOf.narrowK(b).value());
   }
 
-  static Functor<Id_> functor() {
+  static Functor<Id<?>> functor() {
     return IdFunctor.INSTANCE;
   }
 
-  static Applicative<Id_> applicative() {
+  static Applicative<Id<?>> applicative() {
     return IdApplicative.INSTANCE;
   }
 
-  static Monad<Id_> monad() {
+  static Monad<Id<?>> monad() {
     return IdMonad.INSTANCE;
   }
 
-  static Comonad<Id_> comonad() {
+  static Comonad<Id<?>> comonad() {
     return IdComonad.INSTANCE;
   }
 
-  static Foldable<Id_> foldable() {
+  static Foldable<Id<?>> foldable() {
     return IdFoldable.INSTANCE;
   }
 
-  static Traverse<Id_> traverse() {
+  static Traverse<Id<?>> traverse() {
     return IdTraverse.INSTANCE;
   }
 }
 
-interface IdFunctor extends Functor<Id_> {
+interface IdFunctor extends Functor<Id<?>> {
 
   IdFunctor INSTANCE = new IdFunctor() {};
 
   @Override
-  default <T, R> Kind<Id_, R> map(Kind<Id_, ? extends T> value, Function1<? super T, ? extends R> map) {
+  default <T, R> Kind<Id<?>, R> map(Kind<Id<?>, ? extends T> value, Function1<? super T, ? extends R> map) {
     return IdOf.narrowK(value).map(map);
   }
 }
 
-interface IdPure extends Applicative<Id_> {
+interface IdPure extends Applicative<Id<?>> {
 
   @Override
-  default <T> Kind<Id_, T> pure(T value) {
+  default <T> Kind<Id<?>, T> pure(T value) {
     return Id.of(value);
   }
 }
@@ -77,59 +76,59 @@ interface IdApplicative extends IdPure {
   IdApplicative INSTANCE = new IdApplicative() {};
 
   @Override
-  default <T, R> Kind<Id_, R> ap(Kind<Id_, ? extends T> value, 
-      Kind<Id_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Kind<Id<?>, R> ap(Kind<Id<?>, ? extends T> value,
+      Kind<Id<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return IdOf.narrowK(value).flatMap(t -> IdOf.narrowK(apply).map(f -> f.apply(t)));
   }
 }
 
-interface IdMonad extends IdPure, Monad<Id_> {
+interface IdMonad extends IdPure, Monad<Id<?>> {
 
   IdMonad INSTANCE = new IdMonad() {};
 
   @Override
-  default <T, R> Kind<Id_, R> flatMap(Kind<Id_, ? extends T> value, Function1<? super T, ? extends Kind<Id_, ? extends R>> map) {
+  default <T, R> Kind<Id<?>, R> flatMap(Kind<Id<?>, ? extends T> value, Function1<? super T, ? extends Kind<Id<?>, ? extends R>> map) {
     return IdOf.narrowK(value).flatMap(map.andThen(IdOf::narrowK));
   }
 }
 
-interface IdComonad extends IdFunctor, Comonad<Id_> {
+interface IdComonad extends IdFunctor, Comonad<Id<?>> {
 
   IdComonad INSTANCE = new IdComonad() {};
 
   @Override
-  default <A, B> Kind<Id_, B> coflatMap(Kind<Id_, ? extends A> value, Function1<? super Kind<Id_, ? extends A>, ? extends B> map) {
+  default <A, B> Kind<Id<?>, B> coflatMap(Kind<Id<?>, ? extends A> value, Function1<? super Kind<Id<?>, ? extends A>, ? extends B> map) {
     return Id.of(map.apply(value));
   }
 
   @Override
-  default <A> A extract(Kind<Id_, ? extends A> value) {
+  default <A> A extract(Kind<Id<?>, ? extends A> value) {
     return IdOf.narrowK(value).value();
   }
 }
 
-interface IdFoldable extends Foldable<Id_> {
+interface IdFoldable extends Foldable<Id<?>> {
 
   IdFoldable INSTANCE = new IdFoldable() {};
 
   @Override
-  default <A, B> B foldLeft(Kind<Id_, ? extends A> value, B initial, Function2<? super B, ? super A, ? extends B> mapper) {
+  default <A, B> B foldLeft(Kind<Id<?>, ? extends A> value, B initial, Function2<? super B, ? super A, ? extends B> mapper) {
     return mapper.apply(initial, value.fix(toId()).value());
   }
 
   @Override
-  default <A, B> Eval<B> foldRight(Kind<Id_, ? extends A> value, Eval<? extends B> initial, Function2<? super A, ? super Eval<? extends B>, ? extends Eval<? extends B>> mapper) {
+  default <A, B> Eval<B> foldRight(Kind<Id<?>, ? extends A> value, Eval<? extends B> initial, Function2<? super A, ? super Eval<? extends B>, ? extends Eval<? extends B>> mapper) {
     return EvalOf.narrowK(mapper.apply(value.fix(toId()).value(), initial));
   }
 }
 
-interface IdTraverse extends Traverse<Id_>, IdFoldable {
+interface IdTraverse extends Traverse<Id<?>>, IdFoldable {
 
   IdTraverse INSTANCE = new IdTraverse() {};
 
   @Override
-  default <G, T, R> Kind<G, Kind<Id_, R>> traverse(
-      Applicative<G> applicative, Kind<Id_, T> value,
+  default <G, T, R> Kind<G, Kind<Id<?>, R>> traverse(
+      Applicative<G> applicative, Kind<Id<?>, T> value,
       Function1<? super T, ? extends Kind<G, ? extends R>> mapper) {
     Kind<G, ? extends R> apply = mapper.apply(value.fix(toId()).value());
     return applicative.map(apply, Id::of);
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/KleisliInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/KleisliInstances.java
index 429b31ee2..a11c678fd 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/KleisliInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/KleisliInstances.java
@@ -13,7 +13,6 @@
 import com.github.tonivade.purefun.core.Unit;
 import com.github.tonivade.purefun.transformer.Kleisli;
 import com.github.tonivade.purefun.transformer.KleisliOf;
-import com.github.tonivade.purefun.transformer.Kleisli_;
 import com.github.tonivade.purefun.typeclasses.Monad;
 import com.github.tonivade.purefun.typeclasses.MonadError;
 import com.github.tonivade.purefun.typeclasses.MonadReader;
@@ -21,24 +20,24 @@
 
 public interface KleisliInstances {
 
-  static <F, Z> Monad<Kind<Kind<Kleisli_, F>, Z>> monad(Monad<F> monadF) {
+  static <F, Z> Monad<Kind<Kind<Kleisli<?, ?, ?>, F>, Z>> monad(Monad<F> monadF) {
     return KleisliMonad.instance(checkNonNull(monadF));
   }
 
-  static <F, Z, E> MonadError<Kind<Kind<Kleisli_, F>, Z>, E> monadError(MonadError<F, E> monadErrorF) {
+  static <F, Z, E> MonadError<Kind<Kind<Kleisli<?, ?, ?>, F>, Z>, E> monadError(MonadError<F, E> monadErrorF) {
     return KleisliMonadError.instance(monadErrorF);
   }
 
-  static <F, Z> MonadReader<Kind<Kind<Kleisli_, F>, Z>, Z> monadReader(Monad<F> monadF) {
+  static <F, Z> MonadReader<Kind<Kind<Kleisli<?, ?, ?>, F>, Z>, Z> monadReader(Monad<F> monadF) {
     return KleisliMonadReader.instance(monadF);
   }
 
-  static <F, Z, S> MonadState<Kind<Kind<Kleisli_, F>, Z>, S> monadState(MonadState<F, S> monadStateF) {
+  static <F, Z, S> MonadState<Kind<Kind<Kleisli<?, ?, ?>, F>, Z>, S> monadState(MonadState<F, S> monadStateF) {
     return KleisliMonadState.instance(monadStateF);
   }
 }
 
-interface KleisliMonad<F, Z> extends Monad<Kind<Kind<Kleisli_, F>, Z>> {
+interface KleisliMonad<F, Z> extends Monad<Kind<Kind<Kleisli<?, ?, ?>, F>, Z>> {
 
   static <F, Z> KleisliMonad<F, Z> instance(Monad<F> monadF) {
     return () -> monadF;
@@ -52,13 +51,13 @@ default <T> Kleisli<F, Z, T> pure(T value) {
   }
 
   @Override
-  default <T, R> Kleisli<F, Z, R> flatMap(Kind<Kind<Kind<Kleisli_, F>, Z>, ? extends T> value,
-      Function1<? super T, ? extends Kind<Kind<Kind<Kleisli_, F>, Z>, ? extends R>> map) {
+  default <T, R> Kleisli<F, Z, R> flatMap(Kind<Kind<Kind<Kleisli<?, ?, ?>, F>, Z>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Kind<Kind<Kleisli<?, ?, ?>, F>, Z>, ? extends R>> map) {
     return value.fix(toKleisli()).flatMap(map.andThen(KleisliOf::narrowK));
   }
 }
 
-interface KleisliMonadError<F, R, E> extends MonadError<Kind<Kind<Kleisli_, F>, R>, E>, KleisliMonad<F, R> {
+interface KleisliMonadError<F, R, E> extends MonadError<Kind<Kind<Kleisli<?, ?, ?>, F>, R>, E>, KleisliMonad<F, R> {
 
   static <F, R, E> KleisliMonadError<F, R, E> instance(MonadError<F, E> monadErrorF) {
     return () -> monadErrorF;
@@ -74,8 +73,8 @@ default <A> Kleisli<F, R, A> raiseError(E error) {
 
   @Override
   default <A> Kleisli<F, R, A> handleErrorWith(
-      Kind<Kind<Kind<Kleisli_, F>, R>, A> value,
-      Function1<? super E, ? extends Kind<Kind<Kind<Kleisli_, F>, R>, ? extends A>> handler) {
+      Kind<Kind<Kind<Kleisli<?, ?, ?>, F>, R>, A> value,
+      Function1<? super E, ? extends Kind<Kind<Kind<Kleisli<?, ?, ?>, F>, R>, ? extends A>> handler) {
     Kleisli<F, R, A> kleisli = value.fix(KleisliOf::narrowK);
     return Kleisli.of(monadF(),
         reader -> monadF().handleErrorWith(kleisli.run(reader),
@@ -83,7 +82,7 @@ default <A> Kleisli<F, R, A> handleErrorWith(
   }
 }
 
-interface KleisliMonadReader<F, R> extends MonadReader<Kind<Kind<Kleisli_, F>, R>, R>, KleisliMonad<F, R> {
+interface KleisliMonadReader<F, R> extends MonadReader<Kind<Kind<Kleisli<?, ?, ?>, F>, R>, R>, KleisliMonad<F, R> {
 
   static <F, Z> KleisliMonadReader<F, Z> instance(Monad<F> monadF) {
     return () -> monadF;
@@ -95,7 +94,7 @@ default Kleisli<F, R, R> ask() {
   }
 }
 
-interface KleisliMonadState<F, R, S> extends MonadState<Kind<Kind<Kleisli_, F>, R>, S>, KleisliMonad<F, R> {
+interface KleisliMonadState<F, R, S> extends MonadState<Kind<Kind<Kleisli<?, ?, ?>, F>, R>, S>, KleisliMonad<F, R> {
 
   static <F, R, S> KleisliMonadState<F, R, S> instance(MonadState<F, S> monadStateF) {
     return () -> monadStateF;
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/MonadMTL.java b/instances/src/main/java/com/github/tonivade/purefun/instances/MonadMTL.java
index 4037b9dd5..7f3bb8c94 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/MonadMTL.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/MonadMTL.java
@@ -16,16 +16,11 @@
 import com.github.tonivade.purefun.core.Tuple2;
 import com.github.tonivade.purefun.core.Unit;
 import com.github.tonivade.purefun.instances.MonadMTL.EffectE;
-import com.github.tonivade.purefun.instances.MonadMTL.EffectE_;
 import com.github.tonivade.purefun.instances.MonadMTL.EffectR;
-import com.github.tonivade.purefun.instances.MonadMTL.EffectR_;
-import com.github.tonivade.purefun.instances.MonadMTL.EffectS_;
+import com.github.tonivade.purefun.instances.MonadMTL.EffectS;
 import com.github.tonivade.purefun.transformer.EitherT;
-import com.github.tonivade.purefun.transformer.EitherT_;
 import com.github.tonivade.purefun.transformer.Kleisli;
-import com.github.tonivade.purefun.transformer.Kleisli_;
 import com.github.tonivade.purefun.transformer.StateT;
-import com.github.tonivade.purefun.transformer.StateT_;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.typeclasses.Monad;
 import com.github.tonivade.purefun.typeclasses.MonadError;
@@ -33,14 +28,17 @@
 import com.github.tonivade.purefun.typeclasses.MonadState;
 
 public class MonadMTL<F, S, R, E>
-    implements Monad<EffectS_>, MonadError<EffectS_, E>, MonadState<EffectS_, S>, MonadReader<EffectS_, R> {
+    implements Monad<EffectS<?, ?, ?, ?, ?>>,
+      MonadError<EffectS<?, ?, ?, ?, ?>, E>,
+      MonadState<EffectS<?, ?, ?, ?, ?>, S>,
+      MonadReader<EffectS<?, ?, ?, ?, ?>, R> {
 
   private final Monad<F> monad;
-  private final MonadError<EffectE_, E> monadErrorE;
-  private final Monad<EffectR_> monadR;
-  private final MonadError<Kind<Kind<StateT_, EffectR_>, S>, E> monadErrorS;
-  private final MonadReader<Kind<Kind<StateT_, EffectR_>, S>, R> monadReaderS;
-  private final MonadState<Kind<Kind<StateT_, EffectR_>, S>, S> monadStateS;
+  private final MonadError<EffectE<?, ?, ?>, E> monadErrorE;
+  private final Monad<EffectR<?, ?, ?, ?>> monadR;
+  private final MonadError<Kind<Kind<StateT<?, ?, ?>, EffectR<?, ?, ?, ?>>, S>, E> monadErrorS;
+  private final MonadReader<Kind<Kind<StateT<?, ?, ?>, EffectR<?, ?, ?, ?>>, S>, R> monadReaderS;
+  private final MonadState<Kind<Kind<StateT<?, ?, ?>, EffectR<?, ?, ?, ?>>, S>, S> monadStateS;
 
   public MonadMTL(Monad<F> monad) {
     this.monad = checkNonNull(monad);
@@ -57,8 +55,8 @@ public <A> EffectS<F, S, R, E, A> pure(A value) {
   }
 
   @Override
-  public <A, B> EffectS<F, S, R, E, B> flatMap(Kind<EffectS_, ? extends A> value,
-      Function1<? super A, ? extends Kind<EffectS_, ? extends B>> map) {
+  public <A, B> EffectS<F, S, R, E, B> flatMap(Kind<EffectS<?, ?, ?, ?, ?>, ? extends A> value,
+      Function1<? super A, ? extends Kind<EffectS<?, ?, ?, ?, ?>, ? extends B>> map) {
     return new EffectS<>(monadStateS.flatMap(
         value.fix(EffectS::<F, S, R, E, A>narrowK).value(),
         x -> map.apply(x).fix(EffectS::<F, S, R, E, B>narrowK).value()));
@@ -81,7 +79,7 @@ public <A> EffectS<F, S, R, E, A> raiseError(E error) {
 
   @Override
   public <A> EffectS<F, S, R, E, A> handleErrorWith(
-      Kind<EffectS_, A> value, Function1<? super E, ? extends Kind<EffectS_, ? extends A>> handler) {
+      Kind<EffectS<?, ?, ?, ?, ?>, A> value, Function1<? super E, ? extends Kind<EffectS<?, ?, ?, ?, ?>, ? extends A>> handler) {
     return new EffectS<>(monadErrorS.handleErrorWith(
         value.fix(EffectS::<F, S, R, E, A>narrowK).value(),
         error -> handler.apply(error).fix(EffectS::<F, S, R, E, A>narrowK).value()));
@@ -108,15 +106,11 @@ public <A> EffectS<F, S, R, E, A> effect(Kind<F, Either<E, A>> value) {
     return effectS(effectR(effectE(value)));
   }
 
-  public static final class EffectE_ { }
-  public static final class EffectR_ { }
-  public static final class EffectS_ { }
-
-  public static final class EffectE<F, E, A> implements Kind<EffectE_, A> {
+  public static final class EffectE<F, E, A> implements Kind<EffectE<?, ?, ?>, A> {
 
     private final EitherT<F, E, A> value;
 
-    public EffectE(Kind<Kind<Kind<EitherT_, F>, E>, A> value) {
+    public EffectE(Kind<Kind<Kind<EitherT<?, ?, ?>, F>, E>, A> value) {
       this.value = value.fix(toEitherT());
     }
 
@@ -129,20 +123,20 @@ public Kind<F, Either<E, A>> run() {
     }
 
     @SuppressWarnings("unchecked")
-    public static <F, E, A> EffectE<F, E, A> narrowK(Kind<EffectE_, ? extends A> hkt) {
+    public static <F, E, A> EffectE<F, E, A> narrowK(Kind<EffectE<?, ?, ?>, ? extends A> hkt) {
       return (EffectE<F, E, A>) hkt;
     }
   }
 
-  public static final class EffectR<F, R, E, A> implements Kind<EffectR_, A> {
+  public static final class EffectR<F, R, E, A> implements Kind<EffectR<?, ?, ?, ?>, A> {
 
-    private final Kleisli<EffectE_, R, A> value;
+    private final Kleisli<EffectE<?, ?, ?>, R, A> value;
 
-    public EffectR(Kind<Kind<Kind<Kleisli_, EffectE_>, R>, A> value) {
+    public EffectR(Kind<Kind<Kind<Kleisli<?, ?, ?>, EffectE<?, ?, ?>>, R>, A> value) {
       this.value = value.fix(toKleisli());
     }
 
-    public Kleisli<EffectE_, R, A> value() {
+    public Kleisli<EffectE<?, ?, ?>, R, A> value() {
       return value;
     }
 
@@ -151,20 +145,20 @@ public EffectE<F, E, A> run(R config) {
     }
 
     @SuppressWarnings("unchecked")
-    public static <F, R, E, A> EffectR<F, R, E, A> narrowK(Kind<EffectR_, ? extends A> hkt) {
+    public static <F, R, E, A> EffectR<F, R, E, A> narrowK(Kind<EffectR<?, ?, ?, ?>, ? extends A> hkt) {
       return (EffectR<F, R, E, A>) hkt;
     }
   }
 
-  public static final class EffectS<F, S, R, E, A> implements Kind<EffectS_, A> {
+  public static final class EffectS<F, S, R, E, A> implements Kind<EffectS<?, ?, ?, ?, ?>, A> {
 
-    private final StateT<EffectR_, S, A> value;
+    private final StateT<EffectR<?, ?, ?, ?>, S, A> value;
 
-    public EffectS(Kind<Kind<Kind<StateT_, EffectR_>, S>, A> value) {
+    public EffectS(Kind<Kind<Kind<StateT<?, ?, ?>, EffectR<?, ?, ?, ?>>, S>, A> value) {
       this.value = value.fix(toStateT());
     }
 
-    public StateT<EffectR_, S, A> value() {
+    public StateT<EffectR<?, ?, ?, ?>, S, A> value() {
       return value;
     }
 
@@ -173,15 +167,15 @@ public EffectR<F, R, E, Tuple2<S, A>> run(S state) {
     }
 
     @SuppressWarnings("unchecked")
-    public static <F, S, R, E, A> EffectS<F, S, R, E, A> narrowK(Kind<EffectS_, ? extends A> hkt) {
+    public static <F, S, R, E, A> EffectS<F, S, R, E, A> narrowK(Kind<EffectS<?, ?, ?, ?, ?>, ? extends A> hkt) {
       return (EffectS<F, S, R, E, A>) hkt;
     }
   }
 }
 
-class EffectEMonadError<F, E> implements MonadError<EffectE_, E> {
+class EffectEMonadError<F, E> implements MonadError<EffectE<?, ?, ?>, E> {
 
-  private final MonadError<Kind<Kind<EitherT_, F>, E>, E> monad;
+  private final MonadError<Kind<Kind<EitherT<?, ?, ?>, F>, E>, E> monad;
 
   public EffectEMonadError(Monad<F> monad) {
     this.monad = EitherTInstances.monadError(monad);
@@ -193,8 +187,8 @@ public <A> EffectE<F, E, A> pure(A value) {
   }
 
   @Override
-  public <A, B> EffectE<F, E, B> flatMap(Kind<EffectE_, ? extends A> value,
-      Function1<? super A, ? extends Kind<EffectE_, ? extends B>> map) {
+  public <A, B> EffectE<F, E, B> flatMap(Kind<EffectE<?, ?, ?>, ? extends A> value,
+      Function1<? super A, ? extends Kind<EffectE<?, ?, ?>, ? extends B>> map) {
     return new EffectE<>(monad.flatMap(
         value.fix(EffectE::<F, E, A>narrowK).value(),
         x -> map.apply(x).fix(EffectE::<F, E, B>narrowK).value()));
@@ -206,16 +200,16 @@ public <A> EffectE<F, E, A> raiseError(E error) {
   }
 
   @Override
-  public <A> EffectE<F, E, A> handleErrorWith(Kind<EffectE_, A> value,
-      Function1<? super E, ? extends Kind<EffectE_, ? extends A>> handler) {
+  public <A> EffectE<F, E, A> handleErrorWith(Kind<EffectE<?, ?, ?>, A> value,
+      Function1<? super E, ? extends Kind<EffectE<?, ?, ?>, ? extends A>> handler) {
     return new EffectE<>(monad.handleErrorWith(value.fix(EffectE::<F, E, A>narrowK).value(),
             error -> handler.apply(error).fix(EffectE::<F, E, A>narrowK).value()));
   }
 }
 
-class EffectRMonad<F, R, E> implements Monad<EffectR_> {
+class EffectRMonad<F, R, E> implements Monad<EffectR<?, ?, ?, ?>> {
 
-  private final Monad<Kind<Kind<Kleisli_, EffectE_>, R>> monad;
+  private final Monad<Kind<Kind<Kleisli<?, ?, ?>, EffectE<?, ?, ?>>, R>> monad;
 
   public EffectRMonad(Monad<F> monad) {
     this.monad = KleisliInstances.monad(new EffectEMonadError<F, E>(monad));
@@ -228,16 +222,16 @@ public <A> EffectR<F, R, E, A> pure(A value) {
   }
 
   @Override
-  public <A, B> EffectR<F, R, E, B> flatMap(Kind<EffectR_, ? extends A> value,
-      Function1<? super A, ? extends Kind<EffectR_, ? extends B>> map) {
+  public <A, B> EffectR<F, R, E, B> flatMap(Kind<EffectR<?, ?, ?, ?>, ? extends A> value,
+      Function1<? super A, ? extends Kind<EffectR<?, ?, ?, ?>, ? extends B>> map) {
     return new EffectR<>(monad.flatMap(value.fix(EffectR::<F, R, E, A>narrowK).value(),
         t -> map.apply(t).fix(EffectR::<F, R, E, B>narrowK).value()));
   }
 }
 
-class EffectRMonadReader<F, R, E> extends EffectRMonad<F, E, R> implements MonadReader<EffectR_, R> {
+class EffectRMonadReader<F, R, E> extends EffectRMonad<F, E, R> implements MonadReader<EffectR<?, ?, ?, ?>, R> {
 
-  private final MonadReader<Kind<Kind<Kleisli_, EffectE_>, R>, R> monad;
+  private final MonadReader<Kind<Kind<Kleisli<?, ?, ?>, EffectE<?, ?, ?>>, R>, R> monad;
 
   public EffectRMonadReader(Monad<F> monad) {
     super(monad);
@@ -250,9 +244,9 @@ public EffectR<F, R, E, R> ask() {
   }
 }
 
-class EffectRMonadError<F, R, E> extends EffectRMonad<F, R, E> implements MonadError<EffectR_, E> {
+class EffectRMonadError<F, R, E> extends EffectRMonad<F, R, E> implements MonadError<EffectR<?, ?, ?, ?>, E> {
 
-  private final MonadError<Kind<Kind<Kleisli_, EffectE_>, R>, E> monadError;
+  private final MonadError<Kind<Kind<Kleisli<?, ?, ?>, EffectE<?, ?, ?>>, R>, E> monadError;
 
   public EffectRMonadError(Monad<F> monad) {
     super(monad);
@@ -266,7 +260,7 @@ public <A> EffectR<F, R, E, A> raiseError(E error) {
 
   @Override
   public <A> EffectR<F, R, E, A> handleErrorWith(
-      Kind<EffectR_, A> value, Function1<? super E, ? extends Kind<EffectR_, ? extends A>> handler) {
+      Kind<EffectR<?, ?, ?, ?>, A> value, Function1<? super E, ? extends Kind<EffectR<?, ?, ?, ?>, ? extends A>> handler) {
     return new EffectR<>(monadError.handleErrorWith(
         value.fix(EffectR::<F, R, E, A>narrowK).value(),
         error -> handler.apply(error).fix(EffectR::<F, R, E, A>narrowK).value()));
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/OptionInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/OptionInstances.java
index a3ede8eef..92173d91a 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/OptionInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/OptionInstances.java
@@ -22,7 +22,6 @@
 import com.github.tonivade.purefun.type.EvalOf;
 import com.github.tonivade.purefun.type.Option;
 import com.github.tonivade.purefun.type.OptionOf;
-import com.github.tonivade.purefun.type.Option_;
 import com.github.tonivade.purefun.typeclasses.Alternative;
 import com.github.tonivade.purefun.typeclasses.Applicative;
 import com.github.tonivade.purefun.typeclasses.Foldable;
@@ -36,7 +35,7 @@
 
 public interface OptionInstances {
 
-  static <T> Eq<Kind<Option_, T>> eq(Eq<T> eqSome) {
+  static <T> Eq<Kind<Option<?>, T>> eq(Eq<T> eqSome) {
     return (a, b) -> {
       if (a instanceof Option.Some<T>(var valueA) && b instanceof Option.Some<T>(var valueB)) {
         return eqSome.eqv(valueA, valueB);
@@ -45,53 +44,53 @@ static <T> Eq<Kind<Option_, T>> eq(Eq<T> eqSome) {
     };
   }
 
-  static Functor<Option_> functor() {
+  static Functor<Option<?>> functor() {
     return OptionFunctor.INSTANCE;
   }
 
-  static Applicative<Option_> applicative() {
+  static Applicative<Option<?>> applicative() {
     return OptionApplicative.INSTANCE;
   }
 
-  static Alternative<Option_> alternative() {
+  static Alternative<Option<?>> alternative() {
     return OptionAlternative.INSTANCE;
   }
 
-  static Monad<Option_> monad() {
+  static Monad<Option<?>> monad() {
     return OptionMonad.INSTANCE;
   }
 
-  static MonadError<Option_, Unit> monadError() {
+  static MonadError<Option<?>, Unit> monadError() {
     return OptionMonadError.INSTANCE;
   }
 
-  static Traverse<Option_> traverse() {
+  static Traverse<Option<?>> traverse() {
     return OptionTraverse.INSTANCE;
   }
 
-  static Semigroupal<Option_> semigroupal() {
+  static Semigroupal<Option<?>> semigroupal() {
     return OptionSemigroupal.INSTANCE;
   }
 
-  static Foldable<Option_> foldable() {
+  static Foldable<Option<?>> foldable() {
     return OptionFoldable.INSTANCE;
   }
 }
 
-interface OptionFunctor extends Functor<Option_> {
+interface OptionFunctor extends Functor<Option<?>> {
 
   OptionFunctor INSTANCE = new OptionFunctor() {};
 
   @Override
-  default <T, R> Kind<Option_, R> map(Kind<Option_, ? extends T> value, Function1<? super T, ? extends R> mapper) {
+  default <T, R> Kind<Option<?>, R> map(Kind<Option<?>, ? extends T> value, Function1<? super T, ? extends R> mapper) {
     return OptionOf.narrowK(value).map(mapper);
   }
 }
 
-interface OptionPure extends Applicative<Option_> {
+interface OptionPure extends Applicative<Option<?>> {
 
   @Override
-  default <T> Kind<Option_, T> pure(T value) {
+  default <T> Kind<Option<?>, T> pure(T value) {
     return Option.some(value);
   }
 }
@@ -101,28 +100,28 @@ interface OptionApplicative extends OptionPure {
   OptionApplicative INSTANCE = new OptionApplicative() {};
 
   @Override
-  default <T, R> Kind<Option_, R> ap(Kind<Option_, ? extends T> value,
-      Kind<Option_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Kind<Option<?>, R> ap(Kind<Option<?>, ? extends T> value,
+      Kind<Option<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return value.fix(toOption()).flatMap(t -> OptionOf.narrowK(apply).map(f -> f.apply(t)));
   }
 }
 
-interface OptionMonad extends OptionPure, Monad<Option_> {
+interface OptionMonad extends OptionPure, Monad<Option<?>> {
 
   OptionMonad INSTANCE = new OptionMonad() {};
 
   @Override
-  default <T, R> Kind<Option_, R> flatMap(Kind<Option_, ? extends T> value,
-      Function1<? super T, ? extends Kind<Option_, ? extends R>> map) {
+  default <T, R> Kind<Option<?>, R> flatMap(Kind<Option<?>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Option<?>, ? extends R>> map) {
     return value.fix(toOption()).flatMap(map.andThen(OptionOf::narrowK));
   }
 
   @Override
-  default <T, R> Kind<Option_, R> tailRecM(T value, Function1<T, ? extends Kind<Option_, Either<T, R>>> map) {
+  default <T, R> Kind<Option<?>, R> tailRecM(T value, Function1<T, ? extends Kind<Option<?>, Either<T, R>>> map) {
     return loop(value, map).run();
   }
 
-  private <T, R> Trampoline<Kind<Option_, R>> loop(T value, Function1<T, ? extends Kind<Option_, Either<T, R>>> map) {
+  private <T, R> Trampoline<Kind<Option<?>, R>> loop(T value, Function1<T, ? extends Kind<Option<?>, Either<T, R>>> map) {
     return switch (map.andThen(OptionOf::narrowK).apply(value)) {
       case Option.None<Either<T, R>> n -> Trampoline.done(Option.none());
       case Option.Some<Either<T, R>>(Either.Right<T, R>(var right)) -> Trampoline.done(Option.some(right));
@@ -131,71 +130,71 @@ private <T, R> Trampoline<Kind<Option_, R>> loop(T value, Function1<T, ? extends
   }
 }
 
-interface OptionSemigroupK extends SemigroupK<Option_> {
+interface OptionSemigroupK extends SemigroupK<Option<?>> {
 
   OptionSemigroupK INSTANCE = new OptionSemigroupK() {};
 
   @Override
-  default <T> Kind<Option_, T> combineK(Kind<Option_, ? extends T> t1, Kind<Option_, ? extends T> t2) {
+  default <T> Kind<Option<?>, T> combineK(Kind<Option<?>, ? extends T> t1, Kind<Option<?>, ? extends T> t2) {
     return OptionOf.narrowK(t1).fold(cons(OptionOf.narrowK(t2)), Option::some);
   }
 }
 
-interface OptionMonoidK extends OptionSemigroupK, MonoidK<Option_> {
+interface OptionMonoidK extends OptionSemigroupK, MonoidK<Option<?>> {
 
   OptionMonoidK INSTANCE = new OptionMonoidK() {};
 
   @Override
-  default <T> Kind<Option_, T> zero() {
+  default <T> Kind<Option<?>, T> zero() {
     return Option.none();
   }
 }
 
-interface OptionAlternative extends OptionMonoidK, OptionApplicative, Alternative<Option_> {
+interface OptionAlternative extends OptionMonoidK, OptionApplicative, Alternative<Option<?>> {
 
   OptionAlternative INSTANCE = new OptionAlternative() {};
 }
 
-interface OptionMonadError extends OptionMonad, MonadError<Option_, Unit> {
+interface OptionMonadError extends OptionMonad, MonadError<Option<?>, Unit> {
 
   OptionMonadError INSTANCE = new OptionMonadError() {};
 
   @Override
-  default <A> Kind<Option_, A> raiseError(Unit error) {
+  default <A> Kind<Option<?>, A> raiseError(Unit error) {
     return Option.none();
   }
 
   @Override
-  default <A> Kind<Option_, A> handleErrorWith(Kind<Option_, A> value,
-      Function1<? super Unit, ? extends Kind<Option_, ? extends A>> handler) {
+  default <A> Kind<Option<?>, A> handleErrorWith(Kind<Option<?>, A> value,
+      Function1<? super Unit, ? extends Kind<Option<?>, ? extends A>> handler) {
     return OptionOf.narrowK(value).fold(() -> OptionOf.narrowK(handler.apply(unit())), this::pure);
   }
 }
 
-interface OptionFoldable extends Foldable<Option_> {
+interface OptionFoldable extends Foldable<Option<?>> {
 
   OptionFoldable INSTANCE = new OptionFoldable() {};
 
   @Override
-  default <A, B> B foldLeft(Kind<Option_, ? extends A> value, B initial, Function2<? super B, ? super A, ? extends B> mapper) {
+  default <A, B> B foldLeft(Kind<Option<?>, ? extends A> value, B initial, Function2<? super B, ? super A, ? extends B> mapper) {
     return OptionOf.narrowK(value).fold(cons(initial), a -> mapper.apply(initial, a));
   }
 
   @Override
-  default <A, B> Eval<B> foldRight(Kind<Option_, ? extends A> value, Eval<? extends B> initial,
+  default <A, B> Eval<B> foldRight(Kind<Option<?>, ? extends A> value, Eval<? extends B> initial,
       Function2<? super A, ? super Eval<? extends B>, ? extends Eval<? extends B>> mapper) {
     return OptionOf.<A>narrowK(value).fold(
         cons(initial).andThen(EvalOf::<B>narrowK), a -> mapper.andThen(EvalOf::<B>narrowK).apply(a, initial));
   }
 }
 
-interface OptionTraverse extends Traverse<Option_>, OptionFoldable {
+interface OptionTraverse extends Traverse<Option<?>>, OptionFoldable {
 
   OptionTraverse INSTANCE = new OptionTraverse() {};
 
   @Override
-  default <G, T, R> Kind<G, Kind<Option_, R>> traverse(
-      Applicative<G> applicative, Kind<Option_, T> value,
+  default <G, T, R> Kind<G, Kind<Option<?>, R>> traverse(
+      Applicative<G> applicative, Kind<Option<?>, T> value,
       Function1<? super T, ? extends Kind<G, ? extends R>> mapper) {
     return value.fix(toOption()).fold(
         () -> applicative.pure(Option.<R>none().kind()),
@@ -206,12 +205,12 @@ default <G, T, R> Kind<G, Kind<Option_, R>> traverse(
   }
 }
 
-interface OptionSemigroupal extends Semigroupal<Option_> {
+interface OptionSemigroupal extends Semigroupal<Option<?>> {
 
   OptionSemigroupal INSTANCE = new OptionSemigroupal() {};
 
   @Override
-  default <A, B> Kind<Option_, Tuple2<A, B>> product(Kind<Option_, ? extends A> fa, Kind<Option_, ? extends B> fb) {
+  default <A, B> Kind<Option<?>, Tuple2<A, B>> product(Kind<Option<?>, ? extends A> fa, Kind<Option<?>, ? extends B> fb) {
     return OptionOf.narrowK(fa).flatMap(a -> OptionOf.narrowK(fb).map(b -> Tuple.of(a, b)));
   }
 }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/OptionTInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/OptionTInstances.java
index 54350d5b7..253cb82c1 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/OptionTInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/OptionTInstances.java
@@ -20,7 +20,6 @@
 import com.github.tonivade.purefun.core.Unit;
 import com.github.tonivade.purefun.transformer.OptionT;
 import com.github.tonivade.purefun.transformer.OptionTOf;
-import com.github.tonivade.purefun.transformer.OptionT_;
 import com.github.tonivade.purefun.type.Option;
 import com.github.tonivade.purefun.typeclasses.Bracket;
 import com.github.tonivade.purefun.typeclasses.Defer;
@@ -32,36 +31,36 @@
 
 public interface OptionTInstances {
 
-  static <F, T> Eq<Kind<Kind<OptionT_, F>, T>> eq(Eq<Kind<F, Option<T>>> eq) {
+  static <F, T> Eq<Kind<Kind<OptionT<?, ?>, F>, T>> eq(Eq<Kind<F, Option<T>>> eq) {
     return (a, b) -> eq.eqv(OptionTOf.narrowK(a).value(), OptionTOf.narrowK(b).value());
   }
 
-  static <F> Monad<Kind<OptionT_, F>> monad(Monad<F> monadF) {
+  static <F> Monad<Kind<OptionT<?, ?>, F>> monad(Monad<F> monadF) {
     return OptionTMonad.instance(checkNonNull(monadF));
   }
 
-  static <F> MonadError<Kind<OptionT_, F>, Unit> monadError(Monad<F> monadF) {
+  static <F> MonadError<Kind<OptionT<?, ?>, F>, Unit> monadError(Monad<F> monadF) {
     return OptionTMonadErrorFromMonad.instance(checkNonNull(monadF));
   }
 
-  static <F, E> MonadError<Kind<OptionT_, F>, E> monadError(MonadError<F, E> monadErrorF) {
+  static <F, E> MonadError<Kind<OptionT<?, ?>, F>, E> monadError(MonadError<F, E> monadErrorF) {
     return OptionTMonadErrorFromMonadError.instance(checkNonNull(monadErrorF));
   }
 
-  static <F> MonadThrow<Kind<OptionT_, F>> monadThrow(MonadThrow<F> monadThrowF) {
+  static <F> MonadThrow<Kind<OptionT<?, ?>, F>> monadThrow(MonadThrow<F> monadThrowF) {
     return OptionTMonadThrow.instance(checkNonNull(checkNonNull(monadThrowF)));
   }
 
-  static <F> MonadDefer<Kind<OptionT_, F>> monadDefer(MonadDefer<F> monadDeferF) {
+  static <F> MonadDefer<Kind<OptionT<?, ?>, F>> monadDefer(MonadDefer<F> monadDeferF) {
     return OptionTMonadDefer.instance(checkNonNull(monadDeferF));
   }
 
-  static <F, A> Reference<Kind<OptionT_, F>, A> ref(MonadDefer<F> monadF, A value) {
+  static <F, A> Reference<Kind<OptionT<?, ?>, F>, A> ref(MonadDefer<F> monadF, A value) {
     return Reference.of(monadDefer(monadF), value);
   }
 }
 
-interface OptionTMonad<F> extends Monad<Kind<OptionT_, F>> {
+interface OptionTMonad<F> extends Monad<Kind<OptionT<?, ?>, F>> {
 
   static <F> OptionTMonad<F> instance(Monad<F> monadF) {
     return () -> monadF;
@@ -75,14 +74,14 @@ default <T> OptionT<F, T> pure(T value) {
   }
 
   @Override
-  default <T, R> OptionT<F, R> flatMap(Kind<Kind<OptionT_, F>, ? extends T> value,
-      Function1<? super T, ? extends Kind<Kind<OptionT_, F>, ? extends R>> map) {
+  default <T, R> OptionT<F, R> flatMap(Kind<Kind<OptionT<?, ?>, F>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Kind<OptionT<?, ?>, F>, ? extends R>> map) {
     return OptionTOf.narrowK(value).flatMap(map.andThen(OptionTOf::narrowK));
   }
 }
 
 interface OptionTMonadErrorFromMonad<F>
-    extends MonadError<Kind<OptionT_, F>, Unit>, OptionTMonad<F> {
+    extends MonadError<Kind<OptionT<?, ?>, F>, Unit>, OptionTMonad<F> {
 
   static <F> OptionTMonadErrorFromMonad<F> instance(Monad<F> monadF) {
     return () -> monadF;
@@ -94,8 +93,8 @@ default <A> OptionT<F, A> raiseError(Unit error) {
   }
 
   @Override
-  default <A> OptionT<F, A> handleErrorWith(Kind<Kind<OptionT_, F>, A> value,
-      Function1<? super Unit, ? extends Kind<Kind<OptionT_, F>, ? extends A>> handler) {
+  default <A> OptionT<F, A> handleErrorWith(Kind<Kind<OptionT<?, ?>, F>, A> value,
+      Function1<? super Unit, ? extends Kind<Kind<OptionT<?, ?>, F>, ? extends A>> handler) {
     return OptionT.of(monadF(),
         monadF().flatMap(OptionTOf.narrowK(value).value(),
             option -> option.fold(
@@ -105,7 +104,7 @@ default <A> OptionT<F, A> handleErrorWith(Kind<Kind<OptionT_, F>, A> value,
 }
 
 interface OptionTMonadErrorFromMonadError<F, E>
-    extends MonadError<Kind<OptionT_, F>, E>, OptionTMonad<F> {
+    extends MonadError<Kind<OptionT<?, ?>, F>, E>, OptionTMonad<F> {
 
   static <F, E> OptionTMonadErrorFromMonadError<F, E> instance(MonadError<F, E> monadF) {
     return () -> monadF;
@@ -120,8 +119,8 @@ default <A> OptionT<F, A> raiseError(E error) {
   }
 
   @Override
-  default <A> OptionT<F, A> handleErrorWith(Kind<Kind<OptionT_, F>, A> value,
-      Function1<? super E, ? extends Kind<Kind<OptionT_, F>, ? extends A>> handler) {
+  default <A> OptionT<F, A> handleErrorWith(Kind<Kind<OptionT<?, ?>, F>, A> value,
+      Function1<? super E, ? extends Kind<Kind<OptionT<?, ?>, F>, ? extends A>> handler) {
     return OptionT.of(monadF(),
       monadF().handleErrorWith(
         OptionTOf.narrowK(value).value(), error -> handler.andThen(OptionTOf::<F, A>narrowK).apply(error).value()));
@@ -129,7 +128,7 @@ default <A> OptionT<F, A> handleErrorWith(Kind<Kind<OptionT_, F>, A> value,
 }
 
 interface OptionTMonadThrow<F>
-    extends MonadThrow<Kind<OptionT_, F>>,
+    extends MonadThrow<Kind<OptionT<?, ?>, F>>,
             OptionTMonadErrorFromMonadError<F, Throwable> {
 
   static <F> OptionTMonadThrow<F> instance(MonadThrow<F> monadThrowF) {
@@ -137,25 +136,25 @@ static <F> OptionTMonadThrow<F> instance(MonadThrow<F> monadThrowF) {
   }
 }
 
-interface OptionTDefer<F> extends Defer<Kind<OptionT_, F>> {
+interface OptionTDefer<F> extends Defer<Kind<OptionT<?, ?>, F>> {
 
   MonadDefer<F> monadF();
 
   @Override
-  default <A> OptionT<F, A> defer(Producer<? extends Kind<Kind<OptionT_, F>, ? extends A>> defer) {
+  default <A> OptionT<F, A> defer(Producer<? extends Kind<Kind<OptionT<?, ?>, F>, ? extends A>> defer) {
     return OptionT.of(monadF(), monadF().defer(() -> defer.map(OptionTOf::<F, A>narrowK).get().value()));
   }
 }
 
-interface OptionTBracket<F> extends Bracket<Kind<OptionT_, F>, Throwable> {
+interface OptionTBracket<F> extends Bracket<Kind<OptionT<?, ?>, F>, Throwable> {
 
   Bracket<F, Throwable> monadF();
 
   @Override
   default <A, B> OptionT<F, B> bracket(
-      Kind<Kind<OptionT_, F>, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<Kind<OptionT_, F>, ? extends B>> use,
-      Function1<? super A, ? extends Kind<Kind<OptionT_, F>, Unit>> release) {
+      Kind<Kind<OptionT<?, ?>, F>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<Kind<OptionT<?, ?>, F>, ? extends B>> use,
+      Function1<? super A, ? extends Kind<Kind<OptionT<?, ?>, F>, Unit>> release) {
     Kind<F, Option<B>> bracket =
         monadF().bracket(
             acquire.fix(OptionTOf::<F, A>narrowK).value(),
@@ -163,7 +162,7 @@ default <A, B> OptionT<F, B> bracket(
                 () -> monadF().raiseError(new NoSuchElementException("could not acquire resource")),
                 value -> use.andThen(OptionTOf::<F, B>narrowK).apply(value).value()),
             option -> {
-              Kind<Kind<OptionT_, F>, Unit> fold = option.fold(() -> pure(Unit.unit()), release);
+              Kind<Kind<OptionT<?, ?>, F>, Unit> fold = option.fold(() -> pure(Unit.unit()), release);
               Kind<F, Option<Unit>> value = fold.fix(toOptionT()).value();
               return monadF().map(value, x -> x.fold(Unit::unit, identity()));
             });
@@ -175,7 +174,7 @@ interface OptionTMonadDefer<F>
     extends OptionTMonadThrow<F>,
             OptionTDefer<F>,
             OptionTBracket<F>,
-            MonadDefer<Kind<OptionT_, F>> {
+            MonadDefer<Kind<OptionT<?, ?>, F>> {
 
   static <F> OptionTMonadDefer<F> instance(MonadDefer<F> monadDeferF) {
     return () -> monadDeferF;
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/ParInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/ParInstances.java
index 4103a61ae..6e9bd51d3 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/ParInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/ParInstances.java
@@ -11,7 +11,6 @@
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.concurrent.Par;
 import com.github.tonivade.purefun.concurrent.ParOf;
-import com.github.tonivade.purefun.concurrent.Par_;
 import com.github.tonivade.purefun.core.Consumer1;
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.core.Producer;
@@ -28,46 +27,46 @@
 
 public interface ParInstances {
 
-  static Functor<Par_> functor() {
+  static Functor<Par<?>> functor() {
     return ParFunctor.INSTANCE;
   }
 
-  static Applicative<Par_> applicative() {
+  static Applicative<Par<?>> applicative() {
     return PureApplicative.INSTANCE;
   }
 
-  static Monad<Par_> monad() {
+  static Monad<Par<?>> monad() {
     return ParMonad.INSTANCE;
   }
 
-  static MonadDefer<Par_> monadDefer() {
+  static MonadDefer<Par<?>> monadDefer() {
     return ParMonadDefer.INSTANCE;
   }
 
-  static <A> Reference<Par_, A> reference(A value) {
+  static <A> Reference<Par<?>, A> reference(A value) {
     return Reference.of(monadDefer(), value);
   }
 
-  static <A extends AutoCloseable> Resource<Par_, A> resource(Par<A> acquire) {
+  static <A extends AutoCloseable> Resource<Par<?>, A> resource(Par<A> acquire) {
     return resource(acquire, AutoCloseable::close);
   }
 
-  static <A> Resource<Par_, A> resource(Par<A> acquire, Consumer1<A> release) {
+  static <A> Resource<Par<?>, A> resource(Par<A> acquire, Consumer1<A> release) {
     return Resource.from(monadDefer(), acquire, release);
   }
 }
 
-interface ParFunctor extends Functor<Par_> {
+interface ParFunctor extends Functor<Par<?>> {
 
   ParFunctor INSTANCE = new ParFunctor() {};
 
   @Override
-  default <T, R> Par<R> map(Kind<Par_, ? extends T> value, Function1<? super T, ? extends R> mapper) {
+  default <T, R> Par<R> map(Kind<Par<?>, ? extends T> value, Function1<? super T, ? extends R> mapper) {
     return value.fix(ParOf::narrowK).map(mapper);
   }
 }
 
-interface ParPure extends Applicative<Par_> {
+interface ParPure extends Applicative<Par<?>> {
   @Override
   default <T> Par<T> pure(T value) {
     return Par.success(value);
@@ -79,18 +78,18 @@ interface PureApplicative extends ParPure {
   PureApplicative INSTANCE = new PureApplicative() {};
 
   @Override
-  default <T, R> Par<R> ap(Kind<Par_, ? extends T> value,
-      Kind<Par_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Par<R> ap(Kind<Par<?>, ? extends T> value,
+      Kind<Par<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return value.fix(ParOf::<T>narrowK).ap(apply.fix(ParOf::narrowK));
   }
 }
 
-interface ParMonad extends ParPure, Monad<Par_> {
+interface ParMonad extends ParPure, Monad<Par<?>> {
 
   ParMonad INSTANCE = new ParMonad() {};
 
   @Override
-  default <T, R> Par<R> flatMap(Kind<Par_, ? extends T> value, Function1<? super T, ? extends Kind<Par_, ? extends R>> map) {
+  default <T, R> Par<R> flatMap(Kind<Par<?>, ? extends T> value, Function1<? super T, ? extends Kind<Par<?>, ? extends R>> map) {
     return value.fix(ParOf::narrowK).flatMap(x -> map.apply(x).fix(ParOf::narrowK));
   }
 
@@ -99,13 +98,13 @@ default <T, R> Par<R> flatMap(Kind<Par_, ? extends T> value, Function1<? super T
    * applicative version of the ap method
    */
   @Override
-  default <T, R> Par<R> ap(Kind<Par_, ? extends T> value,
-      Kind<Par_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Par<R> ap(Kind<Par<?>, ? extends T> value,
+      Kind<Par<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return ParInstances.applicative().ap(value, apply).fix(ParOf::narrowK);
   }
 }
 
-interface ParMonadThrow extends ParMonad, MonadThrow<Par_> {
+interface ParMonadThrow extends ParMonad, MonadThrow<Par<?>> {
 
   ParMonadThrow INSTANCE = new ParMonadThrow() {};
 
@@ -115,32 +114,32 @@ default <A> Par<A> raiseError(Throwable error) {
   }
 
   @Override
-  default <A> Par<A> handleErrorWith(Kind<Par_, A> value,
-                                     Function1<? super Throwable, ? extends Kind<Par_, ? extends A>> handler) {
+  default <A> Par<A> handleErrorWith(Kind<Par<?>, A> value,
+                                     Function1<? super Throwable, ? extends Kind<Par<?>, ? extends A>> handler) {
     return ParOf.narrowK(value).fold(handler.andThen(ParOf::narrowK), Par::success).flatMap(identity());
   }
 }
 
-interface ParDefer extends Defer<Par_> {
+interface ParDefer extends Defer<Par<?>> {
 
   @Override
-  default <A> Par<A> defer(Producer<? extends Kind<Par_, ? extends A>> defer) {
+  default <A> Par<A> defer(Producer<? extends Kind<Par<?>, ? extends A>> defer) {
     return Par.defer(defer.map(ParOf::<A>narrowK));
   }
 }
 
-interface ParBracket extends Bracket<Par_, Throwable> {
+interface ParBracket extends Bracket<Par<?>, Throwable> {
 
   @Override
   default <A, B> Par<B> bracket(
-      Kind<Par_, ? extends A> acquire,
-      Function1<? super A, ? extends Kind<Par_, ? extends B>> use,
-      Function1<? super A, ? extends Kind<Par_, Unit>> release) {
+      Kind<Par<?>, ? extends A> acquire,
+      Function1<? super A, ? extends Kind<Par<?>, ? extends B>> use,
+      Function1<? super A, ? extends Kind<Par<?>, Unit>> release) {
     return Par.bracket(ParOf.narrowK(acquire), use.andThen(ParOf::narrowK), release::apply);
   }
 }
 
-interface ParMonadDefer extends ParMonadThrow, ParDefer, ParBracket, MonadDefer<Par_> {
+interface ParMonadDefer extends ParMonadThrow, ParDefer, ParBracket, MonadDefer<Par<?>> {
 
   ParMonadDefer INSTANCE = new ParMonadDefer() {};
 
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/ProducerInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/ProducerInstances.java
index 6c4faa53e..19b266fab 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/ProducerInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/ProducerInstances.java
@@ -6,7 +6,6 @@
 
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.core.ProducerOf;
-import com.github.tonivade.purefun.core.Producer_;
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.core.Producer;
 import com.github.tonivade.purefun.typeclasses.Applicative;
@@ -16,37 +15,37 @@
 
 public interface ProducerInstances {
 
-  static Functor<Producer_> functor() {
+  static Functor<Producer<?>> functor() {
     return ProducerFunctor.INSTANCE;
   }
 
-  static Applicative<Producer_> applicative() {
+  static Applicative<Producer<?>> applicative() {
     return ProducerApplicative.INSTANCE;
   }
 
-  static Monad<Producer_> monad() {
+  static Monad<Producer<?>> monad() {
     return ProducerMonad.INSTANCE;
   }
 
-  static Comonad<Producer_> comonad() {
+  static Comonad<Producer<?>> comonad() {
     return ProducerComonad.INSTANCE;
   }
 }
 
-interface ProducerFunctor extends Functor<Producer_> {
+interface ProducerFunctor extends Functor<Producer<?>> {
 
   ProducerFunctor INSTANCE = new ProducerFunctor() {};
 
   @Override
-  default <T, R> Kind<Producer_, R> map(Kind<Producer_, ? extends T> value, Function1<? super T, ? extends R> mapper) {
+  default <T, R> Kind<Producer<?>, R> map(Kind<Producer<?>, ? extends T> value, Function1<? super T, ? extends R> mapper) {
     return value.fix(ProducerOf::<T>narrowK).map(mapper);
   }
 }
 
-interface ProducerPure extends Applicative<Producer_> {
+interface ProducerPure extends Applicative<Producer<?>> {
 
   @Override
-  default <T> Kind<Producer_, T> pure(T value) {
+  default <T> Kind<Producer<?>, T> pure(T value) {
     return Producer.cons(value);
   }
 }
@@ -56,33 +55,33 @@ interface ProducerApplicative extends ProducerPure {
   ProducerApplicative INSTANCE = new ProducerApplicative() {};
 
   @Override
-  default <T, R> Kind<Producer_, R> ap(Kind<Producer_, ? extends T> value,
-      Kind<Producer_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Kind<Producer<?>, R> ap(Kind<Producer<?>, ? extends T> value,
+      Kind<Producer<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return ProducerOf.narrowK(value).flatMap(t -> ProducerOf.narrowK(apply).map(f -> f.apply(t)));
   }
 }
 
-interface ProducerMonad extends ProducerPure, Monad<Producer_> {
+interface ProducerMonad extends ProducerPure, Monad<Producer<?>> {
 
   ProducerMonad INSTANCE = new ProducerMonad() {};
 
   @Override
-  default <T, R> Kind<Producer_, R> flatMap(Kind<Producer_, ? extends T> value, Function1<? super T, ? extends Kind<Producer_, ? extends R>> mapper) {
+  default <T, R> Kind<Producer<?>, R> flatMap(Kind<Producer<?>, ? extends T> value, Function1<? super T, ? extends Kind<Producer<?>, ? extends R>> mapper) {
     return value.fix(ProducerOf::narrowK).flatMap(mapper.andThen(ProducerOf::narrowK));
   }
 }
 
-interface ProducerComonad extends ProducerFunctor, Comonad<Producer_> {
+interface ProducerComonad extends ProducerFunctor, Comonad<Producer<?>> {
 
   ProducerComonad INSTANCE = new ProducerComonad() {};
 
   @Override
-  default <A, B> Kind<Producer_, B> coflatMap(Kind<Producer_, ? extends A> value, Function1<? super Kind<Producer_, ? extends A>, ? extends B> map) {
+  default <A, B> Kind<Producer<?>, B> coflatMap(Kind<Producer<?>, ? extends A> value, Function1<? super Kind<Producer<?>, ? extends A>, ? extends B> map) {
     return Producer.cons(map.apply(value));
   }
 
   @Override
-  default <A> A extract(Kind<Producer_, ? extends A> value) {
+  default <A> A extract(Kind<Producer<?>, ? extends A> value) {
     return value.fix(ProducerOf::narrowK).get();
   }
 }
\ No newline at end of file
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/PromiseInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/PromiseInstances.java
index 29c6aaf89..8a214328e 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/PromiseInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/PromiseInstances.java
@@ -13,7 +13,6 @@
 import com.github.tonivade.purefun.concurrent.Future;
 import com.github.tonivade.purefun.concurrent.Promise;
 import com.github.tonivade.purefun.concurrent.PromiseOf;
-import com.github.tonivade.purefun.concurrent.Promise_;
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.typeclasses.Applicative;
 import com.github.tonivade.purefun.typeclasses.Functor;
@@ -21,33 +20,33 @@
 
 public interface PromiseInstances {
 
-  static Functor<Promise_> functor() {
+  static Functor<Promise<?>> functor() {
     return PromiseFunctor.INSTANCE;
   }
 
-  static Applicative<Promise_> applicative() {
+  static Applicative<Promise<?>> applicative() {
     return applicative(Future.DEFAULT_EXECUTOR);
   }
 
-  static Applicative<Promise_> applicative(Executor executor) {
+  static Applicative<Promise<?>> applicative(Executor executor) {
     return PromiseApplicative.instance(checkNonNull(executor));
   }
 
-  static Monad<Promise_> monad() {
+  static Monad<Promise<?>> monad() {
     return monad(Future.DEFAULT_EXECUTOR);
   }
 
-  static Monad<Promise_> monad(Executor executor) {
+  static Monad<Promise<?>> monad(Executor executor) {
     return PromiseMonad.instance(checkNonNull(executor));
   }
 }
 
-interface PromiseFunctor extends Functor<Promise_> {
+interface PromiseFunctor extends Functor<Promise<?>> {
 
   PromiseFunctor INSTANCE = new PromiseFunctor() {};
 
   @Override
-  default <T, R> Kind<Promise_, R> map(Kind<Promise_, ? extends T> value, Function1<? super T, ? extends R> mapper) {
+  default <T, R> Kind<Promise<?>, R> map(Kind<Promise<?>, ? extends T> value, Function1<? super T, ? extends R> mapper) {
     return value.fix(toPromise()).map(mapper);
   }
 }
@@ -56,10 +55,10 @@ interface PromiseExecutorHolder {
   Executor executor();
 }
 
-interface PromisePure extends Applicative<Promise_>, PromiseExecutorHolder {
+interface PromisePure extends Applicative<Promise<?>>, PromiseExecutorHolder {
 
   @Override
-  default <T> Kind<Promise_, T> pure(T value) {
+  default <T> Kind<Promise<?>, T> pure(T value) {
     return Promise.<T>make(executor()).succeeded(value);
   }
 }
@@ -71,21 +70,21 @@ static PromiseApplicative instance(Executor executor) {
   }
 
   @Override
-  default <T, R> Kind<Promise_, R> ap(Kind<Promise_, ? extends T> value, 
-      Kind<Promise_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Kind<Promise<?>, R> ap(Kind<Promise<?>, ? extends T> value,
+      Kind<Promise<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return value.fix(PromiseOf::<T>narrowK).ap(apply.fix(PromiseOf::narrowK));
   }
 }
 
-interface PromiseMonad extends PromisePure, Monad<Promise_> {
+interface PromiseMonad extends PromisePure, Monad<Promise<?>> {
 
   static PromiseMonad instance(Executor executor) {
     return () -> executor;
   }
 
   @Override
-  default <T, R> Kind<Promise_, R> flatMap(Kind<Promise_, ? extends T> value,
-      Function1<? super T, ? extends Kind<Promise_, ? extends R>> map) {
+  default <T, R> Kind<Promise<?>, R> flatMap(Kind<Promise<?>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Promise<?>, ? extends R>> map) {
     return value.fix(toPromise()).flatMap(map.andThen(PromiseOf::narrowK));
   }
 
@@ -94,8 +93,8 @@ default <T, R> Kind<Promise_, R> flatMap(Kind<Promise_, ? extends T> value,
    * applicative version of the ap method
    */
   @Override
-  default <T, R> Kind<Promise_, R> ap(Kind<Promise_, ? extends T> value, 
-      Kind<Promise_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Kind<Promise<?>, R> ap(Kind<Promise<?>, ? extends T> value,
+      Kind<Promise<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return PromiseInstances.applicative(executor()).ap(value, apply);
   }
 }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/PureIOInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/PureIOInstances.java
index 717f7da95..ea83b3d11 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/PureIOInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/PureIOInstances.java
@@ -19,7 +19,6 @@
 import com.github.tonivade.purefun.effect.UIO;
 import com.github.tonivade.purefun.effect.PureIO;
 import com.github.tonivade.purefun.effect.PureIOOf;
-import com.github.tonivade.purefun.effect.PureIO_;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.typeclasses.Applicative;
@@ -39,65 +38,65 @@
 @SuppressWarnings("unchecked")
 public interface PureIOInstances {
 
-  static <R, E> Functor<Kind<Kind<PureIO_, R>, E>> functor() {
+  static <R, E> Functor<Kind<Kind<PureIO<?, ?, ?>, R>, E>> functor() {
     return PureIOFunctor.INSTANCE;
   }
 
-  static <R, E> Applicative<Kind<Kind<PureIO_, R>, E>> applicative() {
+  static <R, E> Applicative<Kind<Kind<PureIO<?, ?, ?>, R>, E>> applicative() {
     return PureIOApplicative.INSTANCE;
   }
 
-  static <R, E> Monad<Kind<Kind<PureIO_, R>, E>> monad() {
+  static <R, E> Monad<Kind<Kind<PureIO<?, ?, ?>, R>, E>> monad() {
     return PureIOMonad.INSTANCE;
   }
 
-  static <R, E> MonadError<Kind<Kind<PureIO_, R>, E>, E> monadError() {
+  static <R, E> MonadError<Kind<Kind<PureIO<?, ?, ?>, R>, E>, E> monadError() {
     return PureIOMonadError.INSTANCE;
   }
 
-  static <R> MonadThrow<Kind<Kind<PureIO_, R>, Throwable>> monadThrow() {
+  static <R> MonadThrow<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>> monadThrow() {
     return PureIOMonadThrow.INSTANCE;
   }
 
-  static <R> MonadDefer<Kind<Kind<PureIO_, R>, Throwable>> monadDefer() {
+  static <R> MonadDefer<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>> monadDefer() {
     return PureIOMonadDefer.INSTANCE;
   }
 
-  static <R> Async<Kind<Kind<PureIO_, R>, Throwable>> async() {
+  static <R> Async<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>> async() {
     return PureIOAsync.INSTANCE;
   }
 
-  static <R> Concurrent<Kind<Kind<PureIO_, R>, Throwable>> concurrent() {
+  static <R> Concurrent<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>> concurrent() {
     return concurrent(Future.DEFAULT_EXECUTOR);
   }
 
-  static <R> Concurrent<Kind<Kind<PureIO_, R>, Throwable>> concurrent(Executor executor) {
+  static <R> Concurrent<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>> concurrent(Executor executor) {
     return PureIOConcurrent.instance(executor);
   }
 
-  static <R> Console<Kind<Kind<PureIO_, R>, Throwable>> console() {
+  static <R> Console<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>> console() {
     return PureIOConsole.INSTANCE;
   }
 
-  static <R, E> Runtime<Kind<Kind<PureIO_, R>, E>> runtime(R env) {
+  static <R, E> Runtime<Kind<Kind<PureIO<?, ?, ?>, R>, E>> runtime(R env) {
     return PureIORuntime.instance(env);
   }
 }
 
-interface PureIOFunctor<R, E> extends Functor<Kind<Kind<PureIO_, R>, E>> {
+interface PureIOFunctor<R, E> extends Functor<Kind<Kind<PureIO<?, ?, ?>, R>, E>> {
 
   @SuppressWarnings("rawtypes")
   PureIOFunctor INSTANCE = new PureIOFunctor() {};
 
   @Override
   default <A, B> PureIO<R, E, B> map(
-      Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> value,
+      Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> value,
       Function1<? super A, ? extends B> map) {
     return PureIOOf.narrowK(value).map(map);
   }
 }
 
-interface PureIOPure<R, E> extends Applicative<Kind<Kind<PureIO_, R>, E>> {
+interface PureIOPure<R, E> extends Applicative<Kind<Kind<PureIO<?, ?, ?>, R>, E>> {
 
   @Override
   default <A> PureIO<R, E, A> pure(A value) {
@@ -112,26 +111,26 @@ interface PureIOApplicative<R, E> extends PureIOPure<R, E> {
 
   @Override
   default <A, B> PureIO<R, E, B>
-          ap(Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> value,
-             Kind<Kind<Kind<PureIO_, R>, E>, ? extends Function1<? super A, ? extends B>> apply) {
+          ap(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> value,
+             Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends Function1<? super A, ? extends B>> apply) {
     return value.fix(PureIOOf::<R, E, A>narrowK).ap(apply);
   }
 }
 
-interface PureIOMonad<R, E> extends PureIOPure<R, E>, Monad<Kind<Kind<PureIO_, R>, E>> {
+interface PureIOMonad<R, E> extends PureIOPure<R, E>, Monad<Kind<Kind<PureIO<?, ?, ?>, R>, E>> {
 
   @SuppressWarnings("rawtypes")
   PureIOMonad INSTANCE = new PureIOMonad() {};
 
   @Override
   default <A, B> PureIO<R, E, B>
-          flatMap(Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> value,
-                  Function1<? super A, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends B>> map) {
+          flatMap(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> value,
+                  Function1<? super A, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B>> map) {
     return value.fix(toPureIO()).flatMap(map.andThen(PureIOOf::narrowK));
   }
 }
 
-interface PureIOMonadError<R, E> extends PureIOMonad<R, E>, MonadError<Kind<Kind<PureIO_, R>, E>, E> {
+interface PureIOMonadError<R, E> extends PureIOMonad<R, E>, MonadError<Kind<Kind<PureIO<?, ?, ?>, R>, E>, E> {
 
   @SuppressWarnings("rawtypes")
   PureIOMonadError INSTANCE = new PureIOMonadError() {};
@@ -143,40 +142,40 @@ default <A> PureIO<R, E, A> raiseError(E error) {
 
   @Override
   default <A> PureIO<R, E, A> handleErrorWith(
-      Kind<Kind<Kind<PureIO_, R>, E>, A> value,
-      Function1<? super E, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>> handler) {
+      Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, A> value,
+      Function1<? super E, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>> handler) {
     return PureIOOf.narrowK(value).foldM(handler, PureIO::pure);
   }
 }
 
 interface PureIOMonadThrow<R>
-    extends PureIOMonadError<R, Throwable>, MonadThrow<Kind<Kind<PureIO_, R>, Throwable>> {
+    extends PureIOMonadError<R, Throwable>, MonadThrow<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>> {
   @SuppressWarnings("rawtypes")
   PureIOMonadThrow INSTANCE = new PureIOMonadThrow() {};
 }
 
-interface PureIODefer<R, E> extends Defer<Kind<Kind<PureIO_, R>, E>> {
+interface PureIODefer<R, E> extends Defer<Kind<Kind<PureIO<?, ?, ?>, R>, E>> {
 
   @Override
   default <A> PureIO<R, E, A>
-          defer(Producer<? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends A>> defer) {
+          defer(Producer<? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A>> defer) {
     return PureIO.defer(() -> defer.map(PureIOOf::<R, E, A>narrowK).get());
   }
 }
 
-interface PureIOBracket<R, E> extends PureIOMonadError<R, E>, Bracket<Kind<Kind<PureIO_, R>, E>, E> {
+interface PureIOBracket<R, E> extends PureIOMonadError<R, E>, Bracket<Kind<Kind<PureIO<?, ?, ?>, R>, E>, E> {
 
   @Override
   default <A, B> PureIO<R, E, B>
-          bracket(Kind<Kind<Kind<PureIO_, R>, E>, ? extends A> acquire,
-                  Function1<? super A, ? extends Kind<Kind<Kind<PureIO_, R>, E>, ? extends B>> use,
-                  Function1<? super A, ? extends Kind<Kind<Kind<PureIO_, R>, E>, Unit>> release) {
+          bracket(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends A> acquire,
+                  Function1<? super A, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, ? extends B>> use,
+                  Function1<? super A, ? extends Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, Unit>> release) {
     return PureIO.bracket(acquire, use, release);
   }
 }
 
 interface PureIOMonadDefer<R>
-    extends MonadDefer<Kind<Kind<PureIO_, R>, Throwable>>, PureIODefer<R, Throwable>, PureIOBracket<R, Throwable> {
+    extends MonadDefer<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>>, PureIODefer<R, Throwable>, PureIOBracket<R, Throwable> {
 
   @SuppressWarnings("rawtypes")
   PureIOMonadDefer INSTANCE = new PureIOMonadDefer() {};
@@ -187,19 +186,19 @@ default PureIO<R, Throwable, Unit> sleep(Duration duration) {
   }
 }
 
-interface PureIOAsync<R> extends Async<Kind<Kind<PureIO_, R>, Throwable>>, PureIOMonadDefer<R> {
+interface PureIOAsync<R> extends Async<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>>, PureIOMonadDefer<R> {
 
   @SuppressWarnings("rawtypes")
   PureIOAsync INSTANCE = new PureIOAsync<>() {
   };
 
   @Override
-  default <A> PureIO<R, Throwable, A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<Kind<Kind<PureIO_, R>, Throwable>, Unit>> consumer) {
+  default <A> PureIO<R, Throwable, A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>, Unit>> consumer) {
     return PureIO.cancellable((env, cb) -> consumer.andThen(PureIOOf::narrowK).apply(e -> cb.accept(Try.success(e.toEither()))));
   }
 }
 
-interface PureIOConcurrent<R> extends Concurrent<Kind<Kind<PureIO_, R>, Throwable>>, PureIOAsync<R> {
+interface PureIOConcurrent<R> extends Concurrent<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>>, PureIOAsync<R> {
 
   static <R> PureIOConcurrent<R> instance(Executor executor) {
     return () -> executor;
@@ -208,18 +207,18 @@ static <R> PureIOConcurrent<R> instance(Executor executor) {
   Executor executor();
 
   @Override
-  default <A, B> PureIO<R, Throwable, Either<Tuple2<A, Fiber<Kind<Kind<PureIO_, R>, Throwable>, B>>, Tuple2<Fiber<Kind<Kind<PureIO_, R>, Throwable>, A>, B>>> racePair(
-      Kind<Kind<Kind<PureIO_, R>, Throwable>, ? extends A> fa, Kind<Kind<Kind<PureIO_, R>, Throwable>, ? extends B> fb) {
+  default <A, B> PureIO<R, Throwable, Either<Tuple2<A, Fiber<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>, B>>, Tuple2<Fiber<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>, A>, B>>> racePair(
+      Kind<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>, ? extends A> fa, Kind<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>, ? extends B> fb) {
     return PureIO.racePair(executor(), fa, fb);
   }
 
   @Override
-  default <A> PureIO<R, Throwable, Fiber<Kind<Kind<PureIO_, R>, Throwable>, A>> fork(Kind<Kind<Kind<PureIO_, R>, Throwable>, ? extends A> value) {
+  default <A> PureIO<R, Throwable, Fiber<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>, A>> fork(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>, ? extends A> value) {
     return value.fix(PureIOOf::<R, Throwable, A>narrowK).fork();
   }
 }
 
-final class PureIOConsole<R> implements Console<Kind<Kind<PureIO_, R>, Throwable>> {
+final class PureIOConsole<R> implements Console<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>> {
 
   @SuppressWarnings("rawtypes")
   static final PureIOConsole INSTANCE = new PureIOConsole();
@@ -237,7 +236,7 @@ public PureIO<R, Throwable, Unit> println(String text) {
   }
 }
 
-interface PureIORuntime<R, E> extends Runtime<Kind<Kind<PureIO_, R>, E>> {
+interface PureIORuntime<R, E> extends Runtime<Kind<Kind<PureIO<?, ?, ?>, R>, E>> {
 
   static <R, E> PureIORuntime<R, E> instance(R env) {
     return () -> env;
@@ -246,22 +245,22 @@ static <R, E> PureIORuntime<R, E> instance(R env) {
   R env();
 
   @Override
-  default <T> T run(Kind<Kind<Kind<PureIO_, R>, E>, T> value) {
+  default <T> T run(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, T> value) {
     return value.fix(toPureIO()).provide(env()).getRight();
   }
 
   @Override
-  default <T> Sequence<T> run(Sequence<Kind<Kind<Kind<PureIO_, R>, E>, T>> values) {
+  default <T> Sequence<T> run(Sequence<Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, T>> values) {
     return run(PureIO.traverse(values));
   }
 
   @Override
-  default <T> Future<T> parRun(Kind<Kind<Kind<PureIO_, R>, E>, T> value, Executor executor) {
+  default <T> Future<T> parRun(Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, T> value, Executor executor) {
     return value.fix(toPureIO()).runAsync(env()).map(Either::get);
   }
 
   @Override
-  default <T> Future<Sequence<T>> parRun(Sequence<Kind<Kind<Kind<PureIO_, R>, E>, T>> values, Executor executor) {
+  default <T> Future<Sequence<T>> parRun(Sequence<Kind<Kind<Kind<PureIO<?, ?, ?>, R>, E>, T>> values, Executor executor) {
     return parRun(PureIO.traverse(values), executor);
   }
 }
\ No newline at end of file
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/PureStreamInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/PureStreamInstances.java
index 55975465f..031df0c87 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/PureStreamInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/PureStreamInstances.java
@@ -7,74 +7,72 @@
 import static com.github.tonivade.purefun.core.Precondition.checkNonNull;
 
 import com.github.tonivade.purefun.Kind;
-
 import com.github.tonivade.purefun.core.Function1;
-import com.github.tonivade.purefun.effect.EIO_;
-import com.github.tonivade.purefun.effect.RIO_;
-import com.github.tonivade.purefun.effect.Task_;
-import com.github.tonivade.purefun.effect.UIO_;
-import com.github.tonivade.purefun.effect.URIO_;
-import com.github.tonivade.purefun.effect.PureIO_;
-import com.github.tonivade.purefun.monad.IO_;
+import com.github.tonivade.purefun.effect.EIO;
+import com.github.tonivade.purefun.effect.PureIO;
+import com.github.tonivade.purefun.effect.RIO;
+import com.github.tonivade.purefun.effect.Task;
+import com.github.tonivade.purefun.effect.UIO;
+import com.github.tonivade.purefun.effect.URIO;
+import com.github.tonivade.purefun.monad.IO;
 import com.github.tonivade.purefun.stream.PureStream;
 import com.github.tonivade.purefun.stream.PureStreamOf;
-import com.github.tonivade.purefun.stream.PureStream_;
 import com.github.tonivade.purefun.typeclasses.Applicative;
 import com.github.tonivade.purefun.typeclasses.Functor;
 import com.github.tonivade.purefun.typeclasses.Monad;
 
 public interface PureStreamInstances {
 
-  static PureStream.Of<IO_> ofIO() {
+  static PureStream.Of<IO<?>> ofIO() {
     return PureStream.of(IOInstances.monadDefer());
   }
 
-  static <R> PureStream.Of<Kind<Kind<PureIO_, R>, Throwable>> ofPureIO() {
+  static <R> PureStream.Of<Kind<Kind<PureIO<?, ?, ?>, R>, Throwable>> ofPureIO() {
     return PureStream.of(PureIOInstances.monadDefer());
   }
 
-  static PureStream.Of<UIO_> ofUIO() {
+  static PureStream.Of<UIO<?>> ofUIO() {
     return PureStream.of(UIOInstances.monadDefer());
   }
 
-  static PureStream.Of<Kind<EIO_, Throwable>> ofEIO() {
+  static PureStream.Of<Kind<EIO<?, ?>, Throwable>> ofEIO() {
     return PureStream.of(EIOInstances.monadDefer());
   }
 
-  static PureStream.Of<Task_> ofTask() {
+  static PureStream.Of<Task<?>> ofTask() {
     return PureStream.of(TaskInstances.monadDefer());
   }
 
-  static <R> PureStream.Of<Kind<URIO_, R>> ofURIO() {
+  static <R> PureStream.Of<Kind<URIO<?, ?>, R>> ofURIO() {
     return PureStream.of(URIOInstances.monadDefer());
   }
 
-  static <R> PureStream.Of<Kind<RIO_, R>> ofRIO() {
+  static <R> PureStream.Of<Kind<RIO<?, ?>, R>> ofRIO() {
     return PureStream.of(RIOInstances.monadDefer());
   }
 
   @SuppressWarnings("unchecked")
-  static <F> Functor<Kind<PureStream_, F>> functor() {
+  static <F> Functor<Kind<PureStream<?, ?>, F>> functor() {
     return PureStreamFunctor.INSTANCE;
   }
 
-  static <F> Monad<Kind<PureStream_, F>> monad(PureStream.Of<F> streamOf) {
+  static <F> Monad<Kind<PureStream<?, ?>, F>> monad(PureStream.Of<F> streamOf) {
     return PureStreamMonad.instance(checkNonNull(streamOf));
   }
 }
 
-interface PureStreamFunctor<F> extends Functor<Kind<PureStream_, F>> {
+interface PureStreamFunctor<F> extends Functor<Kind<PureStream<?, ?>, F>> {
 
   @SuppressWarnings("rawtypes")
   PureStreamFunctor INSTANCE = new PureStreamFunctor() {};
 
   @Override
-  default <T, R> PureStream<F, R> map(Kind<Kind<PureStream_, F>, ? extends T> value, Function1<? super T, ? extends R> mapper) {
+  default <T, R> PureStream<F, R> map(Kind<Kind<PureStream<?, ?>, F>, ? extends T> value, Function1<? super T, ? extends R> mapper) {
     return PureStreamOf.narrowK(value).map(mapper);
   }
 }
 
-interface PureStreamPure<F> extends Applicative<Kind<PureStream_, F>> {
+interface PureStreamPure<F> extends Applicative<Kind<PureStream<?, ?>, F>> {
 
   PureStream.Of<F> streamOf();
 
@@ -84,15 +82,15 @@ default <T> PureStream<F, T> pure(T value) {
   }
 }
 
-interface PureStreamMonad<F> extends Monad<Kind<PureStream_, F>>, PureStreamPure<F> {
+interface PureStreamMonad<F> extends Monad<Kind<PureStream<?, ?>, F>>, PureStreamPure<F> {
 
   static <F> PureStreamMonad<F> instance(PureStream.Of<F> streamOf) {
     return () -> streamOf;
   }
 
   @Override
-  default <T, R> PureStream<F, R> flatMap(Kind<Kind<PureStream_, F>, ? extends T> value,
-      Function1<? super T, ? extends Kind<Kind<PureStream_, F>, ? extends R>> mapper) {
+  default <T, R> PureStream<F, R> flatMap(Kind<Kind<PureStream<?, ?>, F>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Kind<PureStream<?, ?>, F>, ? extends R>> mapper) {
     return PureStreamOf.narrowK(value).flatMap(mapper.andThen(PureStreamOf::narrowK));
   }
 }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/RIOInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/RIOInstances.java
index 4801caed7..ebea22058 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/RIOInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/RIOInstances.java
@@ -18,7 +18,6 @@
 import com.github.tonivade.purefun.data.Sequence;
 import com.github.tonivade.purefun.effect.RIO;
 import com.github.tonivade.purefun.effect.RIOOf;
-import com.github.tonivade.purefun.effect.RIO_;
 import com.github.tonivade.purefun.effect.UIO;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.type.Try;
@@ -39,60 +38,60 @@
 @SuppressWarnings("unchecked")
 public interface RIOInstances {
 
-  static <R> Functor<Kind<RIO_, R>> functor() {
+  static <R> Functor<Kind<RIO<?, ?>, R>> functor() {
     return RIOFunctor.INSTANCE;
   }
 
-  static <R> Applicative<Kind<RIO_, R>> applicative() {
+  static <R> Applicative<Kind<RIO<?, ?>, R>> applicative() {
     return RIOApplicative.INSTANCE;
   }
 
-  static <R> Monad<Kind<RIO_, R>> monad() {
+  static <R> Monad<Kind<RIO<?, ?>, R>> monad() {
     return RIOMonad.INSTANCE;
   }
 
-  static <R> MonadThrow<Kind<RIO_, R>> monadThrow() {
+  static <R> MonadThrow<Kind<RIO<?, ?>, R>> monadThrow() {
     return RIOMonadThrow.INSTANCE;
   }
 
-  static <R> MonadDefer<Kind<RIO_, R>> monadDefer() {
+  static <R> MonadDefer<Kind<RIO<?, ?>, R>> monadDefer() {
     return RIOMonadDefer.INSTANCE;
   }
 
-  static <R> Async<Kind<RIO_, R>> async() {
+  static <R> Async<Kind<RIO<?, ?>, R>> async() {
     return RIOAsync.INSTANCE;
   }
 
-  static <R> Concurrent<Kind<RIO_, R>> concurrent() {
+  static <R> Concurrent<Kind<RIO<?, ?>, R>> concurrent() {
     return concurrent(Future.DEFAULT_EXECUTOR);
   }
 
-  static <R> Concurrent<Kind<RIO_, R>> concurrent(Executor executor) {
+  static <R> Concurrent<Kind<RIO<?, ?>, R>> concurrent(Executor executor) {
     return RIOConcurrent.instance(executor);
   }
 
-  static <R> Console<Kind<Kind<RIO_, R>, Throwable>> console() {
+  static <R> Console<Kind<Kind<RIO<?, ?>, R>, Throwable>> console() {
     return RIOConsole.INSTANCE;
   }
 
-  static <R> Runtime<Kind<RIO_, R>> runtime(R env) {
+  static <R> Runtime<Kind<RIO<?, ?>, R>> runtime(R env) {
     return RIORuntime.instance(env);
   }
 }
 
-interface RIOFunctor<R> extends Functor<Kind<RIO_, R>> {
+interface RIOFunctor<R> extends Functor<Kind<RIO<?, ?>, R>> {
 
   @SuppressWarnings("rawtypes")
   RIOFunctor INSTANCE = new RIOFunctor() {};
 
   @Override
   default <A, B> RIO<R, B>
-          map(Kind<Kind<RIO_, R>, ? extends A> value, Function1<? super A, ? extends B> map) {
+          map(Kind<Kind<RIO<?, ?>, R>, ? extends A> value, Function1<? super A, ? extends B> map) {
     return RIOOf.narrowK(value).map(map);
   }
 }
 
-interface RIOPure<R> extends Applicative<Kind<RIO_, R>> {
+interface RIOPure<R> extends Applicative<Kind<RIO<?, ?>, R>> {
 
   @Override
   default <A> RIO<R, A> pure(A value) {
@@ -107,26 +106,26 @@ interface RIOApplicative<R> extends RIOPure<R> {
 
   @Override
   default <A, B> RIO<R, B>
-          ap(Kind<Kind<RIO_, R>, ? extends A> value,
-             Kind<Kind<RIO_, R>, ? extends Function1<? super A, ? extends B>> apply) {
+          ap(Kind<Kind<RIO<?, ?>, R>, ? extends A> value,
+             Kind<Kind<RIO<?, ?>, R>, ? extends Function1<? super A, ? extends B>> apply) {
     return value.fix(RIOOf::<R, A>narrowK).ap(apply.fix(RIOOf::narrowK));
   }
 }
 
-interface RIOMonad<R> extends RIOPure<R>, Monad<Kind<RIO_, R>> {
+interface RIOMonad<R> extends RIOPure<R>, Monad<Kind<RIO<?, ?>, R>> {
 
   @SuppressWarnings("rawtypes")
   RIOMonad INSTANCE = new RIOMonad() {};
 
   @Override
   default <A, B> RIO<R, B>
-          flatMap(Kind<Kind<RIO_, R>, ? extends A> value,
-                  Function1<? super A, ? extends Kind<Kind<RIO_, R>, ? extends B>> map) {
+          flatMap(Kind<Kind<RIO<?, ?>, R>, ? extends A> value,
+                  Function1<? super A, ? extends Kind<Kind<RIO<?, ?>, R>, ? extends B>> map) {
     return value.fix(toRIO()).flatMap(map.andThen(RIOOf::narrowK));
   }
 }
 
-interface RIOMonadError<R> extends RIOMonad<R>, MonadError<Kind<RIO_, R>, Throwable> {
+interface RIOMonadError<R> extends RIOMonad<R>, MonadError<Kind<RIO<?, ?>, R>, Throwable> {
 
   @SuppressWarnings("rawtypes")
   RIOMonadError INSTANCE = new RIOMonadError<>() {
@@ -139,8 +138,8 @@ default <A> RIO<R, A> raiseError(Throwable error) {
 
   @Override
   default <A> RIO<R, A> handleErrorWith(
-      Kind<Kind<RIO_, R>, A> value,
-      Function1<? super Throwable, ? extends Kind<Kind<RIO_, R>, ? extends A>> handler) {
+      Kind<Kind<RIO<?, ?>, R>, A> value,
+      Function1<? super Throwable, ? extends Kind<Kind<RIO<?, ?>, R>, ? extends A>> handler) {
     // XXX: java8 fails to infer types, I have to do this in steps
     Function1<? super Throwable, RIO<R, A>> mapError = handler.andThen(RIOOf::narrowK);
     Function1<A, RIO<R, A>> map = RIO::pure;
@@ -151,34 +150,34 @@ default <A> RIO<R, A> handleErrorWith(
 
 interface RIOMonadThrow<R>
     extends RIOMonadError<R>,
-            MonadThrow<Kind<RIO_, R>> {
+            MonadThrow<Kind<RIO<?, ?>, R>> {
   @SuppressWarnings("rawtypes")
   RIOMonadThrow INSTANCE = new RIOMonadThrow<>() {
   };
 }
 
-interface RIODefer<R> extends Defer<Kind<RIO_, R>> {
+interface RIODefer<R> extends Defer<Kind<RIO<?, ?>, R>> {
 
   @Override
   default <A> RIO<R, A>
-          defer(Producer<? extends Kind<Kind<RIO_, R>, ? extends A>> defer) {
+          defer(Producer<? extends Kind<Kind<RIO<?, ?>, R>, ? extends A>> defer) {
     return RIO.defer(defer::get);
   }
 }
 
-interface RIOBracket<R> extends RIOMonadError<R>, Bracket<Kind<RIO_, R>, Throwable> {
+interface RIOBracket<R> extends RIOMonadError<R>, Bracket<Kind<RIO<?, ?>, R>, Throwable> {
 
   @Override
   default <A, B> RIO<R, B>
-          bracket(Kind<Kind<RIO_, R>, ? extends A> acquire,
-                  Function1<? super A, ? extends Kind<Kind<RIO_, R>, ? extends B>> use,
-                  Function1<? super A, ? extends Kind<Kind<RIO_, R>, Unit>> release) {
+          bracket(Kind<Kind<RIO<?, ?>, R>, ? extends A> acquire,
+                  Function1<? super A, ? extends Kind<Kind<RIO<?, ?>, R>, ? extends B>> use,
+                  Function1<? super A, ? extends Kind<Kind<RIO<?, ?>, R>, Unit>> release) {
     return RIO.bracket(acquire, use, release);
   }
 }
 
 interface RIOMonadDefer<R>
-    extends MonadDefer<Kind<RIO_, R>>, RIODefer<R>, RIOBracket<R> {
+    extends MonadDefer<Kind<RIO<?, ?>, R>>, RIODefer<R>, RIOBracket<R> {
 
   @SuppressWarnings("rawtypes")
   RIOMonadDefer INSTANCE = new RIOMonadDefer<>() {
@@ -190,19 +189,19 @@ default RIO<R, Unit> sleep(Duration duration) {
   }
 }
 
-interface RIOAsync<R> extends Async<Kind<RIO_, R>>, RIOMonadDefer<R> {
+interface RIOAsync<R> extends Async<Kind<RIO<?, ?>, R>>, RIOMonadDefer<R> {
 
   @SuppressWarnings("rawtypes")
   RIOAsync INSTANCE = new RIOAsync<>() {
   };
 
   @Override
-  default <A> RIO<R, A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<Kind<RIO_, R>, Unit>> consumer) {
+  default <A> RIO<R, A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<Kind<RIO<?, ?>, R>, Unit>> consumer) {
     return RIO.cancellable((env, cb) -> consumer.andThen(RIOOf::narrowK).apply(cb));
   }
 }
 
-interface RIOConcurrent<R> extends RIOAsync<R>, Concurrent<Kind<RIO_, R>> {
+interface RIOConcurrent<R> extends RIOAsync<R>, Concurrent<Kind<RIO<?, ?>, R>> {
 
   static <R> RIOConcurrent<R> instance(Executor executor) {
     return () -> executor;
@@ -211,19 +210,19 @@ static <R> RIOConcurrent<R> instance(Executor executor) {
   Executor executor();
 
   @Override
-  default <A, B> RIO<R, Either<Tuple2<A, Fiber<Kind<RIO_, R>, B>>, Tuple2<Fiber<Kind<RIO_, R>, A>, B>>> racePair(
-    Kind<Kind<RIO_, R>, ? extends A> fa, Kind<Kind<RIO_, R>, ? extends B> fb) {
+  default <A, B> RIO<R, Either<Tuple2<A, Fiber<Kind<RIO<?, ?>, R>, B>>, Tuple2<Fiber<Kind<RIO<?, ?>, R>, A>, B>>> racePair(
+    Kind<Kind<RIO<?, ?>, R>, ? extends A> fa, Kind<Kind<RIO<?, ?>, R>, ? extends B> fb) {
     return RIO.racePair(executor(), fa, fb);
   }
 
   @Override
-  default <A> RIO<R, Fiber<Kind<RIO_, R>, A>> fork(Kind<Kind<RIO_, R>, ? extends A> value) {
+  default <A> RIO<R, Fiber<Kind<RIO<?, ?>, R>, A>> fork(Kind<Kind<RIO<?, ?>, R>, ? extends A> value) {
     RIO<R, A> fix = value.fix(RIOOf::narrowK);
     return fix.fork();
   }
 }
 
-final class RIOConsole<R> implements Console<Kind<RIO_, R>> {
+final class RIOConsole<R> implements Console<Kind<RIO<?, ?>, R>> {
 
   @SuppressWarnings("rawtypes")
   static final RIOConsole INSTANCE = new RIOConsole();
@@ -241,7 +240,7 @@ public RIO<R, Unit> println(String text) {
   }
 }
 
-interface RIORuntime<R> extends Runtime<Kind<RIO_, R>> {
+interface RIORuntime<R> extends Runtime<Kind<RIO<?, ?>, R>> {
 
   static <R> RIORuntime<R> instance(R env) {
     return () -> env;
@@ -250,22 +249,22 @@ static <R> RIORuntime<R> instance(R env) {
   R env();
 
   @Override
-  default <T> T run(Kind<Kind<RIO_, R>, T> value) {
+  default <T> T run(Kind<Kind<RIO<?, ?>, R>, T> value) {
     return value.fix(toRIO()).safeRunSync(env()).getOrElseThrow();
   }
 
   @Override
-  default <T> Sequence<T> run(Sequence<Kind<Kind<RIO_, R>, T>> values) {
+  default <T> Sequence<T> run(Sequence<Kind<Kind<RIO<?, ?>, R>, T>> values) {
     return run(RIO.traverse(values.map(RIOOf::<R, T>narrowK)));
   }
 
   @Override
-  default <T> Future<T> parRun(Kind<Kind<RIO_, R>, T> value, Executor executor) {
+  default <T> Future<T> parRun(Kind<Kind<RIO<?, ?>, R>, T> value, Executor executor) {
     return value.fix(toRIO()).runAsync(env());
   }
 
   @Override
-  default <T> Future<Sequence<T>> parRun(Sequence<Kind<Kind<RIO_, R>, T>> values, Executor executor) {
+  default <T> Future<Sequence<T>> parRun(Sequence<Kind<Kind<RIO<?, ?>, R>, T>> values, Executor executor) {
     return parRun(RIO.traverse(values.map(RIOOf::<R, T>narrowK)), executor);
   }
 }
\ No newline at end of file
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/ReaderInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/ReaderInstances.java
index 95794602a..da2c15456 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/ReaderInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/ReaderInstances.java
@@ -8,23 +8,22 @@
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.monad.Reader;
 import com.github.tonivade.purefun.monad.ReaderOf;
-import com.github.tonivade.purefun.monad.Reader_;
 import com.github.tonivade.purefun.typeclasses.Monad;
 import com.github.tonivade.purefun.typeclasses.MonadReader;
 
 @SuppressWarnings("unchecked")
 public interface ReaderInstances {
 
-  static <R> Monad<Kind<Reader_, R>> monad() {
+  static <R> Monad<Kind<Reader<?, ?>, R>> monad() {
     return ReaderMonad.INSTANCE;
   }
 
-  static <R> MonadReader<Kind<Reader_, R>, R> monadReader() {
+  static <R> MonadReader<Kind<Reader<?, ?>, R>, R> monadReader() {
     return ReaderMonadReader.INSTANCE;
   }
 }
 
-interface ReaderMonad<R> extends Monad<Kind<Reader_, R>> {
+interface ReaderMonad<R> extends Monad<Kind<Reader<?, ?>, R>> {
 
   @SuppressWarnings("rawtypes")
   ReaderMonad INSTANCE = new ReaderMonad() {};
@@ -35,19 +34,19 @@ default <T> Reader<R, T> pure(T value) {
   }
 
   @Override
-  default <T, V> Reader<R, V> flatMap(Kind<Kind<Reader_, R>, ? extends T> value,
-      Function1<? super T, ? extends Kind<Kind<Reader_, R>, ? extends V>> map) {
+  default <T, V> Reader<R, V> flatMap(Kind<Kind<Reader<?, ?>, R>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Kind<Reader<?, ?>, R>, ? extends V>> map) {
     return ReaderOf.narrowK(value).flatMap(map.andThen(ReaderOf::narrowK));
   }
 }
 
-interface ReaderMonadReader<R> extends MonadReader<Kind<Reader_, R>, R>, ReaderMonad<R> {
+interface ReaderMonadReader<R> extends MonadReader<Kind<Reader<?, ?>, R>, R>, ReaderMonad<R> {
 
   @SuppressWarnings("rawtypes")
   ReaderMonadReader INSTANCE = new ReaderMonadReader() {};
 
   @Override
-  default Kind<Kind<Reader_, R>, R> ask() {
+  default Kind<Kind<Reader<?, ?>, R>, R> ask() {
     return Reader.env();
   }
 }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/ScheduleInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/ScheduleInstances.java
index b89c3a763..d7d59eca8 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/ScheduleInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/ScheduleInstances.java
@@ -8,42 +8,41 @@
 import com.github.tonivade.purefun.typeclasses.Functor;
 import com.github.tonivade.purefun.typeclasses.Profunctor;
 import com.github.tonivade.purefun.typeclasses.Schedule;
-import com.github.tonivade.purefun.typeclasses.Schedule_;
 
 @SuppressWarnings("unchecked")
 public interface ScheduleInstances {
-  
-  static <F, A> Functor<Kind<Kind<Schedule_, F>, A>> functor() {
+
+  static <F, A> Functor<Kind<Kind<Schedule<?, ?, ?>, F>, A>> functor() {
     return ScheduleFunctor.INSTANCE;
   }
-  
-  static <F> Profunctor<Kind<Schedule_, F>> profunctor() {
+
+  static <F> Profunctor<Kind<Schedule<?, ?, ?>, F>> profunctor() {
     return ScheduleProfunctor.INSTANCE;
   }
 }
 
-interface ScheduleFunctor<F, A> extends Functor<Kind<Kind<Schedule_, F>, A>> {
-   
+interface ScheduleFunctor<F, A> extends Functor<Kind<Kind<Schedule<?, ?, ?>, F>, A>> {
+
   @SuppressWarnings("rawtypes")
   ScheduleFunctor INSTANCE = new ScheduleFunctor() {};
-  
+
   @Override
   default <T, R> Schedule<F, A, R> map(
-      Kind<Kind<Kind<Schedule_, F>, A>, ? extends T> value, 
+      Kind<Kind<Kind<Schedule<?, ?, ?>, F>, A>, ? extends T> value,
       Function1<? super T, ? extends R> mapper) {
     return value.fix(toSchedule()).map(mapper);
   }
 }
 
-interface ScheduleProfunctor<F> extends Profunctor<Kind<Schedule_, F>> {
+interface ScheduleProfunctor<F> extends Profunctor<Kind<Schedule<?, ?, ?>, F>> {
 
   @SuppressWarnings("rawtypes")
   ScheduleProfunctor INSTANCE = new ScheduleProfunctor() {};
-  
+
   @Override
   default <A, B, C, D> Schedule<F, C, D> dimap(
-      Kind<Kind<Kind<Schedule_, F>, A>, ? extends B> value, 
-      Function1<? super C, ? extends A> contramap, 
+      Kind<Kind<Kind<Schedule<?, ?, ?>, F>, A>, ? extends B> value,
+      Function1<? super C, ? extends A> contramap,
       Function1<? super B, ? extends D> map) {
     return value.fix(toSchedule()).dimap(contramap, map);
   }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/SequenceInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/SequenceInstances.java
index c29b3212d..dafba79e3 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/SequenceInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/SequenceInstances.java
@@ -14,7 +14,6 @@
 import com.github.tonivade.purefun.data.ImmutableList;
 import com.github.tonivade.purefun.data.Sequence;
 import com.github.tonivade.purefun.data.SequenceOf;
-import com.github.tonivade.purefun.data.Sequence_;
 import com.github.tonivade.purefun.type.Eval;
 import com.github.tonivade.purefun.type.EvalOf;
 import com.github.tonivade.purefun.typeclasses.Alternative;
@@ -31,7 +30,7 @@
 @SuppressWarnings("unchecked")
 public interface SequenceInstances {
 
-  static <T> Eq<Kind<Sequence_, T>> eq(Eq<T> eqElement) {
+  static <T> Eq<Kind<Sequence<?>, T>> eq(Eq<T> eqElement) {
     return (a, b) -> {
       Sequence<T> seq1 = SequenceOf.narrowK(a);
       Sequence<T> seq2 = SequenceOf.narrowK(b);
@@ -48,35 +47,35 @@ static <T> Monoid<Sequence<T>> monoid() {
     return (SequenceMonoid<T>) SequenceMonoid.INSTANCE;
   }
 
-  static SemigroupK<Sequence_> semigroupK() {
+  static SemigroupK<Sequence<?>> semigroupK() {
     return SequenceSemigroupK.INSTANCE;
   }
 
-  static MonoidK<Sequence_> monoidK() {
+  static MonoidK<Sequence<?>> monoidK() {
     return SequenceMonoidK.INSTANCE;
   }
 
-  static Functor<Sequence_> functor() {
+  static Functor<Sequence<?>> functor() {
     return SequenceFunctor.INSTANCE;
   }
 
-  static Applicative<Sequence_> applicative() {
+  static Applicative<Sequence<?>> applicative() {
     return SequenceApplicative.INSTANCE;
   }
 
-  static Monad<Sequence_> monad() {
+  static Monad<Sequence<?>> monad() {
     return SequenceMonad.INSTANCE;
   }
 
-  static Alternative<Sequence_> alternative() {
+  static Alternative<Sequence<?>> alternative() {
     return SequenceAlternative.INSTANCE;
   }
 
-  static Traverse<Sequence_> traverse() {
+  static Traverse<Sequence<?>> traverse() {
     return SequenceTraverse.INSTANCE;
   }
 
-  static Foldable<Sequence_> foldable() {
+  static Foldable<Sequence<?>> foldable() {
     return SequenceFoldable.INSTANCE;
   }
 }
@@ -103,96 +102,96 @@ default Sequence<T> zero() {
   }
 }
 
-interface SequenceSemigroupK extends SemigroupK<Sequence_> {
+interface SequenceSemigroupK extends SemigroupK<Sequence<?>> {
 
   SequenceSemigroupK INSTANCE = new SequenceSemigroupK() {};
 
   @Override
-  default <T> Kind<Sequence_, T> combineK(Kind<Sequence_, ? extends T> t1, Kind<Sequence_, ? extends T> t2) {
+  default <T> Kind<Sequence<?>, T> combineK(Kind<Sequence<?>, ? extends T> t1, Kind<Sequence<?>, ? extends T> t2) {
     return SequenceOf.<T>narrowK(t1).appendAll(SequenceOf.narrowK(t2));
   }
 }
 
-interface SequenceMonoidK extends MonoidK<Sequence_>, SequenceSemigroupK {
+interface SequenceMonoidK extends MonoidK<Sequence<?>>, SequenceSemigroupK {
 
   SequenceMonoidK INSTANCE = new SequenceMonoidK() {};
 
   @Override
-  default <T> Kind<Sequence_, T> zero() {
+  default <T> Kind<Sequence<?>, T> zero() {
     return ImmutableList.empty();
   }
 }
 
-interface SequenceFunctor extends Functor<Sequence_> {
+interface SequenceFunctor extends Functor<Sequence<?>> {
 
   SequenceFunctor INSTANCE = new SequenceFunctor() {};
 
   @Override
-  default <T, R> Kind<Sequence_, R> map(Kind<Sequence_, ? extends T> value, Function1<? super T, ? extends R> map) {
+  default <T, R> Kind<Sequence<?>, R> map(Kind<Sequence<?>, ? extends T> value, Function1<? super T, ? extends R> map) {
     return SequenceOf.narrowK(value).map(map);
   }
 }
 
-interface SequencePure extends Applicative<Sequence_> {
+interface SequencePure extends Applicative<Sequence<?>> {
 
   @Override
-  default <T> Kind<Sequence_, T> pure(T value) {
+  default <T> Kind<Sequence<?>, T> pure(T value) {
     return ImmutableList.of(value);
   }
 }
 
-interface SequenceApplicative extends SequencePure, Applicative<Sequence_> {
+interface SequenceApplicative extends SequencePure, Applicative<Sequence<?>> {
 
   SequenceApplicative INSTANCE = new SequenceApplicative() {};
 
   @Override
-  default <T, R> Kind<Sequence_, R> ap(Kind<Sequence_, ? extends T> value,
-      Kind<Sequence_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Kind<Sequence<?>, R> ap(Kind<Sequence<?>, ? extends T> value,
+      Kind<Sequence<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return SequenceOf.narrowK(apply).flatMap(map -> SequenceOf.narrowK(value).map(map));
   }
 }
 
-interface SequenceMonad extends SequencePure, Monad<Sequence_> {
+interface SequenceMonad extends SequencePure, Monad<Sequence<?>> {
 
   SequenceMonad INSTANCE = new SequenceMonad() {};
 
   @Override
-  default <T, R> Kind<Sequence_, R> flatMap(Kind<Sequence_, ? extends T> value, Function1<? super T, ? extends Kind<Sequence_, ? extends R>> map) {
+  default <T, R> Kind<Sequence<?>, R> flatMap(Kind<Sequence<?>, ? extends T> value, Function1<? super T, ? extends Kind<Sequence<?>, ? extends R>> map) {
     return SequenceOf.narrowK(value).flatMap(map.andThen(SequenceOf::narrowK));
   }
 }
 
 interface SequenceAlternative
-    extends SequenceApplicative, SequenceMonoidK, Alternative<Sequence_> {
+    extends SequenceApplicative, SequenceMonoidK, Alternative<Sequence<?>> {
 
   SequenceAlternative INSTANCE = new SequenceAlternative() {};
 }
 
 
-interface SequenceFoldable extends Foldable<Sequence_> {
+interface SequenceFoldable extends Foldable<Sequence<?>> {
 
   SequenceFoldable INSTANCE = new SequenceFoldable() {};
 
   @Override
-  default <A, B> B foldLeft(Kind<Sequence_, ? extends A> value, B initial, Function2<? super B, ? super A, ? extends B> mapper) {
+  default <A, B> B foldLeft(Kind<Sequence<?>, ? extends A> value, B initial, Function2<? super B, ? super A, ? extends B> mapper) {
     return SequenceOf.narrowK(value).foldLeft(initial, mapper);
   }
 
   @Override
-  default <A, B> Eval<B> foldRight(Kind<Sequence_, ? extends A> value, Eval<? extends B> initial,
+  default <A, B> Eval<B> foldRight(Kind<Sequence<?>, ? extends A> value, Eval<? extends B> initial,
       Function2<? super A, ? super Eval<? extends B>, ? extends Eval<? extends B>> mapper) {
     Eval<? extends B> foldRight = SequenceOf.narrowK(value).foldRight(initial, mapper);
     return EvalOf.narrowK(foldRight);
   }
 }
 
-interface SequenceTraverse extends Traverse<Sequence_>, SequenceFoldable {
+interface SequenceTraverse extends Traverse<Sequence<?>>, SequenceFoldable {
 
   SequenceTraverse INSTANCE = new SequenceTraverse() {};
 
   @Override
-  default <G, T, R> Kind<G, Kind<Sequence_, R>> traverse(
-      Applicative<G> applicative, Kind<Sequence_, T> value,
+  default <G, T, R> Kind<G, Kind<Sequence<?>, R>> traverse(
+      Applicative<G> applicative, Kind<Sequence<?>, T> value,
       Function1<? super T, ? extends Kind<G, ? extends R>> mapper) {
     return value.fix(toSequence()).foldLeft(
       applicative.pure(Sequence.emptyList()),
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/StateInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/StateInstances.java
index 71db60f6c..1506b44cf 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/StateInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/StateInstances.java
@@ -13,7 +13,6 @@
 import com.github.tonivade.purefun.data.ImmutableList;
 import com.github.tonivade.purefun.monad.State;
 import com.github.tonivade.purefun.monad.StateOf;
-import com.github.tonivade.purefun.monad.State_;
 import com.github.tonivade.purefun.typeclasses.Console;
 import com.github.tonivade.purefun.typeclasses.Monad;
 import com.github.tonivade.purefun.typeclasses.MonadState;
@@ -21,20 +20,20 @@
 @SuppressWarnings("unchecked")
 public interface StateInstances {
 
-  static <S> Monad<Kind<State_, S>> monad() {
+  static <S> Monad<Kind<State<?, ?>, S>> monad() {
     return StateMonad.INSTANCE;
   }
 
-  static <S> MonadState<Kind<State_, S>, S> monadState() {
+  static <S> MonadState<Kind<State<?, ?>, S>, S> monadState() {
     return StateMonadState.INSTANCE;
   }
 
-  static Console<Kind<State_, ImmutableList<String>>> console() {
+  static Console<Kind<State<?, ?>, ImmutableList<String>>> console() {
     return StateConsole.INSTANCE;
   }
 }
 
-interface StateMonad<S> extends Monad<Kind<State_, S>> {
+interface StateMonad<S> extends Monad<Kind<State<?, ?>, S>> {
 
   @SuppressWarnings("rawtypes")
   StateMonad INSTANCE = new StateMonad() {};
@@ -45,13 +44,13 @@ default <T> State<S, T> pure(T value) {
   }
 
   @Override
-  default <T, R> State<S, R> flatMap(Kind<Kind<State_, S>, ? extends T> value,
-      Function1<? super T, ? extends Kind<Kind<State_, S>, ? extends R>> map) {
+  default <T, R> State<S, R> flatMap(Kind<Kind<State<?, ?>, S>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Kind<State<?, ?>, S>, ? extends R>> map) {
     return StateOf.narrowK(value).flatMap(map.andThen(StateOf::narrowK));
   }
 }
 
-interface StateMonadState<S> extends MonadState<Kind<State_, S>, S>, StateMonad<S> {
+interface StateMonadState<S> extends MonadState<Kind<State<?, ?>, S>, S>, StateMonad<S> {
 
   @SuppressWarnings("rawtypes")
   StateMonadState INSTANCE = new StateMonadState() {};
@@ -67,7 +66,7 @@ default State<S, Unit> set(S state) {
   }
 }
 
-final class StateConsole implements Console<Kind<State_, ImmutableList<String>>> {
+final class StateConsole implements Console<Kind<State<?, ?>, ImmutableList<String>>> {
 
   static final StateConsole INSTANCE = new StateConsole();
 
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/StateTInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/StateTInstances.java
index 9a0fb4253..821e9789a 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/StateTInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/StateTInstances.java
@@ -13,7 +13,6 @@
 import com.github.tonivade.purefun.core.Unit;
 import com.github.tonivade.purefun.transformer.StateT;
 import com.github.tonivade.purefun.transformer.StateTOf;
-import com.github.tonivade.purefun.transformer.StateT_;
 import com.github.tonivade.purefun.typeclasses.Monad;
 import com.github.tonivade.purefun.typeclasses.MonadError;
 import com.github.tonivade.purefun.typeclasses.MonadReader;
@@ -21,24 +20,24 @@
 
 public interface StateTInstances {
 
-  static <F, S> Monad<Kind<Kind<StateT_, F>, S>> monad(Monad<F> monadF) {
+  static <F, S> Monad<Kind<Kind<StateT<?, ?, ?>, F>, S>> monad(Monad<F> monadF) {
     return StateTMonad.instance(checkNonNull(monadF));
   }
 
-  static <F, S> MonadState<Kind<Kind<StateT_, F>, S>, S> monadState(Monad<F> monadF) {
+  static <F, S> MonadState<Kind<Kind<StateT<?, ?, ?>, F>, S>, S> monadState(Monad<F> monadF) {
     return StateTMonadState.instance(checkNonNull(monadF));
   }
 
-  static <F, S, E> MonadError<Kind<Kind<StateT_, F>, S>, E> monadError(MonadError<F, E> monadErrorF) {
+  static <F, S, E> MonadError<Kind<Kind<StateT<?, ?, ?>, F>, S>, E> monadError(MonadError<F, E> monadErrorF) {
     return StateTMonadError.instance(checkNonNull(monadErrorF));
   }
 
-  static <F, S, R> MonadReader<Kind<Kind<StateT_, F>, S>, R> monadReader(MonadReader<F, R> monadReaderF) {
+  static <F, S, R> MonadReader<Kind<Kind<StateT<?, ?, ?>, F>, S>, R> monadReader(MonadReader<F, R> monadReaderF) {
     return StateTMonadReader.instance(checkNonNull(monadReaderF));
   }
 }
 
-interface StateTMonad<F, S> extends Monad<Kind<Kind<StateT_, F>, S>> {
+interface StateTMonad<F, S> extends Monad<Kind<Kind<StateT<?, ?, ?>, F>, S>> {
 
   static <F, S> StateTMonad<F, S> instance(Monad<F> monadF) {
     return () -> monadF;
@@ -52,13 +51,13 @@ default <T> StateT<F, S, T> pure(T value) {
   }
 
   @Override
-  default <T, R> StateT<F, S, R> flatMap(Kind<Kind<Kind<StateT_, F>, S>, ? extends T> value,
-      Function1<? super T, ? extends Kind<Kind<Kind<StateT_, F>, S>, ? extends R>> map) {
+  default <T, R> StateT<F, S, R> flatMap(Kind<Kind<Kind<StateT<?, ?, ?>, F>, S>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Kind<Kind<StateT<?, ?, ?>, F>, S>, ? extends R>> map) {
     return StateTOf.narrowK(value).flatMap(map.andThen(StateTOf::narrowK));
   }
 }
 
-interface StateTMonadError<F, S, E> extends MonadError<Kind<Kind<StateT_, F>, S>, E>, StateTMonad<F, S> {
+interface StateTMonadError<F, S, E> extends MonadError<Kind<Kind<StateT<?, ?, ?>, F>, S>, E>, StateTMonad<F, S> {
 
   static <F, S, E> StateTMonadError<F, S, E> instance(MonadError<F, E> monadErrorF) {
     return () -> monadErrorF;
@@ -75,8 +74,8 @@ default <A> StateT<F, S, A> raiseError(E error) {
 
   @Override
   default <A> StateT<F, S, A> handleErrorWith(
-      Kind<Kind<Kind<StateT_, F>, S>, A> value,
-      Function1<? super E, ? extends Kind<Kind<Kind<StateT_, F>, S>, ? extends A>> handler) {
+      Kind<Kind<Kind<StateT<?, ?, ?>, F>, S>, A> value,
+      Function1<? super E, ? extends Kind<Kind<Kind<StateT<?, ?, ?>, F>, S>, ? extends A>> handler) {
     StateT<F, S, A> stateT = value.fix(StateTOf::narrowK);
     return StateT.state(monadF(),
         state -> monadF().handleErrorWith(stateT.run(state),
@@ -84,7 +83,7 @@ default <A> StateT<F, S, A> handleErrorWith(
   }
 }
 
-interface StateTMonadState<F, S> extends MonadState<Kind<Kind<StateT_, F>, S>, S>, StateTMonad<F, S> {
+interface StateTMonadState<F, S> extends MonadState<Kind<Kind<StateT<?, ?, ?>, F>, S>, S>, StateTMonad<F, S> {
 
   static <F, S> StateTMonadState<F, S> instance(Monad<F> monadF) {
     return () -> monadF;
@@ -101,7 +100,7 @@ default StateT<F, S, Unit> set(S state) {
   }
 }
 
-interface StateTMonadReader<F, S, R> extends MonadReader<Kind<Kind<StateT_, F>, S>, R>, StateTMonad<F, S> {
+interface StateTMonadReader<F, S, R> extends MonadReader<Kind<Kind<StateT<?, ?, ?>, F>, S>, R>, StateTMonad<F, S> {
 
   static <F, S, R> StateTMonadReader<F, S, R> instance(MonadReader<F, R> monadReaderF) {
     return () -> monadReaderF;
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/TaskInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/TaskInstances.java
index a9eaa2178..e4cbd8d67 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/TaskInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/TaskInstances.java
@@ -18,7 +18,6 @@
 import com.github.tonivade.purefun.data.Sequence;
 import com.github.tonivade.purefun.effect.Task;
 import com.github.tonivade.purefun.effect.TaskOf;
-import com.github.tonivade.purefun.effect.Task_;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.typeclasses.Applicative;
@@ -39,74 +38,74 @@
 
 public interface TaskInstances {
 
-  static Functor<Task_> functor() {
+  static Functor<Task<?>> functor() {
     return TaskFunctor.INSTANCE;
   }
 
-  static Applicative<Task_> applicative() {
+  static Applicative<Task<?>> applicative() {
     return TaskApplicative.INSTANCE;
   }
 
-  static Monad<Task_> monad() {
+  static Monad<Task<?>> monad() {
     return TaskMonad.INSTANCE;
   }
 
-  static MonadError<Task_, Throwable> monadError() {
+  static MonadError<Task<?>, Throwable> monadError() {
     return TaskMonadError.INSTANCE;
   }
 
-  static MonadThrow<Task_> monadThrow() {
+  static MonadThrow<Task<?>> monadThrow() {
     return TaskMonadThrow.INSTANCE;
   }
 
-  static MonadDefer<Task_> monadDefer() {
+  static MonadDefer<Task<?>> monadDefer() {
     return TaskMonadDefer.INSTANCE;
   }
 
-  static Async<Task_> async() {
+  static Async<Task<?>> async() {
     return TaskAsync.INSTANCE;
   }
 
-  static Concurrent<Task_> concurrent() {
+  static Concurrent<Task<?>> concurrent() {
     return TaskConcurrent.instance(Future.DEFAULT_EXECUTOR);
   }
 
-  static Concurrent<Task_> concurrent(Executor executor) {
+  static Concurrent<Task<?>> concurrent(Executor executor) {
     return TaskConcurrent.instance(executor);
   }
 
-  static <A> Reference<Task_, A> ref(A value) {
+  static <A> Reference<Task<?>, A> ref(A value) {
     return Reference.of(monadDefer(), value);
   }
 
-  static <A extends AutoCloseable> Resource<Task_, A> resource(Task<A> acquire) {
+  static <A extends AutoCloseable> Resource<Task<?>, A> resource(Task<A> acquire) {
     return resource(acquire, AutoCloseable::close);
   }
 
-  static <A> Resource<Task_, A> resource(Task<A> acquire, Consumer1<A> release) {
+  static <A> Resource<Task<?>, A> resource(Task<A> acquire, Consumer1<A> release) {
     return Resource.from(monadDefer(), acquire, release);
   }
 
-  static Console<Task_> console() {
+  static Console<Task<?>> console() {
     return TaskConsole.INSTANCE;
   }
 
-  static Runtime<Task_> runtime() {
+  static Runtime<Task<?>> runtime() {
     return TaskRuntime.INSTANCE;
   }
 }
 
-interface TaskFunctor extends Functor<Task_> {
+interface TaskFunctor extends Functor<Task<?>> {
 
   TaskFunctor INSTANCE = new TaskFunctor() {};
 
   @Override
-  default <A, B> Task<B> map(Kind<Task_, ? extends A> value, Function1<? super A, ? extends B> map) {
+  default <A, B> Task<B> map(Kind<Task<?>, ? extends A> value, Function1<? super A, ? extends B> map) {
     return TaskOf.narrowK(value).map(map);
   }
 }
 
-interface TaskPure extends Applicative<Task_> {
+interface TaskPure extends Applicative<Task<?>> {
 
   @Override
   default <A> Task<A> pure(A value) {
@@ -120,25 +119,25 @@ interface TaskApplicative extends TaskPure {
 
   @Override
   default <A, B> Task<B>
-          ap(Kind<Task_, ? extends A> value,
-             Kind<Task_, ? extends Function1<? super A, ? extends B>> apply) {
+          ap(Kind<Task<?>, ? extends A> value,
+             Kind<Task<?>, ? extends Function1<? super A, ? extends B>> apply) {
     return value.fix(TaskOf::<A>narrowK).ap(apply.fix(TaskOf::narrowK));
   }
 }
 
-interface TaskMonad extends TaskPure, Monad<Task_> {
+interface TaskMonad extends TaskPure, Monad<Task<?>> {
 
   TaskMonad INSTANCE = new TaskMonad() {};
 
   @Override
   default <A, B> Task<B>
-          flatMap(Kind<Task_, ? extends A> value,
-                  Function1<? super A, ? extends Kind<Task_, ? extends B>> map) {
+          flatMap(Kind<Task<?>, ? extends A> value,
+                  Function1<? super A, ? extends Kind<Task<?>, ? extends B>> map) {
     return TaskOf.narrowK(value).flatMap(map.andThen(TaskOf::narrowK));
   }
 }
 
-interface TaskMonadError extends TaskMonad, MonadError<Task_, Throwable> {
+interface TaskMonadError extends TaskMonad, MonadError<Task<?>, Throwable> {
 
   TaskMonadError INSTANCE = new TaskMonadError() {};
 
@@ -149,8 +148,8 @@ default <A> Task<A> raiseError(Throwable error) {
 
   @Override
   default <A> Task<A> handleErrorWith(
-      Kind<Task_, A> value,
-      Function1<? super Throwable, ? extends Kind<Task_, ? extends A>> handler) {
+      Kind<Task<?>, A> value,
+      Function1<? super Throwable, ? extends Kind<Task<?>, ? extends A>> handler) {
     // XXX: java8 fails to infer types, I have to do this in steps
     Function1<? super Throwable, Task<A>> mapError = handler.andThen(TaskOf::narrowK);
     Function1<A, Task<A>> map = Task::pure;
@@ -159,33 +158,33 @@ default <A> Task<A> handleErrorWith(
   }
 }
 
-interface TaskMonadThrow extends TaskMonadError, MonadThrow<Task_> {
+interface TaskMonadThrow extends TaskMonadError, MonadThrow<Task<?>> {
 
   TaskMonadThrow INSTANCE = new TaskMonadThrow() {};
 }
 
-interface TaskDefer extends Defer<Task_> {
+interface TaskDefer extends Defer<Task<?>> {
 
   @Override
   default <A> Task<A>
-          defer(Producer<? extends Kind<Task_, ? extends A>> defer) {
+          defer(Producer<? extends Kind<Task<?>, ? extends A>> defer) {
     return Task.defer(defer);
   }
 }
 
-interface TaskBracket extends TaskMonadError, Bracket<Task_, Throwable> {
+interface TaskBracket extends TaskMonadError, Bracket<Task<?>, Throwable> {
 
   @Override
   default <A, B> Task<B>
-          bracket(Kind<Task_, ? extends A> acquire,
-                  Function1<? super A, ? extends Kind<Task_, ? extends B>> use,
-                  Function1<? super A, ? extends Kind<Task_, Unit>> release) {
+          bracket(Kind<Task<?>, ? extends A> acquire,
+                  Function1<? super A, ? extends Kind<Task<?>, ? extends B>> use,
+                  Function1<? super A, ? extends Kind<Task<?>, Unit>> release) {
     return Task.bracket(acquire, use, release);
   }
 }
 
 interface TaskMonadDefer
-    extends MonadDefer<Task_>, TaskDefer, TaskBracket {
+    extends MonadDefer<Task<?>>, TaskDefer, TaskBracket {
 
   TaskMonadDefer INSTANCE = new TaskMonadDefer() {};
 
@@ -195,17 +194,17 @@ default Task<Unit> sleep(Duration duration) {
   }
 }
 
-interface TaskAsync extends Async<Task_>, TaskMonadDefer {
+interface TaskAsync extends Async<Task<?>>, TaskMonadDefer {
 
   TaskAsync INSTANCE = new TaskAsync() {};
 
   @Override
-  default <A> Task<A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<Task_, Unit>> consumer) {
+  default <A> Task<A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<Task<?>, Unit>> consumer) {
     return Task.asyncF(consumer.andThen(TaskOf::narrowK));
   }
 }
 
-interface TaskConcurrent extends TaskAsync, Concurrent<Task_> {
+interface TaskConcurrent extends TaskAsync, Concurrent<Task<?>> {
 
   static TaskConcurrent instance(Executor executor) {
     return () -> executor;
@@ -214,20 +213,20 @@ static TaskConcurrent instance(Executor executor) {
   Executor executor();
 
   @Override
-  default <A, B> Task<Either<Tuple2<A, Fiber<Task_, B>>, Tuple2<Fiber<Task_, A>, B>>> racePair(Kind<Task_, ? extends A> fa,
-    Kind<Task_, ? extends B> fb) {
+  default <A, B> Task<Either<Tuple2<A, Fiber<Task<?>, B>>, Tuple2<Fiber<Task<?>, A>, B>>> racePair(Kind<Task<?>, ? extends A> fa,
+    Kind<Task<?>, ? extends B> fb) {
     return Task.racePair(executor(), fa, fb);
   }
 
   @Override
-  default <A> Task<Fiber<Task_, A>> fork(Kind<Task_, ? extends A> value) {
+  default <A> Task<Fiber<Task<?>, A>> fork(Kind<Task<?>, ? extends A> value) {
     Task<A> fix = value.fix(TaskOf::narrowK);
     return fix.fork();
   }
 
 }
 
-final class TaskConsole implements Console<Task_> {
+final class TaskConsole implements Console<Task<?>> {
 
   public static final TaskConsole INSTANCE = new TaskConsole();
 
@@ -244,27 +243,27 @@ public Task<Unit> println(String text) {
   }
 }
 
-interface TaskRuntime extends Runtime<Task_> {
+interface TaskRuntime extends Runtime<Task<?>> {
 
   TaskRuntime INSTANCE = new TaskRuntime() {};
 
   @Override
-  default <T> T run(Kind<Task_, T> value) {
+  default <T> T run(Kind<Task<?>, T> value) {
     return value.fix(toTask()).safeRunSync().getOrElseThrow();
   }
 
   @Override
-  default <T> Sequence<T> run(Sequence<Kind<Task_, T>> values) {
+  default <T> Sequence<T> run(Sequence<Kind<Task<?>, T>> values) {
     return run(Task.traverse(values.map(TaskOf::<T>narrowK)));
   }
 
   @Override
-  default <T> Future<T> parRun(Kind<Task_, T> value, Executor executor) {
+  default <T> Future<T> parRun(Kind<Task<?>, T> value, Executor executor) {
     return value.fix(toTask()).runAsync();
   }
 
   @Override
-  default <T> Future<Sequence<T>> parRun(Sequence<Kind<Task_, T>> values, Executor executor) {
+  default <T> Future<Sequence<T>> parRun(Sequence<Kind<Task<?>, T>> values, Executor executor) {
     return parRun(Task.traverse(values.map(TaskOf::<T>narrowK)), executor);
   }
 }
\ No newline at end of file
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/TrampolineInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/TrampolineInstances.java
index be4e46ee4..387048143 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/TrampolineInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/TrampolineInstances.java
@@ -9,7 +9,6 @@
 import com.github.tonivade.purefun.core.Producer;
 import com.github.tonivade.purefun.free.Trampoline;
 import com.github.tonivade.purefun.free.TrampolineOf;
-import com.github.tonivade.purefun.free.Trampoline_;
 import com.github.tonivade.purefun.typeclasses.Applicative;
 import com.github.tonivade.purefun.typeclasses.Defer;
 import com.github.tonivade.purefun.typeclasses.Functor;
@@ -17,38 +16,38 @@
 
 public interface TrampolineInstances {
 
-  static Functor<Trampoline_> functor() {
+  static Functor<Trampoline<?>> functor() {
     return TrampolineFunctor.INSTANCE;
   }
 
-  static Applicative<Trampoline_> applicative() {
+  static Applicative<Trampoline<?>> applicative() {
     return TrampolineApplicative.INSTANCE;
   }
 
-  static Monad<Trampoline_> monad() {
+  static Monad<Trampoline<?>> monad() {
     return TrampolineMonad.INSTANCE;
   }
 
-  static Defer<Trampoline_> defer() {
+  static Defer<Trampoline<?>> defer() {
     return TrampolineDefer.INSTANCE;
   }
 }
 
-interface TrampolineFunctor extends Functor<Trampoline_> {
+interface TrampolineFunctor extends Functor<Trampoline<?>> {
 
   TrampolineFunctor INSTANCE = new TrampolineFunctor() {};
 
   @Override
-  default <T, R> Kind<Trampoline_, R> map(
-      Kind<Trampoline_, ? extends T> value, Function1<? super T, ? extends R> mapper) {
+  default <T, R> Kind<Trampoline<?>, R> map(
+      Kind<Trampoline<?>, ? extends T> value, Function1<? super T, ? extends R> mapper) {
     return TrampolineOf.narrowK(value).map(mapper);
   }
 }
 
-interface TrampolinePure extends Applicative<Trampoline_> {
+interface TrampolinePure extends Applicative<Trampoline<?>> {
 
   @Override
-  default <T> Kind<Trampoline_, T> pure(T value) {
+  default <T> Kind<Trampoline<?>, T> pure(T value) {
     return Trampoline.done(value);
   }
 }
@@ -58,29 +57,29 @@ interface TrampolineApplicative extends TrampolinePure {
   TrampolineApplicative INSTANCE = new TrampolineApplicative() {};
 
   @Override
-  default <T, R> Kind<Trampoline_, R> ap(Kind<Trampoline_, ? extends T> value, 
-      Kind<Trampoline_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Kind<Trampoline<?>, R> ap(Kind<Trampoline<?>, ? extends T> value,
+      Kind<Trampoline<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return TrampolineOf.narrowK(value).flatMap(t -> TrampolineOf.narrowK(apply).map(f -> f.apply(t)));
   }
 }
 
-interface TrampolineMonad extends TrampolinePure, Monad<Trampoline_> {
+interface TrampolineMonad extends TrampolinePure, Monad<Trampoline<?>> {
 
   TrampolineMonad INSTANCE = new TrampolineMonad() {};
 
   @Override
-  default <T, R> Kind<Trampoline_, R> flatMap(Kind<Trampoline_, ? extends T> value,
-      Function1<? super T, ? extends Kind<Trampoline_, ? extends R>> map) {
+  default <T, R> Kind<Trampoline<?>, R> flatMap(Kind<Trampoline<?>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Trampoline<?>, ? extends R>> map) {
     return TrampolineOf.narrowK(value).flatMap(map.andThen(TrampolineOf::narrowK));
   }
 }
 
-interface TrampolineDefer extends Defer<Trampoline_> {
+interface TrampolineDefer extends Defer<Trampoline<?>> {
 
   TrampolineDefer INSTANCE = new TrampolineDefer() {};
 
   @Override
-  default <A> Kind<Trampoline_, A> defer(Producer<? extends Kind<Trampoline_, ? extends A>> defer) {
+  default <A> Kind<Trampoline<?>, A> defer(Producer<? extends Kind<Trampoline<?>, ? extends A>> defer) {
     return Trampoline.more(() -> defer.get().fix(TrampolineOf::narrowK));
   }
 }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/TryInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/TryInstances.java
index 5da54d8c8..ce1b6e907 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/TryInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/TryInstances.java
@@ -17,7 +17,6 @@
 import com.github.tonivade.purefun.type.EvalOf;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.type.TryOf;
-import com.github.tonivade.purefun.type.Try_;
 import com.github.tonivade.purefun.typeclasses.Applicative;
 import com.github.tonivade.purefun.typeclasses.Foldable;
 import com.github.tonivade.purefun.typeclasses.Functor;
@@ -28,7 +27,7 @@
 
 public interface TryInstances {
 
-  static <T> Eq<Kind<Try_, T>> eq(Eq<T> eqSuccess) {
+  static <T> Eq<Kind<Try<?>, T>> eq(Eq<T> eqSuccess) {
     final Eq<Throwable> eqFailure = Eq.throwable();
     return (a, b) -> {
       if (a instanceof Try.Failure(var causeA) && b instanceof Try.Failure(var causeB)) {
@@ -41,49 +40,49 @@ static <T> Eq<Kind<Try_, T>> eq(Eq<T> eqSuccess) {
     };
   }
 
-  static Functor<Try_> functor() {
+  static Functor<Try<?>> functor() {
     return TryFunctor.INSTANCE;
   }
 
-  static Applicative<Try_> applicative() {
+  static Applicative<Try<?>> applicative() {
     return TryApplicative.INSTANCE;
   }
 
-  static Monad<Try_> monad() {
+  static Monad<Try<?>> monad() {
     return TryMonad.INSTANCE;
   }
 
-  static MonadError<Try_, Throwable> monadError() {
+  static MonadError<Try<?>, Throwable> monadError() {
     return TryMonadError.INSTANCE;
   }
 
-  static MonadThrow<Try_> monadThrow() {
+  static MonadThrow<Try<?>> monadThrow() {
     return TryMonadThrow.INSTANCE;
   }
 
-  static Foldable<Try_> foldable() {
+  static Foldable<Try<?>> foldable() {
     return TryFoldable.INSTANCE;
   }
 
-  static Traverse<Try_> traverse() {
+  static Traverse<Try<?>> traverse() {
     return TryTraverse.INSTANCE;
   }
 }
 
-interface TryFunctor extends Functor<Try_> {
+interface TryFunctor extends Functor<Try<?>> {
 
   TryFunctor INSTANCE = new TryFunctor() {};
 
   @Override
-  default <T, R> Kind<Try_, R> map(Kind<Try_, ? extends T> value, Function1<? super T, ? extends R> mapper) {
+  default <T, R> Kind<Try<?>, R> map(Kind<Try<?>, ? extends T> value, Function1<? super T, ? extends R> mapper) {
     return TryOf.narrowK(value).map(mapper);
   }
 }
 
-interface TryPure extends Applicative<Try_> {
+interface TryPure extends Applicative<Try<?>> {
 
   @Override
-  default <T> Kind<Try_, T> pure(T value) {
+  default <T> Kind<Try<?>, T> pure(T value) {
     return Try.success(value);
   }
 }
@@ -93,28 +92,28 @@ interface TryApplicative extends TryPure {
   TryApplicative INSTANCE = new TryApplicative() {};
 
   @Override
-  default <T, R> Kind<Try_, R> ap(Kind<Try_, ? extends T> value,
-      Kind<Try_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Kind<Try<?>, R> ap(Kind<Try<?>, ? extends T> value,
+      Kind<Try<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return TryOf.narrowK(value).flatMap(t -> TryOf.narrowK(apply).map(f -> f.apply(t)));
   }
 }
 
-interface TryMonad extends TryPure, Monad<Try_> {
+interface TryMonad extends TryPure, Monad<Try<?>> {
 
   TryMonad INSTANCE = new TryMonad() {};
 
   @Override
-  default <T, R> Kind<Try_, R> flatMap(Kind<Try_, ? extends T> value,
-      Function1<? super T, ? extends Kind<Try_, ? extends R>> map) {
+  default <T, R> Kind<Try<?>, R> flatMap(Kind<Try<?>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Try<?>, ? extends R>> map) {
     return TryOf.narrowK(value).flatMap(map.andThen(TryOf::narrowK));
   }
 
   @Override
-  default <T, R> Kind<Try_, R> tailRecM(T value, Function1<T, ? extends Kind<Try_, Either<T, R>>> map) {
+  default <T, R> Kind<Try<?>, R> tailRecM(T value, Function1<T, ? extends Kind<Try<?>, Either<T, R>>> map) {
     return loop(value, map).run();
   }
 
-  private <T, R> Trampoline<Kind<Try_, R>> loop(T value, Function1<T, ? extends Kind<Try_, Either<T, R>>> map) {
+  private <T, R> Trampoline<Kind<Try<?>, R>> loop(T value, Function1<T, ? extends Kind<Try<?>, Either<T, R>>> map) {
     return switch (map.andThen(TryOf::narrowK).apply(value)) {
       case Try.Failure<Either<T, R>>(var error) -> Trampoline.done(Try.failure(error));
       case Try.Success<Either<T, R>>(Either.Right<T, R>(var right)) -> Trampoline.done(Try.success(right));
@@ -123,38 +122,38 @@ private <T, R> Trampoline<Kind<Try_, R>> loop(T value, Function1<T, ? extends Ki
   }
 }
 
-interface TryMonadError extends TryMonad, MonadError<Try_, Throwable> {
+interface TryMonadError extends TryMonad, MonadError<Try<?>, Throwable> {
 
   TryMonadError INSTANCE = new TryMonadError() {};
 
   @Override
-  default <A> Kind<Try_, A> raiseError(Throwable error) {
+  default <A> Kind<Try<?>, A> raiseError(Throwable error) {
     return Try.failure(error);
   }
 
   @Override
-  default <A> Kind<Try_, A> handleErrorWith(Kind<Try_, A> value,
-      Function1<? super Throwable, ? extends Kind<Try_, ? extends A>> handler) {
+  default <A> Kind<Try<?>, A> handleErrorWith(Kind<Try<?>, A> value,
+      Function1<? super Throwable, ? extends Kind<Try<?>, ? extends A>> handler) {
     return TryOf.narrowK(value).fold(handler.andThen(TryOf::narrowK), Try::success);
   }
 }
 
-interface TryMonadThrow extends TryMonadError, MonadThrow<Try_> {
+interface TryMonadThrow extends TryMonadError, MonadThrow<Try<?>> {
 
   TryMonadThrow INSTANCE = new TryMonadThrow() {};
 }
 
-interface TryFoldable extends Foldable<Try_> {
+interface TryFoldable extends Foldable<Try<?>> {
 
   TryFoldable INSTANCE = new TryFoldable() {};
 
   @Override
-  default <A, B> B foldLeft(Kind<Try_, ? extends A> value, B initial, Function2<? super B, ? super A, ? extends B> mapper) {
+  default <A, B> B foldLeft(Kind<Try<?>, ? extends A> value, B initial, Function2<? super B, ? super A, ? extends B> mapper) {
     return TryOf.narrowK(value).fold(t -> initial, a -> mapper.apply(initial, a));
   }
 
   @Override
-  default <A, B> Eval<B> foldRight(Kind<Try_, ? extends A> value, Eval<? extends B> initial,
+  default <A, B> Eval<B> foldRight(Kind<Try<?>, ? extends A> value, Eval<? extends B> initial,
       Function2<? super A, ? super Eval<? extends B>, ? extends Eval<? extends B>> mapper) {
     return TryOf.<A>narrowK(value).fold(
         cons(initial).andThen(EvalOf::<B>narrowK),
@@ -162,13 +161,13 @@ default <A, B> Eval<B> foldRight(Kind<Try_, ? extends A> value, Eval<? extends B
   }
 }
 
-interface TryTraverse extends Traverse<Try_>, TryFoldable {
+interface TryTraverse extends Traverse<Try<?>>, TryFoldable {
 
   TryTraverse INSTANCE = new TryTraverse() {};
 
   @Override
-  default <G, T, R> Kind<G, Kind<Try_, R>> traverse(
-      Applicative<G> applicative, Kind<Try_, T> value,
+  default <G, T, R> Kind<G, Kind<Try<?>, R>> traverse(
+      Applicative<G> applicative, Kind<Try<?>, T> value,
       Function1<? super T, ? extends Kind<G, ? extends R>> mapper) {
     return TryOf.narrowK(value).fold(
         t -> applicative.pure(Try.<R>failure(t).kind()),
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/TupleInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/TupleInstances.java
index 774aa14d8..8656e1267 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/TupleInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/TupleInstances.java
@@ -5,42 +5,41 @@
 package com.github.tonivade.purefun.instances;
 
 import com.github.tonivade.purefun.Kind;
-import com.github.tonivade.purefun.core.Tuple1Of;
-import com.github.tonivade.purefun.core.Tuple1_;
-import com.github.tonivade.purefun.core.Tuple2Of;
-import com.github.tonivade.purefun.core.Tuple2_;
 import com.github.tonivade.purefun.core.Function1;
+import com.github.tonivade.purefun.core.Tuple1;
+import com.github.tonivade.purefun.core.Tuple1Of;
 import com.github.tonivade.purefun.core.Tuple2;
+import com.github.tonivade.purefun.core.Tuple2Of;
 import com.github.tonivade.purefun.typeclasses.Bifunctor;
 import com.github.tonivade.purefun.typeclasses.Functor;
 
 public interface TupleInstances {
 
-  static Functor<Tuple1_> functor() {
+  static Functor<Tuple1<?>> functor() {
     return Tuple1Functor.INSTANCE;
   }
 
-  static Bifunctor<Tuple2_> bifunctor() {
+  static Bifunctor<Tuple2<?, ?>> bifunctor() {
     return Tuple2Bifunctor.INSTANCE;
   }
 }
 
-interface Tuple1Functor extends Functor<Tuple1_> {
+interface Tuple1Functor extends Functor<Tuple1<?>> {
 
   Tuple1Functor INSTANCE = new Tuple1Functor() {};
 
   @Override
-  default <T, R> Kind<Tuple1_, R> map(Kind<Tuple1_, ? extends T> value, Function1<? super T, ? extends R> map) {
+  default <T, R> Kind<Tuple1<?>, R> map(Kind<Tuple1<?>, ? extends T> value, Function1<? super T, ? extends R> map) {
     return value.fix(Tuple1Of::narrowK).map1(map);
   }
 }
 
-interface Tuple2Bifunctor extends Bifunctor<Tuple2_> {
+interface Tuple2Bifunctor extends Bifunctor<Tuple2<?, ?>> {
 
   Tuple2Bifunctor INSTANCE = new Tuple2Bifunctor() {};
 
   @Override
-  default <A, B, C, D> Tuple2<C, D> bimap(Kind<Kind<Tuple2_, A>, ? extends B> value,
+  default <A, B, C, D> Tuple2<C, D> bimap(Kind<Kind<Tuple2<?, ?>, A>, ? extends B> value,
                                           Function1<? super A, ? extends C> leftMap,
                                           Function1<? super B, ? extends D> rightMap) {
     return value.fix(Tuple2Of::narrowK).map(leftMap, rightMap);
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/UIOInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/UIOInstances.java
index 2392132db..aaa05e499 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/UIOInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/UIOInstances.java
@@ -18,7 +18,6 @@
 import com.github.tonivade.purefun.data.Sequence;
 import com.github.tonivade.purefun.effect.UIO;
 import com.github.tonivade.purefun.effect.UIOOf;
-import com.github.tonivade.purefun.effect.UIO_;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.typeclasses.Applicative;
@@ -37,62 +36,62 @@
 
 public interface UIOInstances {
 
-  static Functor<UIO_> functor() {
+  static Functor<UIO<?>> functor() {
     return UIOFunctor.INSTANCE;
   }
 
-  static Applicative<UIO_> applicative() {
+  static Applicative<UIO<?>> applicative() {
     return UIOApplicative.INSTANCE;
   }
 
-  static Monad<UIO_> monad() {
+  static Monad<UIO<?>> monad() {
     return UIOMonad.INSTANCE;
   }
 
-  static MonadError<UIO_, Throwable> monadError() {
+  static MonadError<UIO<?>, Throwable> monadError() {
     return UIOMonadError.INSTANCE;
   }
 
-  static MonadThrow<UIO_> monadThrow() {
+  static MonadThrow<UIO<?>> monadThrow() {
     return UIOMonadThrow.INSTANCE;
   }
 
-  static MonadDefer<UIO_> monadDefer() {
+  static MonadDefer<UIO<?>> monadDefer() {
     return UIOMonadDefer.INSTANCE;
   }
 
-  static Async<UIO_> async() {
+  static Async<UIO<?>> async() {
     return UIOAsync.INSTANCE;
   }
 
-  static Concurrent<UIO_> concurrent() {
+  static Concurrent<UIO<?>> concurrent() {
     return concurrent(Future.DEFAULT_EXECUTOR);
   }
 
-  static Concurrent<UIO_> concurrent(Executor executor) {
+  static Concurrent<UIO<?>> concurrent(Executor executor) {
     return UIOConcurrent.instance(executor);
   }
-  
-  static Runtime<UIO_> runtime() {
+
+  static Runtime<UIO<?>> runtime() {
     return UIORuntime.INSTANCE;
   }
-  
-  static Console<UIO_> console() {
+
+  static Console<UIO<?>> console() {
     return UIOConsole.INSTANCE;
   }
 }
 
-interface UIOFunctor extends Functor<UIO_> {
+interface UIOFunctor extends Functor<UIO<?>> {
 
   UIOFunctor INSTANCE = new UIOFunctor() {};
 
   @Override
-  default <A, B> UIO<B> map(Kind<UIO_, ? extends A> value, Function1<? super A, ? extends B> map) {
+  default <A, B> UIO<B> map(Kind<UIO<?>, ? extends A> value, Function1<? super A, ? extends B> map) {
     return UIOOf.narrowK(value).map(map);
   }
 }
 
-interface UIOPure extends Applicative<UIO_> {
+interface UIOPure extends Applicative<UIO<?>> {
 
   @Override
   default <A> UIO<A> pure(A value) {
@@ -105,24 +104,24 @@ interface UIOApplicative extends UIOPure {
   UIOApplicative INSTANCE = new UIOApplicative() {};
 
   @Override
-  default <A, B> UIO<B> ap(Kind<UIO_, ? extends A> value, 
-      Kind<UIO_, ? extends Function1<? super A, ? extends B>> apply) {
+  default <A, B> UIO<B> ap(Kind<UIO<?>, ? extends A> value,
+      Kind<UIO<?>, ? extends Function1<? super A, ? extends B>> apply) {
     return value.fix(UIOOf::<A>narrowK).ap(apply.fix(UIOOf::narrowK));
   }
 }
 
-interface UIOMonad extends UIOPure, Monad<UIO_> {
+interface UIOMonad extends UIOPure, Monad<UIO<?>> {
 
   UIOMonad INSTANCE = new UIOMonad() {};
 
   @Override
-  default <A, B> UIO<B> flatMap(Kind<UIO_, ? extends A> value, 
-      Function1<? super A, ? extends Kind<UIO_, ? extends B>> map) {
+  default <A, B> UIO<B> flatMap(Kind<UIO<?>, ? extends A> value,
+      Function1<? super A, ? extends Kind<UIO<?>, ? extends B>> map) {
     return value.fix(toUIO()).flatMap(map.andThen(UIOOf::narrowK));
   }
 }
 
-interface UIOMonadError extends UIOMonad, MonadError<UIO_, Throwable> {
+interface UIOMonadError extends UIOMonad, MonadError<UIO<?>, Throwable> {
 
   UIOMonadError INSTANCE = new UIOMonadError() {};
 
@@ -133,8 +132,8 @@ default <A> UIO<A> raiseError(Throwable error) {
 
   @Override
   default <A> UIO<A> handleErrorWith(
-      Kind<UIO_, A> value,
-      Function1<? super Throwable, ? extends Kind<UIO_, ? extends A>> handler) {
+      Kind<UIO<?>, A> value,
+      Function1<? super Throwable, ? extends Kind<UIO<?>, ? extends A>> handler) {
     Function1<? super Throwable, UIO<A>> mapError = handler.andThen(UIOOf::narrowK);
     Function1<A, UIO<A>> map = UIO::pure;
     UIO<A> uio = UIOOf.narrowK(value);
@@ -142,33 +141,33 @@ default <A> UIO<A> handleErrorWith(
   }
 }
 
-interface UIOMonadThrow extends UIOMonadError, MonadThrow<UIO_> {
+interface UIOMonadThrow extends UIOMonadError, MonadThrow<UIO<?>> {
 
   UIOMonadThrow INSTANCE = new UIOMonadThrow() {};
 }
 
-interface UIODefer extends Defer<UIO_> {
+interface UIODefer extends Defer<UIO<?>> {
 
   @Override
   default <A> UIO<A>
-          defer(Producer<? extends Kind<UIO_, ? extends A>> defer) {
+          defer(Producer<? extends Kind<UIO<?>, ? extends A>> defer) {
     return UIO.defer(defer::get);
   }
 }
 
-interface UIOBracket extends UIOMonadError, Bracket<UIO_, Throwable> {
+interface UIOBracket extends UIOMonadError, Bracket<UIO<?>, Throwable> {
 
   @Override
   default <A, B> UIO<B>
-          bracket(Kind<UIO_, ? extends A> acquire,
-                  Function1<? super A, ? extends Kind<UIO_, ? extends B>> use,
-                  Function1<? super A, ? extends Kind<UIO_, Unit>> release) {
+          bracket(Kind<UIO<?>, ? extends A> acquire,
+                  Function1<? super A, ? extends Kind<UIO<?>, ? extends B>> use,
+                  Function1<? super A, ? extends Kind<UIO<?>, Unit>> release) {
     return UIO.bracket(acquire, use, release);
   }
 }
 
 interface UIOMonadDefer
-    extends MonadDefer<UIO_>, UIODefer, UIOBracket {
+    extends MonadDefer<UIO<?>>, UIODefer, UIOBracket {
 
   UIOMonadDefer INSTANCE = new UIOMonadDefer() {};
 
@@ -178,37 +177,37 @@ default UIO<Unit> sleep(Duration duration) {
   }
 }
 
-interface UIOAsync extends Async<UIO_>, UIOMonadDefer {
+interface UIOAsync extends Async<UIO<?>>, UIOMonadDefer {
 
   UIOAsync INSTANCE = new UIOAsync() {};
-  
+
   @Override
-  default <A> UIO<A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<UIO_, Unit>> consumer) {
+  default <A> UIO<A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<UIO<?>, Unit>> consumer) {
     return UIO.cancellable(consumer.andThen(UIOOf::narrowK));
   }
 }
 
-interface UIOConcurrent extends Concurrent<UIO_>, UIOAsync {
-  
+interface UIOConcurrent extends Concurrent<UIO<?>>, UIOAsync {
+
   static UIOConcurrent instance(Executor executor) {
     return () -> executor;
   }
-  
+
   Executor executor();
-  
+
   @Override
-  default <A, B> UIO<Either<Tuple2<A, Fiber<UIO_, B>>, Tuple2<Fiber<UIO_, A>, B>>> racePair(Kind<UIO_, ? extends A> fa, Kind<UIO_, ? extends B> fb) {
+  default <A, B> UIO<Either<Tuple2<A, Fiber<UIO<?>, B>>, Tuple2<Fiber<UIO<?>, A>, B>>> racePair(Kind<UIO<?>, ? extends A> fa, Kind<UIO<?>, ? extends B> fb) {
     return UIO.racePair(executor(), fa, fb);
   }
-  
+
   @Override
-  default <A> UIO<Fiber<UIO_, A>> fork(Kind<UIO_, ? extends A> value) {
+  default <A> UIO<Fiber<UIO<?>, A>> fork(Kind<UIO<?>, ? extends A> value) {
     UIO<A> fix = value.fix(UIOOf::narrowK);
     return fix.fork();
   }
 }
 
-final class UIOConsole implements Console<UIO_> {
+final class UIOConsole implements Console<UIO<?>> {
 
   public static final UIOConsole INSTANCE = new UIOConsole();
 
@@ -225,27 +224,27 @@ public UIO<Unit> println(String text) {
   }
 }
 
-interface UIORuntime extends Runtime<UIO_> {
-  
+interface UIORuntime extends Runtime<UIO<?>> {
+
   UIORuntime INSTANCE = new UIORuntime() {};
 
   @Override
-  default <T> T run(Kind<UIO_, T> value) {
+  default <T> T run(Kind<UIO<?>, T> value) {
     return value.fix(toUIO()).unsafeRunSync();
   }
-  
+
   @Override
-  default <T> Sequence<T> run(Sequence<Kind<UIO_, T>> values) {
+  default <T> Sequence<T> run(Sequence<Kind<UIO<?>, T>> values) {
     return run(UIO.traverse(values.map(UIOOf::<T>narrowK)));
   }
 
   @Override
-  default <T> Future<T> parRun(Kind<UIO_, T> value, Executor executor) {
+  default <T> Future<T> parRun(Kind<UIO<?>, T> value, Executor executor) {
     return value.fix(toUIO()).runAsync();
   }
-  
+
   @Override
-  default <T> Future<Sequence<T>> parRun(Sequence<Kind<UIO_, T>> values, Executor executor) {
+  default <T> Future<Sequence<T>> parRun(Sequence<Kind<UIO<?>, T>> values, Executor executor) {
     return parRun(UIO.traverse(values.map(UIOOf::<T>narrowK)), executor);
   }
 }
\ No newline at end of file
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/URIOInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/URIOInstances.java
index 9558a7f6d..922c6f23e 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/URIOInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/URIOInstances.java
@@ -19,7 +19,6 @@
 import com.github.tonivade.purefun.effect.UIO;
 import com.github.tonivade.purefun.effect.URIO;
 import com.github.tonivade.purefun.effect.URIOOf;
-import com.github.tonivade.purefun.effect.URIO_;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.typeclasses.Applicative;
@@ -39,60 +38,60 @@
 @SuppressWarnings("unchecked")
 public interface URIOInstances {
 
-  static <R> Functor<Kind<URIO_, R>> functor() {
+  static <R> Functor<Kind<URIO<?, ?>, R>> functor() {
     return URIOFunctor.INSTANCE;
   }
 
-  static <R> Applicative<Kind<URIO_, R>> applicative() {
+  static <R> Applicative<Kind<URIO<?, ?>, R>> applicative() {
     return URIOApplicative.INSTANCE;
   }
 
-  static <R> Monad<Kind<URIO_, R>> monad() {
+  static <R> Monad<Kind<URIO<?, ?>, R>> monad() {
     return URIOMonad.INSTANCE;
   }
 
-  static <R> MonadThrow<Kind<URIO_, R>> monadThrow() {
+  static <R> MonadThrow<Kind<URIO<?, ?>, R>> monadThrow() {
     return URIOMonadThrow.INSTANCE;
   }
 
-  static <R> MonadDefer<Kind<URIO_, R>> monadDefer() {
+  static <R> MonadDefer<Kind<URIO<?, ?>, R>> monadDefer() {
     return URIOMonadDefer.INSTANCE;
   }
 
-  static <R> Async<Kind<URIO_, R>> async() {
+  static <R> Async<Kind<URIO<?, ?>, R>> async() {
     return URIOAsync.INSTANCE;
   }
 
-  static <R> Concurrent<Kind<URIO_, R>> concurrent() {
+  static <R> Concurrent<Kind<URIO<?, ?>, R>> concurrent() {
     return concurrent(Future.DEFAULT_EXECUTOR);
   }
 
-  static <R> Concurrent<Kind<URIO_, R>> concurrent(Executor executor) {
+  static <R> Concurrent<Kind<URIO<?, ?>, R>> concurrent(Executor executor) {
     return URIOConcurrent.instance(executor);
   }
 
-  static <R> Console<Kind<Kind<URIO_, R>, Throwable>> console() {
+  static <R> Console<Kind<Kind<URIO<?, ?>, R>, Throwable>> console() {
     return URIOConsole.INSTANCE;
   }
 
-  static <R> Runtime<Kind<URIO_, R>> runtime(R env) {
+  static <R> Runtime<Kind<URIO<?, ?>, R>> runtime(R env) {
     return URIORuntime.instance(env);
   }
 }
 
-interface URIOFunctor<R> extends Functor<Kind<URIO_, R>> {
+interface URIOFunctor<R> extends Functor<Kind<URIO<?, ?>, R>> {
 
   @SuppressWarnings("rawtypes")
   URIOFunctor INSTANCE = new URIOFunctor() {};
 
   @Override
-  default <A, B> URIO<R, B> map(Kind<Kind<URIO_, R>, ? extends A> value,
+  default <A, B> URIO<R, B> map(Kind<Kind<URIO<?, ?>, R>, ? extends A> value,
       Function1<? super A, ? extends B> map) {
     return URIOOf.narrowK(value).map(map);
   }
 }
 
-interface URIOPure<R> extends Applicative<Kind<URIO_, R>> {
+interface URIOPure<R> extends Applicative<Kind<URIO<?, ?>, R>> {
 
   @Override
   default <A> URIO<R, A> pure(A value) {
@@ -107,26 +106,26 @@ interface URIOApplicative<R> extends URIOPure<R> {
 
   @Override
   default <A, B> URIO<R, B>
-          ap(Kind<Kind<URIO_, R>, ? extends A> value,
-             Kind<Kind<URIO_, R>, ? extends Function1<? super A, ? extends B>> apply) {
+          ap(Kind<Kind<URIO<?, ?>, R>, ? extends A> value,
+             Kind<Kind<URIO<?, ?>, R>, ? extends Function1<? super A, ? extends B>> apply) {
     return value.fix(URIOOf::<R, A>narrowK).ap(apply.fix(URIOOf::narrowK));
   }
 }
 
-interface URIOMonad<R> extends URIOPure<R>, Monad<Kind<URIO_, R>> {
+interface URIOMonad<R> extends URIOPure<R>, Monad<Kind<URIO<?, ?>, R>> {
 
   @SuppressWarnings("rawtypes")
   URIOMonad INSTANCE = new URIOMonad() {};
 
   @Override
   default <A, B> URIO<R, B>
-          flatMap(Kind<Kind<URIO_, R>, ? extends A> value,
-                  Function1<? super A, ? extends Kind<Kind<URIO_, R>, ? extends B>> map) {
+          flatMap(Kind<Kind<URIO<?, ?>, R>, ? extends A> value,
+                  Function1<? super A, ? extends Kind<Kind<URIO<?, ?>, R>, ? extends B>> map) {
     return value.fix(toURIO()).flatMap(map.andThen(URIOOf::narrowK));
   }
 }
 
-interface URIOMonadError<R> extends URIOMonad<R>, MonadError<Kind<URIO_, R>, Throwable> {
+interface URIOMonadError<R> extends URIOMonad<R>, MonadError<Kind<URIO<?, ?>, R>, Throwable> {
 
   @SuppressWarnings("rawtypes")
   URIOMonadError INSTANCE = new URIOMonadError<>() {
@@ -139,8 +138,8 @@ default <A> URIO<R, A> raiseError(Throwable error) {
 
   @Override
   default <A> URIO<R, A> handleErrorWith(
-      Kind<Kind<URIO_, R>, A> value,
-      Function1<? super Throwable, ? extends Kind<Kind<URIO_, R>, ? extends A>> handler) {
+      Kind<Kind<URIO<?, ?>, R>, A> value,
+      Function1<? super Throwable, ? extends Kind<Kind<URIO<?, ?>, R>, ? extends A>> handler) {
     // XXX: java8 fails to infer types, I have to do this in steps
     Function1<? super Throwable, URIO<R, A>> mapError = handler.andThen(URIOOf::narrowK);
     Function1<A, URIO<R, A>> map = URIO::pure;
@@ -151,34 +150,34 @@ default <A> URIO<R, A> handleErrorWith(
 
 interface URIOMonadThrow<R>
     extends URIOMonadError<R>,
-            MonadThrow<Kind<URIO_, R>> {
+            MonadThrow<Kind<URIO<?, ?>, R>> {
   @SuppressWarnings("rawtypes")
   URIOMonadThrow INSTANCE = new URIOMonadThrow<>() {
   };
 }
 
-interface URIODefer<R> extends Defer<Kind<URIO_, R>> {
+interface URIODefer<R> extends Defer<Kind<URIO<?, ?>, R>> {
 
   @Override
   default <A> URIO<R, A>
-          defer(Producer<? extends Kind<Kind<URIO_, R>, ? extends A>> defer) {
+          defer(Producer<? extends Kind<Kind<URIO<?, ?>, R>, ? extends A>> defer) {
     return URIO.defer(defer::get);
   }
 }
 
-interface URIOBracket<R> extends URIOMonadError<R>, Bracket<Kind<URIO_, R>, Throwable> {
+interface URIOBracket<R> extends URIOMonadError<R>, Bracket<Kind<URIO<?, ?>, R>, Throwable> {
 
   @Override
   default <A, B> URIO<R, B>
-          bracket(Kind<Kind<URIO_, R>, ? extends A> acquire,
-                  Function1<? super A, ? extends Kind<Kind<URIO_, R>, ? extends B>> use,
-                  Function1<? super A, ? extends Kind<Kind<URIO_, R>, Unit>> release) {
+          bracket(Kind<Kind<URIO<?, ?>, R>, ? extends A> acquire,
+                  Function1<? super A, ? extends Kind<Kind<URIO<?, ?>, R>, ? extends B>> use,
+                  Function1<? super A, ? extends Kind<Kind<URIO<?, ?>, R>, Unit>> release) {
     return URIO.bracket(acquire, use, release);
   }
 }
 
 interface URIOMonadDefer<R>
-    extends MonadDefer<Kind<URIO_, R>>, URIODefer<R>, URIOBracket<R> {
+    extends MonadDefer<Kind<URIO<?, ?>, R>>, URIODefer<R>, URIOBracket<R> {
 
   @SuppressWarnings("rawtypes")
   URIOMonadDefer INSTANCE = new URIOMonadDefer<>() {
@@ -190,19 +189,19 @@ default URIO<R, Unit> sleep(Duration duration) {
   }
 }
 
-interface URIOAsync<R> extends Async<Kind<URIO_, R>>, URIOMonadDefer<R> {
+interface URIOAsync<R> extends Async<Kind<URIO<?, ?>, R>>, URIOMonadDefer<R> {
 
   @SuppressWarnings("rawtypes")
   URIOAsync INSTANCE = new URIOAsync<>() {
   };
 
   @Override
-  default <A> URIO<R, A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<Kind<URIO_, R>, Unit>> consumer) {
+  default <A> URIO<R, A> asyncF(Function1<Consumer1<? super Try<? extends A>>, Kind<Kind<URIO<?, ?>, R>, Unit>> consumer) {
     return URIO.cancellable((env, cb) -> consumer.andThen(URIOOf::narrowK).apply(cb));
   }
 }
 
-interface URIOConcurrent<R> extends URIOAsync<R>, Concurrent<Kind<URIO_, R>> {
+interface URIOConcurrent<R> extends URIOAsync<R>, Concurrent<Kind<URIO<?, ?>, R>> {
 
   static <R> URIOConcurrent<R> instance(Executor executor) {
     return () -> executor;
@@ -211,20 +210,20 @@ static <R> URIOConcurrent<R> instance(Executor executor) {
   Executor executor();
 
   @Override
-  default <A, B> URIO<R, Either<Tuple2<A, Fiber<Kind<URIO_, R>, B>>, Tuple2<Fiber<Kind<URIO_, R>, A>, B>>> racePair(
-    Kind<Kind<URIO_, R>, ? extends A> fa, Kind<Kind<URIO_, R>, ? extends B> fb) {
+  default <A, B> URIO<R, Either<Tuple2<A, Fiber<Kind<URIO<?, ?>, R>, B>>, Tuple2<Fiber<Kind<URIO<?, ?>, R>, A>, B>>> racePair(
+    Kind<Kind<URIO<?, ?>, R>, ? extends A> fa, Kind<Kind<URIO<?, ?>, R>, ? extends B> fb) {
     return URIO.racePair(executor(), fa, fb);
   }
 
   @Override
-  default <A> URIO<R, Fiber<Kind<URIO_, R>, A>> fork(Kind<Kind<URIO_, R>, ? extends A> value) {
+  default <A> URIO<R, Fiber<Kind<URIO<?, ?>, R>, A>> fork(Kind<Kind<URIO<?, ?>, R>, ? extends A> value) {
     URIO<R, A> fix = value.fix(URIOOf::narrowK);
     return fix.fork();
   }
 
 }
 
-final class URIOConsole<R> implements Console<Kind<URIO_, R>> {
+final class URIOConsole<R> implements Console<Kind<URIO<?, ?>, R>> {
 
   @SuppressWarnings("rawtypes")
   static final URIOConsole INSTANCE = new URIOConsole();
@@ -242,7 +241,7 @@ public URIO<R, Unit> println(String text) {
   }
 }
 
-interface URIORuntime<R> extends Runtime<Kind<URIO_, R>> {
+interface URIORuntime<R> extends Runtime<Kind<URIO<?, ?>, R>> {
 
   static <R> URIORuntime<R> instance(R env) {
     return () -> env;
@@ -251,22 +250,22 @@ static <R> URIORuntime<R> instance(R env) {
   R env();
 
   @Override
-  default <T> T run(Kind<Kind<URIO_, R>, T> value) {
+  default <T> T run(Kind<Kind<URIO<?, ?>, R>, T> value) {
     return value.fix(toURIO()).safeRunSync(env()).getOrElseThrow();
   }
 
   @Override
-  default <T> Sequence<T> run(Sequence<Kind<Kind<URIO_, R>, T>> values) {
+  default <T> Sequence<T> run(Sequence<Kind<Kind<URIO<?, ?>, R>, T>> values) {
     return run(URIO.traverse(values.map(URIOOf::<R, T>narrowK)));
   }
 
   @Override
-  default <T> Future<T> parRun(Kind<Kind<URIO_, R>, T> value, Executor executor) {
+  default <T> Future<T> parRun(Kind<Kind<URIO<?, ?>, R>, T> value, Executor executor) {
     return value.fix(toURIO()).runAsync(env());
   }
 
   @Override
-  default <T> Future<Sequence<T>> parRun(Sequence<Kind<Kind<URIO_, R>, T>> values, Executor executor) {
+  default <T> Future<Sequence<T>> parRun(Sequence<Kind<Kind<URIO<?, ?>, R>, T>> values, Executor executor) {
     return parRun(URIO.traverse(values.map(URIOOf::<R, T>narrowK)), executor);
   }
 }
\ No newline at end of file
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/ValidationInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/ValidationInstances.java
index 04d9f5f17..ad62975d2 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/ValidationInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/ValidationInstances.java
@@ -13,7 +13,6 @@
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.type.Validation;
 import com.github.tonivade.purefun.type.ValidationOf;
-import com.github.tonivade.purefun.type.Validation_;
 import com.github.tonivade.purefun.typeclasses.Applicative;
 import com.github.tonivade.purefun.typeclasses.Bifunctor;
 import com.github.tonivade.purefun.typeclasses.Functor;
@@ -26,7 +25,7 @@
 @SuppressWarnings("unchecked")
 public interface ValidationInstances {
 
-  static <E, T> Eq<Kind<Kind<Validation_, E>, T>> eq(Eq<E> errorEq, Eq<T> validEq) {
+  static <E, T> Eq<Kind<Kind<Validation<?, ?>, E>, T>> eq(Eq<E> errorEq, Eq<T> validEq) {
     return (a, b) -> {
       if (a instanceof Validation.Invalid<E, T>(var invalidA) && b instanceof Validation.Invalid<E, T>(var invalidB)) {
         return errorEq.eqv(invalidA, invalidB);
@@ -38,59 +37,59 @@ static <E, T> Eq<Kind<Kind<Validation_, E>, T>> eq(Eq<E> errorEq, Eq<T> validEq)
     };
   }
 
-  static <E> Functor<Kind<Validation_, E>> functor() {
+  static <E> Functor<Kind<Validation<?, ?>, E>> functor() {
     return ValidationFunctor.INSTANCE;
   }
 
-  static Bifunctor<Validation_> bifunctor() {
+  static Bifunctor<Validation<?, ?>> bifunctor() {
     return ValidationBifunctor.INSTANCE;
   }
 
-  static <E> Applicative<Kind<Validation_, E>> applicative(Semigroup<E> semigroup) {
+  static <E> Applicative<Kind<Validation<?, ?>, E>> applicative(Semigroup<E> semigroup) {
     return ValidationApplicative.instance(semigroup);
   }
 
-  static <E> Selective<Kind<Validation_, E>> selective(Semigroup<E> semigroup) {
+  static <E> Selective<Kind<Validation<?, ?>, E>> selective(Semigroup<E> semigroup) {
     return ValidationSelective.instance(semigroup);
   }
 
-  static <E> Monad<Kind<Validation_, E>> monad() {
+  static <E> Monad<Kind<Validation<?, ?>, E>> monad() {
     return ValidationMonad.INSTANCE;
   }
 
-  static <E> MonadError<Kind<Validation_, E>, E> monadError() {
+  static <E> MonadError<Kind<Validation<?, ?>, E>, E> monadError() {
     return ValidationMonadError.INSTANCE;
   }
 
-  static MonadThrow<Kind<Validation_, Throwable>> monadThrow() {
+  static MonadThrow<Kind<Validation<?, ?>, Throwable>> monadThrow() {
     return ValidationMonadThrow.INSTANCE;
   }
 }
 
-interface ValidationFunctor<E> extends Functor<Kind<Validation_, E>> {
+interface ValidationFunctor<E> extends Functor<Kind<Validation<?, ?>, E>> {
 
   @SuppressWarnings("rawtypes")
   ValidationFunctor INSTANCE = new ValidationFunctor() {};
 
   @Override
-  default <T, R> Validation<E, R> map(Kind<Kind<Validation_, E>, ? extends T> value,
+  default <T, R> Validation<E, R> map(Kind<Kind<Validation<?, ?>, E>, ? extends T> value,
       Function1<? super T, ? extends R> map) {
     return ValidationOf.narrowK(value).map(map);
   }
 }
 
-interface ValidationBifunctor extends Bifunctor<Validation_> {
+interface ValidationBifunctor extends Bifunctor<Validation<?, ?>> {
 
   ValidationBifunctor INSTANCE = new ValidationBifunctor() {};
 
   @Override
-  default <A, B, C, D> Validation<C, D> bimap(Kind<Kind<Validation_, A>, ? extends B> value,
+  default <A, B, C, D> Validation<C, D> bimap(Kind<Kind<Validation<?, ?>, A>, ? extends B> value,
       Function1<? super A, ? extends C> leftMap, Function1<? super B, ? extends D> rightMap) {
     return ValidationOf.narrowK(value).bimap(leftMap, rightMap);
   }
 }
 
-interface ValidationPure<E> extends Applicative<Kind<Validation_, E>> {
+interface ValidationPure<E> extends Applicative<Kind<Validation<?, ?>, E>> {
 
   @Override
   default <T> Validation<E, T> pure(T value) {
@@ -98,7 +97,7 @@ default <T> Validation<E, T> pure(T value) {
   }
 }
 
-interface ValidationApplicative<E> extends ValidationPure<E>, Applicative<Kind<Validation_, E>> {
+interface ValidationApplicative<E> extends ValidationPure<E>, Applicative<Kind<Validation<?, ?>, E>> {
 
   static <E> ValidationApplicative<E> instance(Semigroup<E> semigroup) {
     return () -> semigroup;
@@ -107,8 +106,8 @@ static <E> ValidationApplicative<E> instance(Semigroup<E> semigroup) {
   Semigroup<E> semigroup();
 
   @Override
-  default <T, R> Validation<E, R> ap(Kind<Kind<Validation_, E>, ? extends T> value,
-                                     Kind<Kind<Validation_, E>, ? extends Function1<? super T, ? extends R>> apply) {
+  default <T, R> Validation<E, R> ap(Kind<Kind<Validation<?, ?>, E>, ? extends T> value,
+                                     Kind<Kind<Validation<?, ?>, E>, ? extends Function1<? super T, ? extends R>> apply) {
     Validation<E, T> validation = value.fix(ValidationOf::narrowK);
     Validation<E, Function1<? super T, ? extends R>> validationF = apply.fix(ValidationOf::narrowK);
 
@@ -124,37 +123,37 @@ default <T, R> Validation<E, R> ap(Kind<Kind<Validation_, E>, ? extends T> value
   }
 }
 
-interface ValidationSelective<E> extends ValidationApplicative<E>, Selective<Kind<Validation_, E>> {
+interface ValidationSelective<E> extends ValidationApplicative<E>, Selective<Kind<Validation<?, ?>, E>> {
 
   static <E> ValidationSelective<E> instance(Semigroup<E> semigroup) {
     return () -> semigroup;
   }
 
   @Override
-  default <A, B> Validation<E, B> select(Kind<Kind<Validation_, E>, Either<A, B>> value,
-                                         Kind<Kind<Validation_, E>, Function1<? super A, ? extends B>> apply) {
+  default <A, B> Validation<E, B> select(Kind<Kind<Validation<?, ?>, E>, Either<A, B>> value,
+                                         Kind<Kind<Validation<?, ?>, E>, Function1<? super A, ? extends B>> apply) {
     return Validation.select(value.fix(toValidation()), apply.fix(toValidation()));
   }
 }
 
-interface ValidationMonad<E> extends ValidationPure<E>, Monad<Kind<Validation_, E>> {
+interface ValidationMonad<E> extends ValidationPure<E>, Monad<Kind<Validation<?, ?>, E>> {
 
   @SuppressWarnings("rawtypes")
   ValidationMonad INSTANCE = new ValidationMonad() {};
 
   @Override
-  default <T, R> Validation<E, R> flatMap(Kind<Kind<Validation_, E>, ? extends T> value,
-      Function1<? super T, ? extends Kind<Kind<Validation_, E>, ? extends R>> map) {
+  default <T, R> Validation<E, R> flatMap(Kind<Kind<Validation<?, ?>, E>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Kind<Validation<?, ?>, E>, ? extends R>> map) {
     return ValidationOf.narrowK(value).flatMap(map.andThen(ValidationOf::narrowK));
   }
 
   @Override
-  default <T, R> Kind<Kind<Validation_, E>, R> tailRecM(T value,
-      Function1<T, ? extends Kind<Kind<Validation_, E>, Either<T, R>>> map) {
+  default <T, R> Kind<Kind<Validation<?, ?>, E>, R> tailRecM(T value,
+      Function1<T, ? extends Kind<Kind<Validation<?, ?>, E>, Either<T, R>>> map) {
     return loop(value, map).run();
   }
 
-  private <T, R> Trampoline<Kind<Kind<Validation_, E>, R>> loop(T value, Function1<T, ? extends Kind<Kind<Validation_, E>, Either<T, R>>> map) {
+  private <T, R> Trampoline<Kind<Kind<Validation<?, ?>, E>, R>> loop(T value, Function1<T, ? extends Kind<Kind<Validation<?, ?>, E>, Either<T, R>>> map) {
     return switch (map.andThen(ValidationOf::narrowK).apply(value)) {
       case Validation.Invalid<E, Either<T, R>>(var error) -> Trampoline.done(Validation.invalid(error));
       case Validation.Valid<E, Either<T, R>>(Either.Right<T, R>(var right)) -> Trampoline.done(Validation.valid(right));
@@ -163,7 +162,7 @@ private <T, R> Trampoline<Kind<Kind<Validation_, E>, R>> loop(T value, Function1
   }
 }
 
-interface ValidationMonadError<E> extends ValidationMonad<E>, MonadError<Kind<Validation_, E>, E> {
+interface ValidationMonadError<E> extends ValidationMonad<E>, MonadError<Kind<Validation<?, ?>, E>, E> {
 
   @SuppressWarnings("rawtypes")
   ValidationMonadError INSTANCE = new ValidationMonadError() {};
@@ -174,15 +173,15 @@ default <A> Validation<E, A> raiseError(E error) {
   }
 
   @Override
-  default <A> Validation<E, A> handleErrorWith(Kind<Kind<Validation_, E>, A> value,
-      Function1<? super E, ? extends Kind<Kind<Validation_, E>, ? extends A>> handler) {
+  default <A> Validation<E, A> handleErrorWith(Kind<Kind<Validation<?, ?>, E>, A> value,
+      Function1<? super E, ? extends Kind<Kind<Validation<?, ?>, E>, ? extends A>> handler) {
     return ValidationOf.narrowK(value).fold(handler.andThen(ValidationOf::narrowK), Validation::valid);
   }
 }
 
 interface ValidationMonadThrow
     extends ValidationMonadError<Throwable>,
-            MonadThrow<Kind<Validation_, Throwable>> {
+            MonadThrow<Kind<Validation<?, ?>, Throwable>> {
 
   ValidationMonadThrow INSTANCE = new ValidationMonadThrow() {};
 }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/WriterInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/WriterInstances.java
index 29abe5e35..364d34fc0 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/WriterInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/WriterInstances.java
@@ -10,18 +10,17 @@
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.monad.Writer;
 import com.github.tonivade.purefun.monad.WriterOf;
-import com.github.tonivade.purefun.monad.Writer_;
 import com.github.tonivade.purefun.typeclasses.Monad;
 import com.github.tonivade.purefun.typeclasses.Monoid;
 
 public interface WriterInstances {
 
-  static <L> Monad<Kind<Writer_, L>> monad(Monoid<L> monoid) {
+  static <L> Monad<Kind<Writer<?, ?>, L>> monad(Monoid<L> monoid) {
     return WriterMonad.instance(checkNonNull(monoid));
   }
 }
 
-interface WriterMonad<L> extends Monad<Kind<Writer_, L>> {
+interface WriterMonad<L> extends Monad<Kind<Writer<?, ?>, L>> {
 
   static <L> WriterMonad<L> instance(Monoid<L> monoid) {
     return () -> monoid;
@@ -35,8 +34,8 @@ default <T> Writer<L, T> pure(T value) {
   }
 
   @Override
-  default <T, R> Writer<L, R> flatMap(Kind<Kind<Writer_, L>, ? extends T> value,
-      Function1<? super T, ? extends Kind<Kind<Writer_, L>, ? extends R>> map) {
+  default <T, R> Writer<L, R> flatMap(Kind<Kind<Writer<?, ?>, L>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Kind<Writer<?, ?>, L>, ? extends R>> map) {
     return WriterOf.narrowK(value).flatMap(map.andThen(WriterOf::narrowK));
   }
 }
diff --git a/instances/src/main/java/com/github/tonivade/purefun/instances/WriterTInstances.java b/instances/src/main/java/com/github/tonivade/purefun/instances/WriterTInstances.java
index 87db7dc63..fb56f2f6d 100644
--- a/instances/src/main/java/com/github/tonivade/purefun/instances/WriterTInstances.java
+++ b/instances/src/main/java/com/github/tonivade/purefun/instances/WriterTInstances.java
@@ -15,7 +15,6 @@
 import com.github.tonivade.purefun.core.Tuple2;
 import com.github.tonivade.purefun.transformer.WriterT;
 import com.github.tonivade.purefun.transformer.WriterTOf;
-import com.github.tonivade.purefun.transformer.WriterT_;
 import com.github.tonivade.purefun.typeclasses.Monad;
 import com.github.tonivade.purefun.typeclasses.MonadError;
 import com.github.tonivade.purefun.typeclasses.MonadWriter;
@@ -23,23 +22,23 @@
 
 public interface WriterTInstances {
 
-  static <F, L> Monad<Kind<Kind<WriterT_, F>, L>> monad(Monoid<L> monoid, Monad<F> monadF) {
+  static <F, L> Monad<Kind<Kind<WriterT<?, ?, ?>, F>, L>> monad(Monoid<L> monoid, Monad<F> monadF) {
     return WriterTMonad.instance(checkNonNull(monoid), checkNonNull(monadF));
   }
 
-  static <F, L> MonadWriter<Kind<Kind<WriterT_, F>, L>, L> monadWriter(Monoid<L> monoid, Monad<F> monadF) {
+  static <F, L> MonadWriter<Kind<Kind<WriterT<?, ?, ?>, F>, L>, L> monadWriter(Monoid<L> monoid, Monad<F> monadF) {
     return WriterTMonadWriter.instance(checkNonNull(monoid), checkNonNull(monadF));
   }
 
-  static <F, L, E> MonadError<Kind<Kind<WriterT_, F>, L>, E> monadError(
+  static <F, L, E> MonadError<Kind<Kind<WriterT<?, ?, ?>, F>, L>, E> monadError(
       Monoid<L> monoid, MonadError<F, E> monadErrorF) {
     return WriterTMonadError.instance(checkNonNull(monoid), checkNonNull(monadErrorF));
   }
 }
 
-interface WriterTMonad<F, L> extends Monad<Kind<Kind<WriterT_, F>, L>> {
+interface WriterTMonad<F, L> extends Monad<Kind<Kind<WriterT<?, ?, ?>, F>, L>> {
 
-  static <F, L> Monad<Kind<Kind<WriterT_, F>, L>> instance(Monoid<L> monoid, Monad<F> monadF) {
+  static <F, L> Monad<Kind<Kind<WriterT<?, ?, ?>, F>, L>> instance(Monoid<L> monoid, Monad<F> monadF) {
     return new WriterTMonad<>() {
 
       @Override
@@ -63,16 +62,16 @@ default <T> WriterT<F, L, T> pure(T value) {
   }
 
   @Override
-  default <T, R> WriterT<F, L, R> flatMap(Kind<Kind<Kind<WriterT_, F>, L>, ? extends T> value,
-      Function1<? super T, ? extends Kind<Kind<Kind<WriterT_, F>, L>, ? extends R>> map) {
+  default <T, R> WriterT<F, L, R> flatMap(Kind<Kind<Kind<WriterT<?, ?, ?>, F>, L>, ? extends T> value,
+      Function1<? super T, ? extends Kind<Kind<Kind<WriterT<?, ?, ?>, F>, L>, ? extends R>> map) {
     return WriterTOf.narrowK(value).flatMap(map.andThen(WriterTOf::narrowK));
   }
 }
 
 interface WriterTMonadWriter<F, L>
-    extends MonadWriter<Kind<Kind<WriterT_, F>, L>, L>, WriterTMonad<F, L> {
+    extends MonadWriter<Kind<Kind<WriterT<?, ?, ?>, F>, L>, L>, WriterTMonad<F, L> {
 
-  static <F, L> MonadWriter<Kind<Kind<WriterT_, F>, L>, L> instance(Monoid<L> monoid, Monad<F> monadF) {
+  static <F, L> MonadWriter<Kind<Kind<WriterT<?, ?, ?>, F>, L>, L> instance(Monoid<L> monoid, Monad<F> monadF) {
     return new WriterTMonadWriter<>() {
 
       @Override
@@ -93,13 +92,13 @@ default <A> WriterT<F, L, A> writer(Tuple2<L, A> value) {
   }
 
   @Override
-  default <A> WriterT<F, L, Tuple2<L, A>> listen(Kind<Kind<Kind<WriterT_, F>, L>, ? extends A> value) {
+  default <A> WriterT<F, L, Tuple2<L, A>> listen(Kind<Kind<Kind<WriterT<?, ?, ?>, F>, L>, ? extends A> value) {
     return value.fix(WriterTOf::<F, L, A>narrowK).listen();
   }
 
   @Override
   default <A> WriterT<F, L, A> pass(
-      Kind<Kind<Kind<WriterT_, F>, L>, Tuple2<Operator1<L>, A>> value) {
+      Kind<Kind<Kind<WriterT<?, ?, ?>, F>, L>, Tuple2<Operator1<L>, A>> value) {
     WriterT<F, L, Tuple2<Operator1<L>, A>> writerT = value.fix(WriterTOf::narrowK);
     return writerT.listen().flatMap((Tuple2<L, Tuple2<Operator1<L>, A>> tuple) -> {
         Operator1<L> operator = tuple.get2().get1();
@@ -110,9 +109,9 @@ default <A> WriterT<F, L, A> pass(
 }
 
 interface WriterTMonadError<F, L, E>
-    extends MonadError<Kind<Kind<WriterT_, F>, L>, E>, WriterTMonad<F, L> {
+    extends MonadError<Kind<Kind<WriterT<?, ?, ?>, F>, L>, E>, WriterTMonad<F, L> {
 
-  static <F, L, E> MonadError<Kind<Kind<WriterT_, F>, L>, E> instance(
+  static <F, L, E> MonadError<Kind<Kind<WriterT<?, ?, ?>, F>, L>, E> instance(
       Monoid<L> monoid, MonadError<F, E> monadErrorF) {
     return new WriterTMonadError<>() {
 
@@ -139,8 +138,8 @@ default <A> WriterT<F, L, A> raiseError(E error) {
 
   @Override
   default <A> WriterT<F, L, A> handleErrorWith(
-      Kind<Kind<Kind<WriterT_, F>, L>, A> value,
-      Function1<? super E, ? extends Kind<Kind<Kind<WriterT_, F>, L>, ? extends A>> handler) {
+      Kind<Kind<Kind<WriterT<?, ?, ?>, F>, L>, A> value,
+      Function1<? super E, ? extends Kind<Kind<Kind<WriterT<?, ?, ?>, F>, L>, ? extends A>> handler) {
     return WriterT.writer(monoid(), monadF(),
         monadF().handleErrorWith(value.fix(toWriterT()).value(),
             error -> handler.apply(error).fix(WriterTOf::<F, L, A>narrowK).value()));
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/AlternativeTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/AlternativeTest.java
index 3b3387672..a444e6de4 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/AlternativeTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/AlternativeTest.java
@@ -8,27 +8,28 @@
 import static com.github.tonivade.purefun.laws.AlternativeLaws.verifyLaws;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import org.junit.jupiter.api.Test;
 
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.core.Function1;
-import com.github.tonivade.purefun.data.Sequence_;
+import com.github.tonivade.purefun.data.Sequence;
 import com.github.tonivade.purefun.instances.OptionInstances;
 import com.github.tonivade.purefun.instances.SequenceInstances;
 
 public class AlternativeTest {
 
-  private final Alternative<Sequence_> instance = SequenceInstances.alternative();
+  private final Alternative<Sequence<?>> instance = SequenceInstances.alternative();
 
   private final Function1<Integer, Integer> twoTimes = a -> a * 2;
   private final Function1<Integer, Integer> plusFive = a -> a + 5;
 
   @Test
   public void combineAndAp() {
-    Kind<Sequence_, Integer> seven = instance.pure(7);
-    Kind<Sequence_, Integer> eight = instance.pure(8);
+    Kind<Sequence<?>, Integer> seven = instance.pure(7);
+    Kind<Sequence<?>, Integer> eight = instance.pure(8);
 
-    Kind<Sequence_, Integer> result =
+    Kind<Sequence<?>, Integer> result =
         instance.ap(instance.combineK(seven, eight),
                     instance.combineK(instance.pure(twoTimes), instance.pure(plusFive)));
 
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ApplicativeTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ApplicativeTest.java
index 31c8bd381..83c856f9f 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ApplicativeTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ApplicativeTest.java
@@ -18,7 +18,6 @@
 import com.github.tonivade.purefun.instances.TryInstances;
 import com.github.tonivade.purefun.instances.ValidationInstances;
 import com.github.tonivade.purefun.type.Option;
-import com.github.tonivade.purefun.type.Option_;
 
 public class ApplicativeTest {
 
@@ -39,7 +38,7 @@ public void laws() {
 
   @Test
   public void map5Some() {
-    Kind<Option_, Integer> map5 =
+    Kind<Option<?>, Integer> map5 =
         OptionInstances.applicative().mapN(
             Option.some(1),
             Option.some(2),
@@ -52,7 +51,7 @@ public void map5Some() {
 
   @Test
   public void map5None() {
-    Kind<Option_, Integer> map5 =
+    Kind<Option<?>, Integer> map5 =
         OptionInstances.applicative().mapN(
             Option.some(1),
             Option.some(2),
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ContravariantTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ContravariantTest.java
index c09d42633..efbce721f 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ContravariantTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ContravariantTest.java
@@ -12,35 +12,32 @@
 import org.junit.jupiter.api.Test;
 
 import com.github.tonivade.purefun.core.Function1Of;
-import com.github.tonivade.purefun.core.Function1_;
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.instances.ConstInstances;
 import com.github.tonivade.purefun.instances.Function1Instances;
 import com.github.tonivade.purefun.instances.IdInstances;
 import com.github.tonivade.purefun.type.Const;
-import com.github.tonivade.purefun.type.Const_;
 import com.github.tonivade.purefun.type.Id;
-import com.github.tonivade.purefun.type.Id_;
 
 public class ContravariantTest {
 
   @Test
   public void constInstance() {
-    Contravariant<Kind<Const_, String>> instance = ConstInstances.contravariant();
+    Contravariant<Kind<Const<?, ?>, String>> instance = ConstInstances.contravariant();
 
     verifyLaws(instance, Const.<String, String>of("string"));
   }
 
   @Test
   public void function1Instance() {
-    Contravariant<Conested<Function1_, Double>> instance = Function1Instances.<Double>contravariant();
+    Contravariant<Conested<Function1<?, ?>, Double>> instance = Function1Instances.<Double>contravariant();
 
     Function1<Integer, Double> int2double = Integer::doubleValue;
     Function1<String, Integer> string2Int = String::length;
 
-    Kind<Conested<Function1_, Double>, Integer> conest = conest(int2double);
-    Kind<Conested<Function1_, Double>, String> contramap = instance.contramap(conest, string2Int);
+    Kind<Conested<Function1<?, ?>, Double>, Integer> conest = conest(int2double);
+    Kind<Conested<Function1<?, ?>, Double>, String> contramap = instance.contramap(conest, string2Int);
     Function1<String, Double> result = counnest(contramap).fix(Function1Of::<String, Double>narrowK);
 
     assertEquals(4.0, result.apply("hola"));
@@ -48,9 +45,9 @@ public void function1Instance() {
 
   @Test
   public void composedCovariantContravariant() {
-    Functor<Id_> functor = IdInstances.functor();
-    Contravariant<Kind<Const_, String>> contravariant = ConstInstances.contravariant();
-    Contravariant<Nested<Id_, Kind<Const_, String>>> instance = Contravariant.compose(functor, contravariant);
+    Functor<Id<?>> functor = IdInstances.functor();
+    Contravariant<Kind<Const<?, ?>, String>> contravariant = ConstInstances.contravariant();
+    Contravariant<Nested<Id<?>, Kind<Const<?, ?>, String>>> instance = Contravariant.compose(functor, contravariant);
 
     verifyLaws(instance, nest(Id.of(Const.<String, String>of("string"))));
   }
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/FoldableTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/FoldableTest.java
index 15e5a5aa5..be95e1e30 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/FoldableTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/FoldableTest.java
@@ -12,11 +12,12 @@
 import static com.github.tonivade.purefun.typeclasses.Nested.nest;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import org.junit.jupiter.api.Test;
+
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.data.ImmutableList;
 import com.github.tonivade.purefun.data.Sequence;
-import com.github.tonivade.purefun.data.Sequence_;
 import com.github.tonivade.purefun.instances.ConstInstances;
 import com.github.tonivade.purefun.instances.EitherInstances;
 import com.github.tonivade.purefun.instances.IdInstances;
@@ -25,12 +26,9 @@
 import com.github.tonivade.purefun.instances.TryInstances;
 import com.github.tonivade.purefun.type.Const;
 import com.github.tonivade.purefun.type.Either;
-import com.github.tonivade.purefun.type.Either_;
 import com.github.tonivade.purefun.type.Id;
 import com.github.tonivade.purefun.type.Option;
-import com.github.tonivade.purefun.type.Option_;
 import com.github.tonivade.purefun.type.Try;
-import com.github.tonivade.purefun.type.Try_;
 
 public class FoldableTest {
 
@@ -52,7 +50,7 @@ public void laws() {
 
   @Test
   public void composed() {
-    Foldable<Nested<Sequence_, Option_>> instance = compose(SequenceInstances.foldable(), OptionInstances.foldable());
+    Foldable<Nested<Sequence<?>, Option<?>>> instance = compose(SequenceInstances.foldable(), OptionInstances.foldable());
 
     assertEquals(Integer.valueOf(3), instance.fold(Monoid.integer(),
       nest(listOf(Option.some(1), Option.<Integer>none(), Option.some(2)))));
@@ -60,7 +58,7 @@ public void composed() {
 
   @Test
   public void sequence() {
-    Foldable<Sequence_> instance = SequenceInstances.foldable();
+    Foldable<Sequence<?>> instance = SequenceInstances.foldable();
 
     assertAll(
         () -> assertEquals("abc", instance.foldLeft(listOf("a", "b", "c"), "", String::concat)),
@@ -73,7 +71,7 @@ public void sequence() {
 
   @Test
   public void either() {
-    Foldable<Kind<Either_, Throwable>> instance = EitherInstances.foldable();
+    Foldable<Kind<Either<?, ?>, Throwable>> instance = EitherInstances.foldable();
 
     assertAll(
         () -> assertEquals(empty(), instance.foldLeft(Either.<Throwable, String>left(new Error()), empty(), ImmutableList::append)),
@@ -92,7 +90,7 @@ public void either() {
 
   @Test
   public void option() {
-    Foldable<Option_> instance = OptionInstances.foldable();
+    Foldable<Option<?>> instance = OptionInstances.foldable();
 
     assertAll(
         () -> assertEquals(empty(), instance.foldLeft(Option.<String>none(), empty(), ImmutableList::append)),
@@ -111,7 +109,7 @@ public void option() {
 
   @Test
   public void try_() {
-    Foldable<Try_> instance = TryInstances.foldable();
+    Foldable<Try<?>> instance = TryInstances.foldable();
 
     assertAll(
         () -> assertEquals(empty(), instance.foldLeft(Try.<String>failure(), empty(), ImmutableList::append)),
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/FunctionKTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/FunctionKTest.java
index cc7ab4bc2..aea790042 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/FunctionKTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/FunctionKTest.java
@@ -9,45 +9,43 @@
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.type.Option;
 import com.github.tonivade.purefun.type.OptionOf;
-import com.github.tonivade.purefun.type.Option_;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.type.TryOf;
-import com.github.tonivade.purefun.type.Try_;
 
 public class FunctionKTest {
 
   @Test
   public void apply() {
-    Kind<Try_, String> success = new OptionToTry().apply(Option.some("hello world!"));
+    Kind<Try<?>, String> success = new OptionToTry().apply(Option.some("hello world!"));
 
     assertEquals(Try.success("hello world!"), success);
   }
 
   @Test
   public void andThen() {
-    Kind<Option_, String> some = new OptionToTry().andThen(new TryToOption()).apply(Option.some("hello world!"));
+    Kind<Option<?>, String> some = new OptionToTry().andThen(new TryToOption()).apply(Option.some("hello world!"));
 
     assertEquals(Option.some("hello world!"), some);
   }
 
   @Test
   public void compose() {
-    Kind<Try_, String> some = new OptionToTry().compose(new TryToOption()).apply(Try.success("hello world!"));
+    Kind<Try<?>, String> some = new OptionToTry().compose(new TryToOption()).apply(Try.success("hello world!"));
 
     assertEquals(Try.success("hello world!"), some);
   }
 }
 
-class OptionToTry implements FunctionK<Option_, Try_> {
+class OptionToTry implements FunctionK<Option<?>, Try<?>> {
   @Override
-  public <X> Kind<Try_, X> apply(Kind<Option_, ? extends X> from) {
+  public <X> Kind<Try<?>, X> apply(Kind<Option<?>, ? extends X> from) {
     return OptionOf.<X>narrowK(from).map(Try::success).getOrElse(Try::failure);
   }
 }
 
-class TryToOption implements FunctionK<Try_, Option_> {
+class TryToOption implements FunctionK<Try<?>, Option<?>> {
   @Override
-  public <X> Kind<Option_, X> apply(Kind<Try_, ? extends X> from) {
+  public <X> Kind<Option<?>, X> apply(Kind<Try<?>, ? extends X> from) {
     return TryOf.<X>narrowK(from).toOption();
   }
 }
\ No newline at end of file
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadDeferTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadDeferTest.java
index 289b66217..e94f033c8 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadDeferTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadDeferTest.java
@@ -26,27 +26,23 @@
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.core.Producer;
 import com.github.tonivade.purefun.effect.PureIO;
-import com.github.tonivade.purefun.effect.PureIO_;
 import com.github.tonivade.purefun.monad.IO;
-import com.github.tonivade.purefun.monad.IO_;
 import com.github.tonivade.purefun.transformer.EitherT;
 import com.github.tonivade.purefun.transformer.EitherTOf;
-import com.github.tonivade.purefun.transformer.EitherT_;
 import com.github.tonivade.purefun.transformer.OptionT;
 import com.github.tonivade.purefun.transformer.OptionTOf;
-import com.github.tonivade.purefun.transformer.OptionT_;
 import com.github.tonivade.purefun.type.Either;
 
 @ExtendWith(MockitoExtension.class)
 public class MonadDeferTest {
 
-  private MonadDefer<IO_> ioMonadDefer = Instances.<IO_>monadDefer();
-  private MonadDefer<Kind<Kind<PureIO_, Void>, Throwable>> PureIOMonadDefer =
-      new Instance<Kind<Kind<PureIO_, Void>, Throwable>>(){}.monadDefer();
-  private MonadDefer<Kind<Kind<EitherT_, IO_>, Throwable>> eitherTMonadDefer =
-      new Instance<Kind<Kind<EitherT_, IO_>, Throwable>>(){}.monadDefer(ioMonadDefer);
-  private MonadDefer<Kind<OptionT_, IO_>> optionTMonadDefer =
-      new Instance<Kind<OptionT_, IO_>>(){}.monadDefer(ioMonadDefer);
+  private MonadDefer<IO<?>> ioMonadDefer = Instances.<IO<?>>monadDefer();
+  private MonadDefer<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>> PureIOMonadDefer =
+      new Instance<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>>(){}.monadDefer();
+  private MonadDefer<Kind<Kind<EitherT<?, ?, ?>, IO<?>>, Throwable>> eitherTMonadDefer =
+      new Instance<Kind<Kind<EitherT<?, ?, ?>, IO<?>>, Throwable>>(){}.monadDefer(ioMonadDefer);
+  private MonadDefer<Kind<OptionT<?, ?>, IO<?>>> optionTMonadDefer =
+      new Instance<Kind<OptionT<?, ?>, IO<?>>>(){}.monadDefer(ioMonadDefer);
 
   private AutoCloseable resource = Mockito.mock(AutoCloseable.class);
 
@@ -54,7 +50,7 @@ public class MonadDeferTest {
   public void ioLater(@Mock Producer<String> task) throws Exception {
     when(task.get()).thenReturn("hola toni");
 
-    Kind<IO_, String> later = ioMonadDefer.later(task);
+    Kind<IO<?>, String> later = ioMonadDefer.later(task);
 
     String result = later.fix(toIO()).unsafeRunSync();
 
@@ -64,7 +60,7 @@ public void ioLater(@Mock Producer<String> task) throws Exception {
 
   @Test
   public void ioBracket() throws Exception {
-    Kind<IO_, String> bracket =
+    Kind<IO<?>, String> bracket =
         ioMonadDefer.bracket(IO.pure(resource), r -> IO.pure("done"));
 
     String result = bracket.fix(toIO()).unsafeRunSync();
@@ -75,7 +71,7 @@ public void ioBracket() throws Exception {
 
   @Test
   public void ioBracketAcquireError() throws Exception {
-    Kind<IO_, String> bracket =
+    Kind<IO<?>, String> bracket =
         ioMonadDefer.bracket(IO.<AutoCloseable>raiseError(new IllegalStateException()), r -> IO.pure("done"));
 
     assertThrows(IllegalStateException.class, () -> bracket.fix(toIO()).unsafeRunSync());
@@ -85,7 +81,7 @@ public void ioBracketAcquireError() throws Exception {
 
   @Test
   public void ioBracketUseError() throws Exception {
-    Kind<IO_, String> bracket =
+    Kind<IO<?>, String> bracket =
         ioMonadDefer.bracket(IO.pure(resource), r -> IO.<String>raiseError(new UnsupportedOperationException()));
 
     assertThrows(UnsupportedOperationException.class, () -> bracket.fix(toIO()).unsafeRunSync());
@@ -95,9 +91,9 @@ public void ioBracketUseError() throws Exception {
 
   @Test
   public void eitherTBracket() throws Exception {
-    Kind<Kind<Kind<EitherT_, IO_>, Throwable>, String> bracket =
-        eitherTMonadDefer.bracket(EitherT.<IO_, Throwable, AutoCloseable>right(Instances.<IO_>monad(), resource),
-                                                r -> EitherT.<IO_, Throwable, String>right(Instances.<IO_>monad(), "done"));
+    Kind<Kind<Kind<EitherT<?, ?, ?>, IO<?>>, Throwable>, String> bracket =
+        eitherTMonadDefer.bracket(EitherT.<IO<?>, Throwable, AutoCloseable>right(Instances.<IO<?>>monad(), resource),
+                                                r -> EitherT.<IO<?>, Throwable, String>right(Instances.<IO<?>>monad(), "done"));
 
     String result = bracket.fix(EitherTOf::narrowK).get().fix(toIO()).unsafeRunSync();
 
@@ -107,9 +103,9 @@ public void eitherTBracket() throws Exception {
 
   @Test
   public void eitherTBracketAcquireError() throws Exception {
-    Kind<Kind<Kind<EitherT_, IO_>, Throwable>, String> bracket =
-        eitherTMonadDefer.bracket(EitherT.<IO_, Throwable, AutoCloseable>left(Instances.<IO_>monad(), new IllegalStateException()),
-                                                r -> EitherT.<IO_, Throwable, String>right(Instances.<IO_>monad(), "done"));
+    Kind<Kind<Kind<EitherT<?, ?, ?>, IO<?>>, Throwable>, String> bracket =
+        eitherTMonadDefer.bracket(EitherT.<IO<?>, Throwable, AutoCloseable>left(Instances.<IO<?>>monad(), new IllegalStateException()),
+                                                r -> EitherT.<IO<?>, Throwable, String>right(Instances.<IO<?>>monad(), "done"));
 
     assertThrows(IllegalStateException.class,
                  () -> bracket.fix(EitherTOf::narrowK).value().fix(toIO()).unsafeRunSync());
@@ -119,9 +115,9 @@ public void eitherTBracketAcquireError() throws Exception {
 
   @Test
   public void eitherTBracketUseError() throws Exception {
-    Kind<Kind<Kind<EitherT_, IO_>, Throwable>, String> bracket =
-        eitherTMonadDefer.bracket(EitherT.<IO_, Throwable, AutoCloseable>right(Instances.<IO_>monad(), resource),
-                                                r -> EitherT.<IO_, Throwable, String>left(Instances.<IO_>monad(), new UnsupportedOperationException()));
+    Kind<Kind<Kind<EitherT<?, ?, ?>, IO<?>>, Throwable>, String> bracket =
+        eitherTMonadDefer.bracket(EitherT.<IO<?>, Throwable, AutoCloseable>right(Instances.<IO<?>>monad(), resource),
+                                                r -> EitherT.<IO<?>, Throwable, String>left(Instances.<IO<?>>monad(), new UnsupportedOperationException()));
 
     Either<Throwable, String> unsafeRunSync = bracket.fix(toEitherT()).value().fix(toIO()).unsafeRunSync();
 
@@ -131,9 +127,9 @@ public void eitherTBracketUseError() throws Exception {
 
   @Test
   public void optionTBracket() throws Exception {
-    Kind<Kind<OptionT_, IO_>, String> bracket =
-        optionTMonadDefer.bracket(OptionT.some(Instances.<IO_>monad(), resource),
-                                  r -> OptionT.some(Instances.<IO_>monad(), "done"));
+    Kind<Kind<OptionT<?, ?>, IO<?>>, String> bracket =
+        optionTMonadDefer.bracket(OptionT.some(Instances.<IO<?>>monad(), resource),
+                                  r -> OptionT.some(Instances.<IO<?>>monad(), "done"));
 
     String result = bracket.fix(OptionTOf::narrowK).getOrElseThrow().fix(toIO()).unsafeRunSync();
 
@@ -144,9 +140,9 @@ public void optionTBracket() throws Exception {
   @Test
   @Disabled
   public void optionTBracketAcquireError() throws Exception {
-    Kind<Kind<OptionT_, IO_>, String> bracket =
-        optionTMonadDefer.bracket(OptionT.<IO_, AutoCloseable>none(Instances.<IO_>monad()),
-                                  r -> OptionT.some(Instances.<IO_>monad(), "done"));
+    Kind<Kind<OptionT<?, ?>, IO<?>>, String> bracket =
+        optionTMonadDefer.bracket(OptionT.<IO<?>, AutoCloseable>none(Instances.<IO<?>>monad()),
+                                  r -> OptionT.some(Instances.<IO<?>>monad(), "done"));
 
     NoSuchElementException error = assertThrows(NoSuchElementException.class,
                  () -> bracket.fix(OptionTOf::narrowK).getOrElseThrow().fix(toIO()).unsafeRunSync());
@@ -158,9 +154,9 @@ public void optionTBracketAcquireError() throws Exception {
   @Test
   @Disabled
   public void optionTBracketUseError() throws Exception {
-    Kind<Kind<OptionT_, IO_>, String> bracket =
-        optionTMonadDefer.bracket(OptionT.some(Instances.<IO_>monad(), resource),
-                                  r -> OptionT.<IO_, String>none(Instances.<IO_>monad()));
+    Kind<Kind<OptionT<?, ?>, IO<?>>, String> bracket =
+        optionTMonadDefer.bracket(OptionT.some(Instances.<IO<?>>monad(), resource),
+                                  r -> OptionT.<IO<?>, String>none(Instances.<IO<?>>monad()));
 
     NoSuchElementException error = assertThrows(NoSuchElementException.class,
                  () -> bracket.fix(OptionTOf::narrowK).getOrElseThrow().fix(toIO()).unsafeRunSync());
@@ -171,7 +167,7 @@ public void optionTBracketUseError() throws Exception {
 
   @Test
   public void pureIOBracket() throws Exception {
-    Kind<Kind<Kind<PureIO_, Void>, Throwable>, String> bracket =
+    Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, String> bracket =
         PureIOMonadDefer.bracket(PureIO.<Void, Throwable, AutoCloseable>pure(resource),
                               r -> PureIO.<Void, Throwable, String>pure("done"));
 
@@ -183,7 +179,7 @@ public void pureIOBracket() throws Exception {
 
   @Test
   public void pureIOBracketAcquireError() throws Exception {
-    Kind<Kind<Kind<PureIO_, Void>, Throwable>, String> bracket =
+    Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, String> bracket =
         PureIOMonadDefer.bracket(PureIO.<Void, Throwable, AutoCloseable>raiseError(new IllegalStateException()),
                               r -> PureIO.<Void, Throwable, String>pure("done"));
 
@@ -195,7 +191,7 @@ public void pureIOBracketAcquireError() throws Exception {
 
   @Test
   public void pureIOBracketUseError() throws Exception {
-    Kind<Kind<Kind<PureIO_, Void>, Throwable>, String> bracket =
+    Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, String> bracket =
         PureIOMonadDefer.bracket(PureIO.<Void, Throwable, AutoCloseable>pure(resource),
                               r -> PureIO.<Void, Throwable, String>raiseError(new UnsupportedOperationException()));
 
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadErrorTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadErrorTest.java
index 0f9e9c896..120b1de54 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadErrorTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadErrorTest.java
@@ -4,56 +4,54 @@
  */
 package com.github.tonivade.purefun.typeclasses;
 
+import static com.github.tonivade.purefun.core.Matcher1.always;
+import static com.github.tonivade.purefun.core.Matcher1.is;
+import static com.github.tonivade.purefun.core.Producer.cons;
+import static com.github.tonivade.purefun.core.Unit.unit;
+import static com.github.tonivade.purefun.monad.IOOf.toIO;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+
 import org.junit.jupiter.api.Test;
+
 import com.github.tonivade.purefun.Kind;
+import com.github.tonivade.purefun.concurrent.Future;
 import com.github.tonivade.purefun.concurrent.FutureOf;
-import com.github.tonivade.purefun.concurrent.Future_;
 import com.github.tonivade.purefun.core.PartialFunction1;
 import com.github.tonivade.purefun.core.Unit;
+import com.github.tonivade.purefun.effect.EIO;
 import com.github.tonivade.purefun.effect.EIOOf;
-import com.github.tonivade.purefun.effect.EIO_;
+import com.github.tonivade.purefun.effect.PureIO;
+import com.github.tonivade.purefun.effect.PureIOOf;
+import com.github.tonivade.purefun.effect.Task;
 import com.github.tonivade.purefun.effect.TaskOf;
-import com.github.tonivade.purefun.effect.Task_;
+import com.github.tonivade.purefun.effect.UIO;
 import com.github.tonivade.purefun.effect.UIOOf;
-import com.github.tonivade.purefun.effect.UIO_;
-import com.github.tonivade.purefun.effect.PureIOOf;
-import com.github.tonivade.purefun.effect.PureIO_;
 import com.github.tonivade.purefun.instances.EIOInstances;
 import com.github.tonivade.purefun.instances.EitherInstances;
 import com.github.tonivade.purefun.instances.EvalInstances;
 import com.github.tonivade.purefun.instances.FutureInstances;
 import com.github.tonivade.purefun.instances.IOInstances;
 import com.github.tonivade.purefun.instances.OptionInstances;
+import com.github.tonivade.purefun.instances.PureIOInstances;
 import com.github.tonivade.purefun.instances.TaskInstances;
 import com.github.tonivade.purefun.instances.TryInstances;
 import com.github.tonivade.purefun.instances.UIOInstances;
-import com.github.tonivade.purefun.instances.PureIOInstances;
-
-import static com.github.tonivade.purefun.core.Matcher1.always;
-import static com.github.tonivade.purefun.core.Matcher1.is;
-import static com.github.tonivade.purefun.core.Producer.cons;
-import static com.github.tonivade.purefun.core.Unit.unit;
-import static com.github.tonivade.purefun.monad.IOOf.toIO;
-import com.github.tonivade.purefun.monad.IO_;
+import com.github.tonivade.purefun.monad.IO;
 import com.github.tonivade.purefun.type.Either;
-import com.github.tonivade.purefun.type.Either_;
+import com.github.tonivade.purefun.type.Eval;
 import com.github.tonivade.purefun.type.EvalOf;
-import com.github.tonivade.purefun.type.Eval_;
 import com.github.tonivade.purefun.type.Option;
-import com.github.tonivade.purefun.type.Option_;
 import com.github.tonivade.purefun.type.Try;
-import com.github.tonivade.purefun.type.Try_;
 
 public class MonadErrorTest {
 
-  private final MonadError<Try_, Throwable> monadError = TryInstances.monadError();
+  private final MonadError<Try<?>, Throwable> monadError = TryInstances.monadError();
 
   @Test
   public void recover() {
-    Kind<Try_, String> recover =
+    Kind<Try<?>, String> recover =
         monadError.recover(Try.<String>failure("error"), PartialFunction1.of(always(), Throwable::toString));
 
     assertEquals(Try.success("java.lang.RuntimeException: error"), recover);
@@ -61,7 +59,7 @@ public void recover() {
 
   @Test
   public void attempRight() {
-    Kind<Try_, Either<Throwable, String>> attempt = monadError.attempt(Try.success("hola mundo!"));
+    Kind<Try<?>, Either<Throwable, String>> attempt = monadError.attempt(Try.success("hola mundo!"));
 
     assertEquals(Try.success(Either.right("hola mundo!")), attempt);
   }
@@ -70,7 +68,7 @@ public void attempRight() {
   public void attempLeft() {
     Exception error = new Exception("error");
 
-    Kind<Try_, Either<Throwable, String>> attempt = monadError.attempt(Try.<String>failure(error));
+    Kind<Try<?>, Either<Throwable, String>> attempt = monadError.attempt(Try.<String>failure(error));
 
     assertEquals(Try.success(Either.left(error)), attempt);
   }
@@ -79,7 +77,7 @@ public void attempLeft() {
   public void ensureError() {
     Exception error = new Exception("error");
 
-    Kind<Try_, String> ensure =
+    Kind<Try<?>, String> ensure =
         monadError.ensure(Try.success("not ok"), cons(error), is("ok"));
 
     assertEquals(Try.failure(error), ensure);
@@ -89,7 +87,7 @@ public void ensureError() {
   public void ensureOk() {
     Exception error = new Exception("error");
 
-    Kind<Try_, String> ensure =
+    Kind<Try<?>, String> ensure =
         monadError.ensure(Try.success("ok"), cons(error), is("ok"));
 
     assertEquals(Try.success("ok"), ensure);
@@ -98,15 +96,15 @@ public void ensureOk() {
   @Test
   public void either() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<Kind<Either_, Throwable>, Throwable> monadError = EitherInstances.<Throwable>monadError();
+    MonadError<Kind<Either<?, ?>, Throwable>, Throwable> monadError = EitherInstances.<Throwable>monadError();
 
-    Kind<Kind<Either_, Throwable>, String> pure = monadError.pure("is not ok");
-    Kind<Kind<Either_, Throwable>, String> raiseError = monadError.raiseError(error);
-    Kind<Kind<Either_, Throwable>, String> handleError =
+    Kind<Kind<Either<?, ?>, Throwable>, String> pure = monadError.pure("is not ok");
+    Kind<Kind<Either<?, ?>, Throwable>, String> raiseError = monadError.raiseError(error);
+    Kind<Kind<Either<?, ?>, Throwable>, String> handleError =
         monadError.handleError(raiseError, e -> "not an error");
-    Kind<Kind<Either_, Throwable>, String> ensureOk =
+    Kind<Kind<Either<?, ?>, Throwable>, String> ensureOk =
         monadError.ensure(pure, () -> error, value -> "is not ok".equals(value));
-    Kind<Kind<Either_, Throwable>, String> ensureError =
+    Kind<Kind<Either<?, ?>, Throwable>, String> ensureError =
         monadError.ensure(pure, () -> error, value -> "is ok?".equals(value));
 
     assertAll(
@@ -118,13 +116,13 @@ public void either() {
 
   @Test
   public void option() {
-    MonadError<Option_, Unit> monadError = OptionInstances.monadError();
+    MonadError<Option<?>, Unit> monadError = OptionInstances.monadError();
 
-    Kind<Option_, String> pure = monadError.pure("is not ok");
-    Kind<Option_, String> raiseError = monadError.raiseError(unit());
-    Kind<Option_, String> handleError = monadError.handleError(raiseError, e -> "not an error");
-    Kind<Option_, String> ensureOk = monadError.ensure(pure, Unit::unit, "is not ok"::equals);
-    Kind<Option_, String> ensureError = monadError.ensure(pure, Unit::unit, "is ok?"::equals);
+    Kind<Option<?>, String> pure = monadError.pure("is not ok");
+    Kind<Option<?>, String> raiseError = monadError.raiseError(unit());
+    Kind<Option<?>, String> handleError = monadError.handleError(raiseError, e -> "not an error");
+    Kind<Option<?>, String> ensureOk = monadError.ensure(pure, Unit::unit, "is not ok"::equals);
+    Kind<Option<?>, String> ensureError = monadError.ensure(pure, Unit::unit, "is ok?"::equals);
 
     assertAll(
         () -> assertEquals(Option.none(), raiseError),
@@ -136,13 +134,13 @@ public void option() {
   @Test
   public void try_() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<Try_, Throwable> monadError = TryInstances.monadError();
+    MonadError<Try<?>, Throwable> monadError = TryInstances.monadError();
 
-    Kind<Try_, String> pure = monadError.pure("is not ok");
-    Kind<Try_, String> raiseError = monadError.raiseError(error);
-    Kind<Try_, String> handleError = monadError.handleError(raiseError, e -> "not an error");
-    Kind<Try_, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
-    Kind<Try_, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
+    Kind<Try<?>, String> pure = monadError.pure("is not ok");
+    Kind<Try<?>, String> raiseError = monadError.raiseError(error);
+    Kind<Try<?>, String> handleError = monadError.handleError(raiseError, e -> "not an error");
+    Kind<Try<?>, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
+    Kind<Try<?>, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
 
     assertAll(
         () -> assertEquals(Try.failure(error), raiseError),
@@ -154,13 +152,13 @@ public void try_() {
   @Test
   public void future() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<Future_, Throwable> monadError = FutureInstances.monadError();
+    MonadError<Future<?>, Throwable> monadError = FutureInstances.monadError();
 
-    Kind<Future_, String> pure = monadError.pure("is not ok");
-    Kind<Future_, String> raiseError = monadError.raiseError(error);
-    Kind<Future_, String> handleError = monadError.handleError(raiseError, e -> "not an error");
-    Kind<Future_, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
-    Kind<Future_, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
+    Kind<Future<?>, String> pure = monadError.pure("is not ok");
+    Kind<Future<?>, String> raiseError = monadError.raiseError(error);
+    Kind<Future<?>, String> handleError = monadError.handleError(raiseError, e -> "not an error");
+    Kind<Future<?>, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
+    Kind<Future<?>, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
 
     assertAll(
         () -> assertEquals(Try.failure(error), FutureOf.narrowK(raiseError).await()),
@@ -172,13 +170,13 @@ public void future() {
   @Test
   public void eval() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<Eval_, Throwable> monadError = EvalInstances.monadError();
+    MonadError<Eval<?>, Throwable> monadError = EvalInstances.monadError();
 
-    Kind<Eval_, String> pure = monadError.pure("is not ok");
-    Kind<Eval_, String> raiseError = monadError.raiseError(error);
-    Kind<Eval_, String> handleError = monadError.handleError(raiseError, e -> "not an error");
-    Kind<Eval_, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
-    Kind<Eval_, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
+    Kind<Eval<?>, String> pure = monadError.pure("is not ok");
+    Kind<Eval<?>, String> raiseError = monadError.raiseError(error);
+    Kind<Eval<?>, String> handleError = monadError.handleError(raiseError, e -> "not an error");
+    Kind<Eval<?>, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
+    Kind<Eval<?>, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
 
     assertAll(
         () -> assertThrows(RuntimeException.class, () -> EvalOf.narrowK(raiseError).value()),
@@ -190,13 +188,13 @@ public void eval() {
   @Test
   public void io() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<IO_, Throwable> monadError = IOInstances.monadError();
+    MonadError<IO<?>, Throwable> monadError = IOInstances.monadError();
 
-    Kind<IO_, String> pure = monadError.pure("is not ok");
-    Kind<IO_, String> raiseError = monadError.raiseError(error);
-    Kind<IO_, String> handleError = monadError.handleError(raiseError, e -> "not an error");
-    Kind<IO_, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
-    Kind<IO_, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
+    Kind<IO<?>, String> pure = monadError.pure("is not ok");
+    Kind<IO<?>, String> raiseError = monadError.raiseError(error);
+    Kind<IO<?>, String> handleError = monadError.handleError(raiseError, e -> "not an error");
+    Kind<IO<?>, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
+    Kind<IO<?>, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
 
     assertAll(
         () -> assertThrows(RuntimeException.class, () -> raiseError.fix(toIO()).unsafeRunSync()),
@@ -208,13 +206,13 @@ public void io() {
   @Test
   public void uio() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<UIO_, Throwable> monadError = UIOInstances.monadError();
+    MonadError<UIO<?>, Throwable> monadError = UIOInstances.monadError();
 
-    Kind<UIO_, String> pure = monadError.pure("is not ok");
-    Kind<UIO_, String> raiseError = monadError.raiseError(error);
-    Kind<UIO_, String> handleError = monadError.handleError(raiseError, e -> "not an error");
-    Kind<UIO_, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
-    Kind<UIO_, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
+    Kind<UIO<?>, String> pure = monadError.pure("is not ok");
+    Kind<UIO<?>, String> raiseError = monadError.raiseError(error);
+    Kind<UIO<?>, String> handleError = monadError.handleError(raiseError, e -> "not an error");
+    Kind<UIO<?>, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
+    Kind<UIO<?>, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
 
     assertAll(
         () -> assertThrows(RuntimeException.class, () -> UIOOf.narrowK(raiseError).unsafeRunSync()),
@@ -226,13 +224,13 @@ public void uio() {
   @Test
   public void eio() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<Kind<EIO_, Throwable>, Throwable> monadError = EIOInstances.monadThrow();
+    MonadError<Kind<EIO<?, ?>, Throwable>, Throwable> monadError = EIOInstances.monadThrow();
 
-    Kind<Kind<EIO_, Throwable>, String> pure = monadError.pure("is not ok");
-    Kind<Kind<EIO_, Throwable>, String> raiseError = monadError.raiseError(error);
-    Kind<Kind<EIO_, Throwable>, String> handleError = monadError.handleError(raiseError, e -> "not an error");
-    Kind<Kind<EIO_, Throwable>, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
-    Kind<Kind<EIO_, Throwable>, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
+    Kind<Kind<EIO<?, ?>, Throwable>, String> pure = monadError.pure("is not ok");
+    Kind<Kind<EIO<?, ?>, Throwable>, String> raiseError = monadError.raiseError(error);
+    Kind<Kind<EIO<?, ?>, Throwable>, String> handleError = monadError.handleError(raiseError, e -> "not an error");
+    Kind<Kind<EIO<?, ?>, Throwable>, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
+    Kind<Kind<EIO<?, ?>, Throwable>, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
 
     assertAll(
         () -> assertEquals(Either.<Throwable, String>left(error), EIOOf.narrowK(raiseError).safeRunSync()),
@@ -244,13 +242,13 @@ public void eio() {
   @Test
   public void task() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<Task_, Throwable> monadError = TaskInstances.monadThrow();
+    MonadError<Task<?>, Throwable> monadError = TaskInstances.monadThrow();
 
-    Kind<Task_, String> pure = monadError.pure("is not ok");
-    Kind<Task_, String> raiseError = monadError.raiseError(error);
-    Kind<Task_, String> handleError = monadError.handleError(raiseError, e -> "not an error");
-    Kind<Task_, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
-    Kind<Task_, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
+    Kind<Task<?>, String> pure = monadError.pure("is not ok");
+    Kind<Task<?>, String> raiseError = monadError.raiseError(error);
+    Kind<Task<?>, String> handleError = monadError.handleError(raiseError, e -> "not an error");
+    Kind<Task<?>, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
+    Kind<Task<?>, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
 
     assertAll(
         () -> assertEquals(Try.<String>failure(error), TaskOf.narrowK(raiseError).safeRunSync()),
@@ -262,13 +260,13 @@ public void task() {
   @Test
   public void PureIO() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<Kind<Kind<PureIO_, Void>, Throwable>, Throwable> monadError = PureIOInstances.monadThrow();
+    MonadError<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, Throwable> monadError = PureIOInstances.monadThrow();
 
-    Kind<Kind<Kind<PureIO_, Void>, Throwable>, String> pure = monadError.pure("is not ok");
-    Kind<Kind<Kind<PureIO_, Void>, Throwable>, String> raiseError = monadError.raiseError(error);
-    Kind<Kind<Kind<PureIO_, Void>, Throwable>, String> handleError = monadError.handleError(raiseError, e -> "not an error");
-    Kind<Kind<Kind<PureIO_, Void>, Throwable>, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
-    Kind<Kind<Kind<PureIO_, Void>, Throwable>, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
+    Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, String> pure = monadError.pure("is not ok");
+    Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, String> raiseError = monadError.raiseError(error);
+    Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, String> handleError = monadError.handleError(raiseError, e -> "not an error");
+    Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, String> ensureOk = monadError.ensure(pure, () -> error, "is not ok"::equals);
+    Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, String> ensureError = monadError.ensure(pure, () -> error, "is ok?"::equals);
 
     assertAll(
         () -> assertEquals(Either.<Throwable, String>left(error), PureIOOf.narrowK(raiseError).provide(null)),
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadTest.java
index d4447566c..04a350149 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/MonadTest.java
@@ -7,16 +7,16 @@
 import static com.github.tonivade.purefun.laws.MonadLaws.verifyLaws;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import org.junit.jupiter.api.Test;
 
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.instances.EitherInstances;
 import com.github.tonivade.purefun.instances.OptionInstances;
 import com.github.tonivade.purefun.instances.ValidationInstances;
-import com.github.tonivade.purefun.type.Id_;
+import com.github.tonivade.purefun.type.Id;
 import com.github.tonivade.purefun.type.Option;
-import com.github.tonivade.purefun.type.Option_;
-import com.github.tonivade.purefun.type.Try_;
+import com.github.tonivade.purefun.type.Try;
 
 public class MonadTest {
 
@@ -24,17 +24,17 @@ public class MonadTest {
 
   @Test
   public void idMonad() {
-    verifyLaws(Instances.<Id_>monad());
+    verifyLaws(Instances.<Id<?>>monad());
   }
 
   @Test
   public void optionMonad() {
-    verifyLaws(Instances.<Option_>monad());
+    verifyLaws(Instances.<Option<?>>monad());
   }
 
   @Test
   public void tryMonad() {
-    verifyLaws(Instances.<Try_>monad());
+    verifyLaws(Instances.<Try<?>>monad());
   }
 
   @Test
@@ -49,7 +49,7 @@ public void validationMonad() {
 
   @Test
   public void option() {
-    Monad<Option_> monad = OptionInstances.monad();
+    Monad<Option<?>> monad = OptionInstances.monad();
 
     Option<String> some = Option.some("asdf");
     Option<String> none = Option.none();
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ProfunctorTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ProfunctorTest.java
index c6c49f176..8f30a58f7 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ProfunctorTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/ProfunctorTest.java
@@ -5,12 +5,12 @@
 package com.github.tonivade.purefun.typeclasses;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import org.junit.jupiter.api.Test;
 
-import com.github.tonivade.purefun.core.Function1Of;
-import com.github.tonivade.purefun.core.Function1_;
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.core.Function1;
+import com.github.tonivade.purefun.core.Function1Of;
 import com.github.tonivade.purefun.instances.Function1Instances;
 
 public class ProfunctorTest {
@@ -21,9 +21,9 @@ public class ProfunctorTest {
 
   @Test
   public void dimap() {
-    Profunctor<Function1_> profunctor = Function1Instances.profunctor();
+    Profunctor<Function1<?, ?>> profunctor = Function1Instances.profunctor();
 
-    Kind<Kind<Function1_, Integer>, Double> result = profunctor.dimap(parseInt, toString, toDouble);
+    Kind<Kind<Function1<?, ?>, Integer>, Double> result = profunctor.dimap(parseInt, toString, toDouble);
 
     assertEquals(2.0, result.fix(Function1Of::<Integer, Double>narrowK).apply(2));
   }
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/SelectiveTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/SelectiveTest.java
index fdc3cce68..5ada6bc0e 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/SelectiveTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/SelectiveTest.java
@@ -5,18 +5,19 @@
 package com.github.tonivade.purefun.typeclasses;
 
 import org.junit.jupiter.api.Test;
+
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.data.Sequence;
 import com.github.tonivade.purefun.instances.SequenceInstances;
 import com.github.tonivade.purefun.instances.ValidationInstances;
 import com.github.tonivade.purefun.laws.SelectiveLaws;
-import com.github.tonivade.purefun.type.Validation_;
+import com.github.tonivade.purefun.type.Validation;
 
 public class SelectiveTest {
 
   @Test
   public void laws() {
-    Selective<Kind<Validation_, Sequence<String>>> selective =
+    Selective<Kind<Validation<?, ?>, Sequence<String>>> selective =
         ValidationInstances.selective(SequenceInstances.semigroup());
 
     SelectiveLaws.verifyLaws(selective);
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/SemigroupalTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/SemigroupalTest.java
index 9287e2ac4..60a5b7677 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/SemigroupalTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/SemigroupalTest.java
@@ -7,13 +7,12 @@
 import com.github.tonivade.purefun.core.Tuple;
 import com.github.tonivade.purefun.instances.OptionInstances;
 import com.github.tonivade.purefun.type.Option;
-import com.github.tonivade.purefun.type.Option_;
 
 public class SemigroupalTest {
 
   @Test
   public void semigroupal() {
-    Semigroupal<Option_> instance = OptionInstances.semigroupal();
+    Semigroupal<Option<?>> instance = OptionInstances.semigroupal();
 
     assertAll(
         () -> assertEquals(Option.none(), instance.product(Option.none(), Option.none())),
diff --git a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/TraverseTest.java b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/TraverseTest.java
index 5f7d9986f..197631cf8 100644
--- a/instances/src/test/java/com/github/tonivade/purefun/typeclasses/TraverseTest.java
+++ b/instances/src/test/java/com/github/tonivade/purefun/typeclasses/TraverseTest.java
@@ -11,7 +11,6 @@
 import org.junit.jupiter.api.Test;
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.data.Sequence;
-import com.github.tonivade.purefun.data.Sequence_;
 import com.github.tonivade.purefun.instances.ConstInstances;
 import com.github.tonivade.purefun.instances.EitherInstances;
 import com.github.tonivade.purefun.instances.IdInstances;
@@ -19,15 +18,10 @@
 import com.github.tonivade.purefun.instances.SequenceInstances;
 import com.github.tonivade.purefun.instances.TryInstances;
 import com.github.tonivade.purefun.type.Const;
-import com.github.tonivade.purefun.type.Const_;
 import com.github.tonivade.purefun.type.Either;
-import com.github.tonivade.purefun.type.Either_;
 import com.github.tonivade.purefun.type.Id;
-import com.github.tonivade.purefun.type.Id_;
 import com.github.tonivade.purefun.type.Option;
-import com.github.tonivade.purefun.type.Option_;
 import com.github.tonivade.purefun.type.Try;
-import com.github.tonivade.purefun.type.Try_;
 
 public class TraverseTest {
 
@@ -35,9 +29,9 @@ public class TraverseTest {
   public void sequence() {
     Sequence<Option<String>> seq = listOf(Option.some("a"), Option.some("b"), Option.some("c"));
 
-    Traverse<Sequence_> instance = SequenceInstances.traverse();
+    Traverse<Sequence<?>> instance = SequenceInstances.traverse();
 
-    Kind<Option_, Kind<Sequence_, String>> result =
+    Kind<Option<?>, Kind<Sequence<?>, String>> result =
         instance.traverse(OptionInstances.applicative(), seq, x -> x.map(String::toUpperCase));
 
     assertEquals(Option.some(listOf("A", "B", "C")), result);
@@ -45,7 +39,7 @@ public void sequence() {
 
   @Test
   public void either() {
-    Traverse<Kind<Either_, Throwable>> instance = EitherInstances.traverse();
+    Traverse<Kind<Either<?, ?>, Throwable>> instance = EitherInstances.traverse();
 
     Exception error = new Exception("error");
 
@@ -60,7 +54,7 @@ public void either() {
 
   @Test
   public void composed() {
-    Traverse<Nested<Option_, Id_>> composed = Traverse.compose(OptionInstances.traverse(), IdInstances.traverse());
+    Traverse<Nested<Option<?>, Id<?>>> composed = Traverse.compose(OptionInstances.traverse(), IdInstances.traverse());
 
     assertEquals(Try.success(Option.some(Id.of("HOLA!"))),
         composed.traverse(TryInstances.applicative(), nest(Option.some(Id.of(Try.success("hola!")))),
@@ -69,7 +63,7 @@ public void composed() {
 
   @Test
   public void id() {
-    Traverse<Id_> instance = IdInstances.traverse();
+    Traverse<Id<?>> instance = IdInstances.traverse();
 
     assertAll(
         () -> assertEquals(Option.some(Id.of("HELLO!")),
@@ -79,7 +73,7 @@ public void id() {
 
   @Test
   public void testConst() {
-    Traverse<Kind<Const_, String>> instance = ConstInstances.traverse();
+    Traverse<Kind<Const<?, ?>, String>> instance = ConstInstances.traverse();
 
     assertAll(
         () -> assertEquals(Option.some(Const.of("hello!")),
@@ -89,7 +83,7 @@ public void testConst() {
 
   @Test
   public void option() {
-    Traverse<Option_> instance = OptionInstances.traverse();
+    Traverse<Option<?>> instance = OptionInstances.traverse();
 
     assertAll(
         () -> assertEquals(Try.success(Option.some("HELLO!")),
@@ -102,7 +96,7 @@ public void option() {
 
   @Test
   public void testTry() {
-    Traverse<Try_> instance = TryInstances.traverse();
+    Traverse<Try<?>> instance = TryInstances.traverse();
 
     Exception error = new Exception("error");
 
diff --git a/monad/src/main/java/com/github/tonivade/purefun/monad/IO.java b/monad/src/main/java/com/github/tonivade/purefun/monad/IO.java
index 8054c4190..2e6330e9c 100644
--- a/monad/src/main/java/com/github/tonivade/purefun/monad/IO.java
+++ b/monad/src/main/java/com/github/tonivade/purefun/monad/IO.java
@@ -42,7 +42,7 @@
 import com.github.tonivade.purefun.typeclasses.Fiber;
 
 @HigherKind
-public sealed interface IO<T> extends IOOf<T>, Effect<IO_, T>, Recoverable {
+public sealed interface IO<T> extends IOOf<T>, Effect<IO<?>, T>, Recoverable {
 
   IO<Unit> UNIT = pure(Unit.unit());
 
@@ -76,17 +76,17 @@ default <R> IO<R> map(Function1<? super T, ? extends R> map) {
   }
 
   @Override
-  default <R> IO<R> flatMap(Function1<? super T, ? extends Kind<IO_, ? extends R>> map) {
+  default <R> IO<R> flatMap(Function1<? super T, ? extends Kind<IO<?>, ? extends R>> map) {
     return new FlatMapped<>(this, map);
   }
 
   @Override
-  default <R> IO<R> andThen(Kind<IO_, ? extends R> after) {
+  default <R> IO<R> andThen(Kind<IO<?>, ? extends R> after) {
     return flatMap(ignore -> after);
   }
 
   @Override
-  default <R> IO<R> ap(Kind<IO_, ? extends Function1<? super T, ? extends R>> apply) {
+  default <R> IO<R> ap(Kind<IO<?>, ? extends Function1<? super T, ? extends R>> apply) {
     return parMap2(Future.DEFAULT_EXECUTOR, this, apply, (v, a) -> a.apply(v));
   }
 
@@ -108,8 +108,8 @@ default <R> IO<R> redeem(Function1<? super Throwable, ? extends R> mapError,
     return attempt().map(result -> result.fold(mapError, mapper));
   }
 
-  default <R> IO<R> redeemWith(Function1<? super Throwable, ? extends Kind<IO_, ? extends R>> mapError,
-                               Function1<? super T, ? extends Kind<IO_, ? extends R>> mapper) {
+  default <R> IO<R> redeemWith(Function1<? super Throwable, ? extends Kind<IO<?>, ? extends R>> mapError,
+                               Function1<? super T, ? extends Kind<IO<?>, ? extends R>> mapper) {
     return attempt().flatMap(result -> result.fold(mapError, mapper));
   }
 
@@ -122,7 +122,7 @@ default <X extends Throwable> IO<T> recover(Class<X> type, Function1<? super X,
     return recoverWith(PartialFunction1.of(error -> error.getClass().equals(type), t -> function.andThen(IO::pure).apply((X) t)));
   }
 
-  default IO<T> recoverWith(PartialFunction1<? super Throwable, ? extends Kind<IO_, ? extends T>> mapper) {
+  default IO<T> recoverWith(PartialFunction1<? super Throwable, ? extends Kind<IO<?>, ? extends T>> mapper) {
     return new Recover<>(this, mapper.andThen(IOOf::narrowK));
   }
 
@@ -132,7 +132,7 @@ default IO<Tuple2<Duration, T>> timed() {
       start -> map(result -> Tuple.of(Duration.ofNanos(System.nanoTime() - start), result)));
   }
 
-  default IO<Fiber<IO_, T>> fork() {
+  default IO<Fiber<IO<?>, T>> fork() {
     return async(callback -> {
       IOConnection connection = IOConnection.cancellable();
       Promise<T> promise = runAsync(this, connection);
@@ -199,17 +199,17 @@ static <T> IO<T> pure(T value) {
     return new Pure<>(value);
   }
 
-  static <A, B> IO<Either<A, B>> race(Kind<IO_, ? extends A> fa, Kind<IO_, ? extends B> fb) {
+  static <A, B> IO<Either<A, B>> race(Kind<IO<?>, ? extends A> fa, Kind<IO<?>, ? extends B> fb) {
     return race(Future.DEFAULT_EXECUTOR, fa, fb);
   }
 
-  static <A, B> IO<Either<A, B>> race(Executor executor, Kind<IO_, ? extends A> fa, Kind<IO_, ? extends B> fb) {
+  static <A, B> IO<Either<A, B>> race(Executor executor, Kind<IO<?>, ? extends A> fa, Kind<IO<?>, ? extends B> fb) {
     return racePair(executor, fa, fb).flatMap(either -> either.fold(
         ta -> ta.get2().cancel().fix(IOOf.toIO()).map(x -> Either.left(ta.get1())),
         tb -> tb.get1().cancel().fix(IOOf.toIO()).map(x -> Either.right(tb.get2()))));
   }
 
-  static <A, B> IO<Either<Tuple2<A, Fiber<IO_, B>>, Tuple2<Fiber<IO_, A>, B>>> racePair(Executor executor, Kind<IO_, ? extends A> fa, Kind<IO_, ? extends B> fb) {
+  static <A, B> IO<Either<Tuple2<A, Fiber<IO<?>, B>>, Tuple2<Fiber<IO<?>, A>, B>>> racePair(Executor executor, Kind<IO<?>, ? extends A> fa, Kind<IO<?>, ? extends B> fb) {
     return cancellable(callback -> {
 
       IOConnection connection1 = IOConnection.cancellable();
@@ -241,7 +241,7 @@ static <T> IO<T> delay(Duration delay, Producer<? extends T> lazy) {
     return sleep(delay).andThen(task(lazy));
   }
 
-  static <T> IO<T> suspend(Producer<? extends Kind<IO_, ? extends T>> lazy) {
+  static <T> IO<T> suspend(Producer<? extends Kind<IO<?>, ? extends T>> lazy) {
     return new Suspend<>(() -> lazy.get().fix(IOOf::narrowK));
   }
 
@@ -318,7 +318,7 @@ static <T> IO<T> async(Consumer1<Consumer1<? super Try<? extends T>>> callback)
     return cancellable(callback.asFunction().andThen(IO::pure));
   }
 
-  static <T> IO<T> cancellable(Function1<Consumer1<? super Try<? extends T>>, Kind<IO_, Unit>> callback) {
+  static <T> IO<T> cancellable(Function1<Consumer1<? super Try<? extends T>>, Kind<IO<?>, Unit>> callback) {
     return new Async<>(callback);
   }
 
@@ -342,8 +342,8 @@ static IO<Unit> unit() {
     return UNIT;
   }
 
-  static <T, R> IO<R> bracket(Kind<IO_, ? extends T> acquire,
-      Function1<? super T, ? extends Kind<IO_, ? extends R>> use, Function1<? super T, ? extends Kind<IO_, Unit>> release) {
+  static <T, R> IO<R> bracket(Kind<IO<?>, ? extends T> acquire,
+      Function1<? super T, ? extends Kind<IO<?>, ? extends R>> use, Function1<? super T, ? extends Kind<IO<?>, Unit>> release) {
     return cancellable(callback -> {
 
       IOConnection cancellable = IOConnection.cancellable();
@@ -361,37 +361,37 @@ static <T, R> IO<R> bracket(Kind<IO_, ? extends T> acquire,
     });
   }
 
-  static <T, R> IO<R> bracket(Kind<IO_, ? extends T> acquire,
-      Function1<? super T, ? extends Kind<IO_, ? extends R>> use, Consumer1<? super T> release) {
+  static <T, R> IO<R> bracket(Kind<IO<?>, ? extends T> acquire,
+      Function1<? super T, ? extends Kind<IO<?>, ? extends R>> use, Consumer1<? super T> release) {
     return bracket(acquire, use, release.asFunction().andThen(IO::pure));
   }
 
-  static <T extends AutoCloseable, R> IO<R> bracket(Kind<IO_, ? extends T> acquire,
-      Function1<? super T, ? extends Kind<IO_, ? extends R>> use) {
+  static <T extends AutoCloseable, R> IO<R> bracket(Kind<IO<?>, ? extends T> acquire,
+      Function1<? super T, ? extends Kind<IO<?>, ? extends R>> use) {
     return bracket(acquire, use, AutoCloseable::close);
   }
 
-  static IO<Unit> sequence(Sequence<? extends Kind<IO_, ?>> sequence) {
-    Kind<IO_, ?> initial = IO.unit().kind();
+  static IO<Unit> sequence(Sequence<? extends Kind<IO<?>, ?>> sequence) {
+    Kind<IO<?>, ?> initial = IO.unit().kind();
     return sequence.foldLeft(initial,
-        (Kind<IO_, ?> a, Kind<IO_, ?> b) -> a.fix(IOOf::narrowK).andThen(b.fix(IOOf::narrowK))).fix(IOOf::narrowK).andThen(IO.unit());
+        (Kind<IO<?>, ?> a, Kind<IO<?>, ?> b) -> a.fix(IOOf::narrowK).andThen(b.fix(IOOf::narrowK))).fix(IOOf::narrowK).andThen(IO.unit());
   }
 
-  static <A> IO<Sequence<A>> traverse(Sequence<? extends Kind<IO_, A>> sequence) {
+  static <A> IO<Sequence<A>> traverse(Sequence<? extends Kind<IO<?>, A>> sequence) {
     return traverse(Future.DEFAULT_EXECUTOR, sequence);
   }
 
-  static <A> IO<Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<IO_, A>> sequence) {
+  static <A> IO<Sequence<A>> traverse(Executor executor, Sequence<? extends Kind<IO<?>, A>> sequence) {
     return sequence.foldLeft(pure(ImmutableList.empty()),
-        (Kind<IO_, Sequence<A>> xs, Kind<IO_, A> a) -> parMap2(executor, xs, a, Sequence::append));
+        (Kind<IO<?>, Sequence<A>> xs, Kind<IO<?>, A> a) -> parMap2(executor, xs, a, Sequence::append));
   }
 
-  static <A, B, C> IO<C> parMap2(Kind<IO_, ? extends A> fa, Kind<IO_, ? extends B> fb,
+  static <A, B, C> IO<C> parMap2(Kind<IO<?>, ? extends A> fa, Kind<IO<?>, ? extends B> fb,
                               Function2<? super A, ? super B, ? extends C> mapper) {
     return parMap2(Future.DEFAULT_EXECUTOR, fa, fb, mapper);
   }
 
-  static <A, B, C> IO<C> parMap2(Executor executor, Kind<IO_, ? extends A> fa, Kind<IO_, ? extends B> fb,
+  static <A, B, C> IO<C> parMap2(Executor executor, Kind<IO<?>, ? extends A> fa, Kind<IO<?>, ? extends B> fb,
                               Function2<? super A, ? super B, ? extends C> mapper) {
     return cancellable(callback -> {
 
@@ -413,11 +413,11 @@ static <A, B, C> IO<C> parMap2(Executor executor, Kind<IO_, ? extends A> fa, Kin
     });
   }
 
-  static <A, B> IO<Tuple2<A, B>> tuple(Kind<IO_, ? extends A> fa, Kind<IO_, ? extends B> fb) {
+  static <A, B> IO<Tuple2<A, B>> tuple(Kind<IO<?>, ? extends A> fa, Kind<IO<?>, ? extends B> fb) {
     return tuple(Future.DEFAULT_EXECUTOR, fa, fb);
   }
 
-  static <A, B> IO<Tuple2<A, B>> tuple(Executor executor, Kind<IO_, ? extends A> fa, Kind<IO_, ? extends B> fb) {
+  static <A, B> IO<Tuple2<A, B>> tuple(Executor executor, Kind<IO<?>, ? extends A> fa, Kind<IO<?>, ? extends B> fb) {
     return parMap2(executor, fa, fb, Tuple::of);
   }
 
@@ -426,7 +426,7 @@ private static <T> Promise<T> runAsync(IO<T> current, IOConnection connection) {
   }
 
   @SuppressWarnings("unchecked")
-  private static <T, U, V> Promise<T> runAsync(Kind<IO_, T> current, IOConnection connection, CallStack<T> stack, Promise<T> promise) {
+  private static <T, U, V> Promise<T> runAsync(Kind<IO<?>, T> current, IOConnection connection, CallStack<T> stack, Promise<T> promise) {
     while (true) {
       try {
         current = unwrap(current, stack, identity());
@@ -478,7 +478,7 @@ private static <T, U, V> Promise<T> runAsync(Kind<IO_, T> current, IOConnection
     }
   }
 
-  private static <T, U> Kind<IO_,T> unwrap(Kind<IO_, T> current, CallStack<U> stack, Function1<Kind<IO_, ? extends T>, Kind<IO_, ? extends U>> next) {
+  private static <T, U> Kind<IO<?>,T> unwrap(Kind<IO<?>, T> current, CallStack<U> stack, Function1<Kind<IO<?>, ? extends T>, Kind<IO<?>, ? extends U>> next) {
     while (true) {
       if (current instanceof Failure<T> failure) {
         return stack.sneakyThrow(failure.error);
@@ -565,11 +565,11 @@ public String toString() {
 
   final class FlatMapped<T, R> implements IO<R> {
 
-    private final Kind<IO_, ? extends T> current;
-    private final Function1<? super T, ? extends Kind<IO_, ? extends R>> next;
+    private final Kind<IO<?>, ? extends T> current;
+    private final Function1<? super T, ? extends Kind<IO<?>, ? extends R>> next;
 
     private FlatMapped(IO<? extends T> current,
-                         Function1<? super T, ? extends Kind<IO_, ? extends R>> next) {
+                         Function1<? super T, ? extends Kind<IO<?>, ? extends R>> next) {
       this.current = checkNonNull(current);
       this.next = checkNonNull(next);
     }
@@ -596,9 +596,9 @@ public String toString() {
 
   final class Async<T> implements IO<T> {
 
-    private final Function1<Consumer1<? super Try<? extends T>>, Kind<IO_, Unit>> callback;
+    private final Function1<Consumer1<? super Try<? extends T>>, Kind<IO<?>, Unit>> callback;
 
-    private Async(Function1<Consumer1<? super Try<? extends T>>, Kind<IO_, Unit>> callback) {
+    private Async(Function1<Consumer1<? super Try<? extends T>>, Kind<IO<?>, Unit>> callback) {
       this.callback = checkNonNull(callback);
     }
 
@@ -610,9 +610,9 @@ public String toString() {
 
   final class Suspend<T> implements IO<T> {
 
-    private final Producer<? extends Kind<IO_, ? extends T>> lazy;
+    private final Producer<? extends Kind<IO<?>, ? extends T>> lazy;
 
-    private Suspend(Producer<? extends Kind<IO_, ? extends T>> lazy) {
+    private Suspend(Producer<? extends Kind<IO<?>, ? extends T>> lazy) {
       this.lazy = checkNonNull(lazy);
     }
 
@@ -624,10 +624,10 @@ public String toString() {
 
   final class Recover<T> implements IO<T> {
 
-    private final Kind<IO_, T> current;
-    private final PartialFunction1<? super Throwable, ? extends Kind<IO_, ? extends T>> mapper;
+    private final Kind<IO<?>, T> current;
+    private final PartialFunction1<? super Throwable, ? extends Kind<IO<?>, ? extends T>> mapper;
 
-    private Recover(IO<T> current, PartialFunction1<? super Throwable, ? extends Kind<IO_, ? extends T>> mapper) {
+    private Recover(IO<T> current, PartialFunction1<? super Throwable, ? extends Kind<IO<?>, ? extends T>> mapper) {
       this.current = checkNonNull(current);
       this.mapper = checkNonNull(mapper);
     }
@@ -645,7 +645,7 @@ sealed interface IOConnection {
 
   boolean isCancellable();
 
-  void setCancelToken(Kind<IO_, Unit> cancel);
+  void setCancelToken(Kind<IO<?>, Unit> cancel);
 
   void cancelNow();
 
@@ -667,7 +667,7 @@ public boolean isCancellable() {
     }
 
     @Override
-    public void setCancelToken(Kind<IO_, Unit> cancel) {
+    public void setCancelToken(Kind<IO<?>, Unit> cancel) {
       // uncancellable
     }
 
@@ -689,7 +689,7 @@ public StateIO updateState(Operator1<StateIO> update) {
 
   final class Cancellable implements IOConnection {
 
-    private Kind<IO_, Unit> cancelToken = IO.UNIT;
+    private Kind<IO<?>, Unit> cancelToken = IO.UNIT;
     private final AtomicReference<StateIO> state = new AtomicReference<>(StateIO.INITIAL);
 
     private Cancellable() { }
@@ -700,7 +700,7 @@ public boolean isCancellable() {
     }
 
     @Override
-    public void setCancelToken(Kind<IO_, Unit> cancel) {
+    public void setCancelToken(Kind<IO<?>, Unit> cancel) {
       this.cancelToken = checkNonNull(cancel);
     }
 
@@ -795,7 +795,7 @@ public void pop() {
     }
   }
 
-  public void add(PartialFunction1<? super Throwable, ? extends Kind<IO_, ? extends T>> mapError) {
+  public void add(PartialFunction1<? super Throwable, ? extends Kind<IO<?>, ? extends T>> mapError) {
     if (top == null) {
       return;
     }
@@ -824,7 +824,7 @@ public Option<IO<T>> tryHandle(Throwable error) {
 final class StackItem<T> {
 
   private int count = 0;
-  private final Deque<PartialFunction1<? super Throwable, ? extends Kind<IO_, ? extends T>>> recover = new ArrayDeque<>();
+  private final Deque<PartialFunction1<? super Throwable, ? extends Kind<IO<?>, ? extends T>>> recover = new ArrayDeque<>();
 
   @Nullable
   private final StackItem<T> prev;
@@ -858,7 +858,7 @@ public void reset() {
     count = 0;
   }
 
-  public void add(PartialFunction1<? super Throwable, ? extends Kind<IO_, ? extends T>> mapError) {
+  public void add(PartialFunction1<? super Throwable, ? extends Kind<IO<?>, ? extends T>> mapError) {
     recover.addFirst(mapError);
   }
 
diff --git a/monad/src/main/java/com/github/tonivade/purefun/monad/Reader.java b/monad/src/main/java/com/github/tonivade/purefun/monad/Reader.java
index 60c247873..bee08f8ee 100644
--- a/monad/src/main/java/com/github/tonivade/purefun/monad/Reader.java
+++ b/monad/src/main/java/com/github/tonivade/purefun/monad/Reader.java
@@ -11,7 +11,7 @@
 
 @HigherKind
 @FunctionalInterface
-public non-sealed interface Reader<R, A> extends ReaderOf<R, A>, Bindable<Kind<Reader_, R>, A> {
+public non-sealed interface Reader<R, A> extends ReaderOf<R, A>, Bindable<Kind<Reader<?, ?>, R>, A> {
 
   A eval(R reader);
 
@@ -21,7 +21,7 @@ default <B> Reader<R, B> map(Function1<? super A, ? extends B> mapper) {
   }
 
   @Override
-  default <B> Reader<R, B> flatMap(Function1<? super A, ? extends Kind<Kind<Reader_, R>, ? extends B>> mapper) {
+  default <B> Reader<R, B> flatMap(Function1<? super A, ? extends Kind<Kind<Reader<?, ?>, R>, ? extends B>> mapper) {
     return reader -> mapper.andThen(ReaderOf::<R, B>narrowK).apply(eval(reader)).eval(reader);
   }
 
diff --git a/monad/src/main/java/com/github/tonivade/purefun/monad/State.java b/monad/src/main/java/com/github/tonivade/purefun/monad/State.java
index 5724872d3..ccc0ee6d2 100644
--- a/monad/src/main/java/com/github/tonivade/purefun/monad/State.java
+++ b/monad/src/main/java/com/github/tonivade/purefun/monad/State.java
@@ -19,7 +19,7 @@
 
 @HigherKind
 @FunctionalInterface
-public non-sealed interface State<S, A> extends StateOf<S, A>, Bindable<Kind<State_, S>, A> {
+public non-sealed interface State<S, A> extends StateOf<S, A>, Bindable<Kind<State<?, ?>, S>, A> {
 
   Tuple2<S, A> run(S state);
 
@@ -29,7 +29,7 @@ default <R> State<S, R> map(Function1<? super A, ? extends R> mapper) {
   }
 
   @Override
-  default <R> State<S, R> flatMap(Function1<? super A, ? extends Kind<Kind<State_, S>, ? extends R>> mapper) {
+  default <R> State<S, R> flatMap(Function1<? super A, ? extends Kind<Kind<State<?, ?>, S>, ? extends R>> mapper) {
     return state -> {
       Tuple2<S, A> run = run(state);
       State<S, R> narrowK = mapper.andThen(StateOf::<S, R>narrowK).apply(run.get2());
diff --git a/monad/src/main/java/com/github/tonivade/purefun/monad/Writer.java b/monad/src/main/java/com/github/tonivade/purefun/monad/Writer.java
index 705fb7934..96215daf0 100644
--- a/monad/src/main/java/com/github/tonivade/purefun/monad/Writer.java
+++ b/monad/src/main/java/com/github/tonivade/purefun/monad/Writer.java
@@ -16,7 +16,7 @@
 import com.github.tonivade.purefun.typeclasses.Monoid;
 
 @HigherKind
-public non-sealed interface Writer<L, A> extends WriterOf<L, A>, Bindable<Kind<Writer_, L>, A> {
+public non-sealed interface Writer<L, A> extends WriterOf<L, A>, Bindable<Kind<Writer<?, ?>, L>, A> {
 
   Monoid<L> monoid();
   Tuple2<L, A> value();
@@ -53,7 +53,7 @@ default <V, R> Writer<V, R> bimap(Monoid<V> monoidV,
   }
 
   @Override
-  default <B> Writer<L, B> flatMap(Function1<? super A, ? extends Kind<Kind<Writer_, L>, ? extends B>> mapper) {
+  default <B> Writer<L, B> flatMap(Function1<? super A, ? extends Kind<Kind<Writer<?, ?>, L>, ? extends B>> mapper) {
     Writer<L, B> apply = mapper.andThen(WriterOf::<L, B>narrowK).apply(value().get2());
     Tuple2<L, A> combine = value().map1(log -> monoid().combine(log, apply.getLog()));
     return writer(monoid(), Tuple.of(combine.get1(), apply.getValue()));
diff --git a/monad/src/test/java/com/github/tonivade/purefun/monad/IOTest.java b/monad/src/test/java/com/github/tonivade/purefun/monad/IOTest.java
index 4ca60636f..4239ee57a 100644
--- a/monad/src/test/java/com/github/tonivade/purefun/monad/IOTest.java
+++ b/monad/src/test/java/com/github/tonivade/purefun/monad/IOTest.java
@@ -51,7 +51,7 @@
 @ExtendWith(MockitoExtension.class)
 public class IOTest {
 
-  private final Console<IO_> console = IOInstances.console();
+  private final Console<IO<?>> console = IOInstances.console();
 
   @Test
   public void pure() {
@@ -312,7 +312,7 @@ public void raceB() {
 
   @Test
   public void fork() {
-    IO<String> result = Instances.<IO_>monad().use()
+    IO<String> result = Instances.<IO<?>>monad().use()
       .then(IO.pure("hola"))
       .flatMap(hello -> IO.delay(Duration.ofSeconds(1), () -> hello + " toni").fork())
       .flatMap(Fiber::join).fix(toIO());
@@ -406,7 +406,7 @@ private IO<Integer> sum(Integer n, Integer sum) {
   }
 
   private IO<ImmutableList<String>> currentThreadIO() {
-    Reference<IO_, ImmutableList<String>> ref = IOInstances.monadDefer().ref(ImmutableList.empty());
+    Reference<IO<?>, ImmutableList<String>> ref = IOInstances.monadDefer().ref(ImmutableList.empty());
     IO<ImmutableList<String>> currentThread =
         ref.updateAndGet(list -> list.append("thread-" + Thread.currentThread().threadId())).fix(toIO());
 
diff --git a/monad/src/test/java/com/github/tonivade/purefun/monad/TaglessTest.java b/monad/src/test/java/com/github/tonivade/purefun/monad/TaglessTest.java
index 681f5f5f9..83a37a269 100644
--- a/monad/src/test/java/com/github/tonivade/purefun/monad/TaglessTest.java
+++ b/monad/src/test/java/com/github/tonivade/purefun/monad/TaglessTest.java
@@ -24,9 +24,9 @@
 
 public class TaglessTest {
 
-  private final Program<Kind<State_, ImmutableList<String>>> stateProgram =
+  private final Program<Kind<State<?, ?>, ImmutableList<String>>> stateProgram =
       new Program<>(StateInstances.monad(), StateInstances.console());
-  private final Program<IO_> ioProgram =
+  private final Program<IO<?>> ioProgram =
       new Program<>(IOInstances.monad(), IOInstances.console());
 
   @Test
diff --git a/optics/src/test/java/com/github/tonivade/purefun/optics/IsoTest.java b/optics/src/test/java/com/github/tonivade/purefun/optics/IsoTest.java
index b5c74acd0..9ed85882e 100644
--- a/optics/src/test/java/com/github/tonivade/purefun/optics/IsoTest.java
+++ b/optics/src/test/java/com/github/tonivade/purefun/optics/IsoTest.java
@@ -13,7 +13,6 @@
 import com.github.tonivade.purefun.core.Tuple2;
 import com.github.tonivade.purefun.type.Option;
 import com.github.tonivade.purefun.type.OptionOf;
-import com.github.tonivade.purefun.type.Option_;
 
 public class IsoTest {
 
@@ -22,7 +21,7 @@ public class IsoTest {
   private final Iso<Tuple2<Integer, Integer>, Point> tupleToPoint = pointToTuple.reverse();
   private final Iso<Point, Point> pointToPoint = pointToTuple.compose(tupleToPoint);
   private final Iso<Point, Point> identity = Iso.identity();
-  private final Iso<Option<String>, Kind<Option_, String>> optionToKind =
+  private final Iso<Option<String>, Kind<Option<?>, String>> optionToKind =
     Iso.of(Option::kind, OptionOf::<String>narrowK);
 
   private final Point point = new Point(1, 2);
diff --git a/processor/src/main/java/com/github/tonivade/purefun/processor/HigherKindProcessor.java b/processor/src/main/java/com/github/tonivade/purefun/processor/HigherKindProcessor.java
index 1adae9089..0f897c7e5 100644
--- a/processor/src/main/java/com/github/tonivade/purefun/processor/HigherKindProcessor.java
+++ b/processor/src/main/java/com/github/tonivade/purefun/processor/HigherKindProcessor.java
@@ -72,17 +72,18 @@ private void generate(TypeElement element) throws IOException {
       packageName = null;
       className = qualifiedName;
     }
-    String witnessName = className + "_";
+    String witnessName = witnessOf(packageName, className, element.getTypeParameters());
     String typeOfName = annotation.value().isEmpty() ? className + "Of" : annotation.value();
-    writeWitness(packageName, witnessName);
     writeTypeOf(packageName, className, typeOfName, witnessName, element.getTypeParameters());
   }
 
-  private void writeWitness(@Nullable String packageName, String witnessName) throws IOException {
-    JavaFileObject witnessFile = createFile(packageName, witnessName);
-    try (PrintWriter writer = new PrintWriter(witnessFile.openWriter())) {
-      witness(writer, packageName, witnessName);
-    }
+  private String witnessOf(@Nullable String packageName, String className, List<? extends TypeParameterElement> types) {
+    return switch (types.size()) {
+      case 1 -> className + "<?>";
+      case 2 -> className + "<?, ?>";
+      case 3 -> className + "<?, ?, ?>";
+      default -> throw new UnsupportedOperationException("too many params: " + packageName + "." + className);
+    };
   }
 
   private void writeTypeOf(@Nullable String packageName, String className, String typeOfName, String witnessName,
@@ -98,21 +99,6 @@ private void writeTypeOf(@Nullable String packageName, String className, String
     }
   }
 
-  private void witness(PrintWriter writer, @Nullable String packageName, String witnessName) {
-    if (packageName != null) {
-      writer.println(packageName(packageName));
-      writer.println();
-    }
-    writer.println(import_(generated()));
-    writer.println();
-    writer.println(GENERATED);
-    writer.println(witnessClass(witnessName));
-    writer.println();
-    writer.println(privateConstructor(witnessName));
-    writer.println();
-    writer.println(END);
-  }
-
   private void generate1(PrintWriter writer, @Nullable String packageName, String className,
       String typeOfName, String kindName, List<? extends TypeParameterElement> list) {
     String higher1 = "Kind<" + kindName + ", A>";
@@ -124,9 +110,9 @@ private void generate1(PrintWriter writer, @Nullable String packageName, String
       writer.println(packageName(packageName));
       writer.println();
     }
-    writer.println(import_(KIND));
-    writer.println(import_(FUNCTION));
-    writer.println(import_(generated()));
+    writer.println(importClass(KIND));
+    writer.println(importClass(FUNCTION));
+    writer.println(importClass(generated()));
     writer.println();
     writer.println(GENERATED);
     writer.println(typeOfClass(className, typeOfNameWithParams, higher1));
@@ -149,9 +135,9 @@ private void generate2(PrintWriter writer, @Nullable String packageName, String
       writer.println();
     }
     writer.println();
-    writer.println(import_(KIND));
-    writer.println(import_(FUNCTION));
-    writer.println(import_(generated()));
+    writer.println(importClass(KIND));
+    writer.println(importClass(FUNCTION));
+    writer.println(importClass(generated()));
     writer.println();
     writer.println(GENERATED);
     writer.println(typeOfClass(className, typeOfNameWithParams, higher2));
@@ -175,9 +161,9 @@ private void generate3(PrintWriter writer, @Nullable String packageName, String
       writer.println();
     }
     writer.println();
-    writer.println(import_(KIND));
-    writer.println(import_(FUNCTION));
-    writer.println(import_(generated()));
+    writer.println(importClass(KIND));
+    writer.println(importClass(FUNCTION));
+    writer.println(importClass(generated()));
     writer.println();
     writer.println(GENERATED);
     writer.println(typeOfClass(className, typeOfNameWithParams, higher3));
@@ -199,10 +185,6 @@ private String generated() {
     return JAVAX_ANNOTATION_PROCESSING_GENERATED;
   }
 
-  private static String privateConstructor(String witnessName) {
-    return "  private " + witnessName + "() {}";
-  }
-
   private static void narrowK1(PrintWriter writer, String className, String aType, String hkt) {
     narrowK(writer, "<" + aType + ">", className + "<A>", hkt);
   }
@@ -242,10 +224,6 @@ private static void toTypeOf(PrintWriter writer, String types, String returnType
     writer.println();
   }
 
-  private static String witnessClass(String kindName) {
-    return "public final class " + kindName + " {";
-  }
-
   private static String typeOfClass(String typeName, String typeOfName, String type) {
     return "public sealed interface " + typeOfName + " extends " + type + " permits " + typeName + " {";
   }
@@ -266,7 +244,7 @@ private static String packageName(String packageName) {
     return "package " + packageName + ";";
   }
 
-  private static String import_(String className) {
+  private static String importClass(String className) {
     return "import " + className + ";";
   }
 }
diff --git a/processor/src/test/java/com/github/tonivade/purefun/processor/HigherKindProcessorTest.java b/processor/src/test/java/com/github/tonivade/purefun/processor/HigherKindProcessorTest.java
index e04438c43..82671b37c 100644
--- a/processor/src/test/java/com/github/tonivade/purefun/processor/HigherKindProcessorTest.java
+++ b/processor/src/test/java/com/github/tonivade/purefun/processor/HigherKindProcessorTest.java
@@ -12,16 +12,6 @@
 
 public class HigherKindProcessorTest {
 
-  private final JavaFileObject witness = forSourceLines("test.Foo_",
-        "package test;",
-
-        "import javax.annotation.processing.Generated;",
-
-        "@Generated(\"com.github.tonivade.purefun.processor.HigherKindProcessor\")",
-        "public final class Foo_ {",
-        "private Foo_() {}",
-        "}");
-
   @Test
   public void compilesKind1() {
     JavaFileObject file = forSourceLines("test.Foo",
@@ -41,14 +31,14 @@ public void compilesKind1() {
         "import javax.annotation.processing.Generated;",
 
         "@Generated(\"com.github.tonivade.purefun.processor.HigherKindProcessor\")",
-        "public sealed interface FooOf<A> extends Kind<Foo_, A> permits Foo {",
+        "public sealed interface FooOf<A> extends Kind<Foo<?>, A> permits Foo {",
 
         "@SuppressWarnings(\"unchecked\")",
-        "static <A> Foo<A> narrowK(Kind<Foo_, ? extends A> hkt) {",
+        "static <A> Foo<A> narrowK(Kind<Foo<?>, ? extends A> hkt) {",
         "return (Foo<A>) hkt;",
         "}",
 
-        "static <A> Function<Kind<Foo_, ? extends A>, Foo<A>> toFoo() {",
+        "static <A> Function<Kind<Foo<?>, ? extends A>, Foo<A>> toFoo() {",
         "return FooOf::narrowK;",
         "}",
 
@@ -56,7 +46,7 @@ public void compilesKind1() {
 
     assert_().about(javaSource()).that(file)
         .processedWith(new HigherKindProcessor())
-        .compilesWithoutError().and().generatesSources(generated, witness);
+        .compilesWithoutError().and().generatesSources(generated);
   }
 
   @Test
@@ -74,29 +64,22 @@ public void compilesKind1NoPackage() {
         "import javax.annotation.processing.Generated;",
 
         "@Generated(\"com.github.tonivade.purefun.processor.HigherKindProcessor\")",
-        "public sealed interface FooOf<A> extends Kind<Foo_, A> permits Foo {",
+        "public sealed interface FooOf<A> extends Kind<Foo<?>, A> permits Foo {",
 
         "@SuppressWarnings(\"unchecked\")",
-        "static <A> Foo<A> narrowK(Kind<Foo_, ? extends A> hkt) {",
+        "static <A> Foo<A> narrowK(Kind<Foo<?>, ? extends A> hkt) {",
         "return (Foo<A>) hkt;",
         "}",
 
-        "static <A> Function<Kind<Foo_, ? extends A>, Foo<A>> toFoo() {",
+        "static <A> Function<Kind<Foo<?>, ? extends A>, Foo<A>> toFoo() {",
         "return FooOf::narrowK;",
         "}",
 
         "}");
 
-    JavaFileObject generatedWitness = forSourceLines("Foo_",
-        "import javax.annotation.processing.Generated;",
-
-        "@Generated(\"com.github.tonivade.purefun.processor.HigherKindProcessor\")",
-        "public final class Foo_ {",
-        "private Foo_() {}",
-        "}");
     assert_().about(javaSource()).that(file)
         .processedWith(new HigherKindProcessor())
-        .compilesWithoutError().and().generatesSources(generated, generatedWitness);
+        .compilesWithoutError().and().generatesSources(generated);
   }
 
   @Test
@@ -118,14 +101,14 @@ public void compilesKind1Bounds() {
         "import javax.annotation.processing.Generated;",
 
         "@Generated(\"com.github.tonivade.purefun.processor.HigherKindProcessor\")",
-        "public sealed interface FooOf<A extends java.lang.String> extends Kind<Foo_, A> permits Foo {",
+        "public sealed interface FooOf<A extends java.lang.String> extends Kind<Foo<?>, A> permits Foo {",
 
         "@SuppressWarnings(\"unchecked\")",
-        "static <A extends java.lang.String> Foo<A> narrowK(Kind<Foo_, ? extends A> hkt) {",
+        "static <A extends java.lang.String> Foo<A> narrowK(Kind<Foo<?>, ? extends A> hkt) {",
         "return (Foo<A>) hkt;",
         "}",
 
-        "static <A extends java.lang.String> Function<Kind<Foo_, ? extends A>, Foo<A>> toFoo() {",
+        "static <A extends java.lang.String> Function<Kind<Foo<?>, ? extends A>, Foo<A>> toFoo() {",
         "return FooOf::narrowK;",
         "}",
 
@@ -133,7 +116,7 @@ public void compilesKind1Bounds() {
 
     assert_().about(javaSource()).that(file)
         .processedWith(new HigherKindProcessor())
-        .compilesWithoutError().and().generatesSources(generated, witness);
+        .compilesWithoutError().and().generatesSources(generated);
   }
 
   @Test
@@ -187,14 +170,14 @@ public void compilesKind2() {
         "import javax.annotation.processing.Generated;",
 
         "@Generated(\"com.github.tonivade.purefun.processor.HigherKindProcessor\")",
-        "public sealed interface FooOf<A, B> extends Kind<Kind<Foo_, A>, B> permits Foo {",
+        "public sealed interface FooOf<A, B> extends Kind<Kind<Foo<?, ?>, A>, B> permits Foo {",
 
         "@SuppressWarnings(\"unchecked\")",
-        "static <A, B> Foo<A, B> narrowK(Kind<Kind<Foo_, A>, ? extends B> hkt) {",
+        "static <A, B> Foo<A, B> narrowK(Kind<Kind<Foo<?, ?>, A>, ? extends B> hkt) {",
         "return (Foo<A, B>) hkt;",
         "}",
 
-        "static <A, B> Function<Kind<Kind<Foo_, A>, ? extends B>, Foo<A, B>> toFoo() {",
+        "static <A, B> Function<Kind<Kind<Foo<?, ?>, A>, ? extends B>, Foo<A, B>> toFoo() {",
         "return FooOf::narrowK;",
         "}",
 
@@ -202,7 +185,7 @@ public void compilesKind2() {
 
     assert_().about(javaSource()).that(file)
         .processedWith(new HigherKindProcessor())
-        .compilesWithoutError().and().generatesSources(generated, witness);
+        .compilesWithoutError().and().generatesSources(generated);
   }
 
   @Test
@@ -224,14 +207,14 @@ public void compilesKind3() {
         "import javax.annotation.processing.Generated;",
 
         "@Generated(\"com.github.tonivade.purefun.processor.HigherKindProcessor\")",
-        "public sealed interface FooOf<A, B, C> extends Kind<Kind<Kind<Foo_, A>, B>, C> permits Foo {",
+        "public sealed interface FooOf<A, B, C> extends Kind<Kind<Kind<Foo<?, ?, ?>, A>, B>, C> permits Foo {",
 
         "@SuppressWarnings(\"unchecked\")",
-        "static <A, B, C> Foo<A, B, C> narrowK(Kind<Kind<Kind<Foo_, A>, B>, ? extends C> hkt) {",
+        "static <A, B, C> Foo<A, B, C> narrowK(Kind<Kind<Kind<Foo<?, ?, ?>, A>, B>, ? extends C> hkt) {",
         "return (Foo<A, B, C>) hkt;",
         "}",
 
-        "static <A, B, C> Function<Kind<Kind<Kind<Foo_, A>, B>, ? extends C>, Foo<A, B, C>> toFoo() {",
+        "static <A, B, C> Function<Kind<Kind<Kind<Foo<?, ?, ?>, A>, B>, ? extends C>, Foo<A, B, C>> toFoo() {",
         "return FooOf::narrowK;",
         "}",
 
@@ -239,6 +222,6 @@ public void compilesKind3() {
 
     assert_().about(javaSource()).that(file)
         .processedWith(new HigherKindProcessor())
-        .compilesWithoutError().and().generatesSources(generated, witness);
+        .compilesWithoutError().and().generatesSources(generated);
   }
 }
\ No newline at end of file
diff --git a/stream/src/main/java/com/github/tonivade/purefun/stream/Cons.java b/stream/src/main/java/com/github/tonivade/purefun/stream/Cons.java
index 4e6b1ecfb..f8f4e5b05 100644
--- a/stream/src/main/java/com/github/tonivade/purefun/stream/Cons.java
+++ b/stream/src/main/java/com/github/tonivade/purefun/stream/Cons.java
@@ -124,7 +124,7 @@ public <R> PureStream<F, R> mapEval(Function1<? super T, ? extends Kind<F, ? ext
   }
 
   @Override
-  public <R> PureStream<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<PureStream_, F>, ? extends R>> map) {
+  public <R> PureStream<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<PureStream<?, ?>, F>, ? extends R>> map) {
     return suspendF(() ->
         monad.map(
             monad.map(head, map.andThen(PureStreamOf::<F, R>narrowK)),
diff --git a/stream/src/main/java/com/github/tonivade/purefun/stream/Nil.java b/stream/src/main/java/com/github/tonivade/purefun/stream/Nil.java
index c83b28c03..2d04b6a3d 100644
--- a/stream/src/main/java/com/github/tonivade/purefun/stream/Nil.java
+++ b/stream/src/main/java/com/github/tonivade/purefun/stream/Nil.java
@@ -112,7 +112,7 @@ public <R> PureStream<F, R> mapEval(Function1<? super T, ? extends Kind<F, ? ext
   }
 
   @Override
-  public <R> PureStream<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<PureStream_, F>, ? extends R>> map) {
+  public <R> PureStream<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<PureStream<?, ?>, F>, ? extends R>> map) {
     return new Nil<>(monad);
   }
 
diff --git a/stream/src/main/java/com/github/tonivade/purefun/stream/PureStream.java b/stream/src/main/java/com/github/tonivade/purefun/stream/PureStream.java
index 312d55d6b..7a729f1a3 100644
--- a/stream/src/main/java/com/github/tonivade/purefun/stream/PureStream.java
+++ b/stream/src/main/java/com/github/tonivade/purefun/stream/PureStream.java
@@ -31,7 +31,7 @@
 
 @HigherKind
 public sealed interface PureStream<F, T>
-  extends PureStreamOf<F, T>, Bindable<Kind<PureStream_, F>, T>
+  extends PureStreamOf<F, T>, Bindable<Kind<PureStream<?, ?>, F>, T>
     permits Cons, Suspend, Nil {
 
   default PureStream<F, T> head() {
@@ -68,9 +68,9 @@ <R> Kind<F, R> foldRight(Kind<F, ? extends R> begin,
   @Override
   <R> PureStream<F, R> map(Function1<? super T, ? extends R> map);
   @Override
-  <R> PureStream<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<PureStream_, F>, ? extends R>> map);
+  <R> PureStream<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<PureStream<?, ?>, F>, ? extends R>> map);
   @Override
-  default <R> PureStream<F, R> andThen(Kind<Kind<PureStream_, F>, ? extends R> next) {
+  default <R> PureStream<F, R> andThen(Kind<Kind<PureStream<?, ?>, F>, ? extends R> next) {
     return flatMap(ignore -> next);
   }
 
diff --git a/stream/src/main/java/com/github/tonivade/purefun/stream/Suspend.java b/stream/src/main/java/com/github/tonivade/purefun/stream/Suspend.java
index 4eb314e4c..ed254c142 100644
--- a/stream/src/main/java/com/github/tonivade/purefun/stream/Suspend.java
+++ b/stream/src/main/java/com/github/tonivade/purefun/stream/Suspend.java
@@ -114,7 +114,7 @@ public <R> PureStream<F, R> mapEval(Function1<? super T, ? extends Kind<F, ? ext
   }
 
   @Override
-  public <R> PureStream<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<PureStream_, F>, ? extends R>> map) {
+  public <R> PureStream<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<PureStream<?, ?>, F>, ? extends R>> map) {
     return lazyMap(s -> s.flatMap(map));
   }
 
diff --git a/stream/src/test/java/com/github/tonivade/purefun/stream/PureStreamTest.java b/stream/src/test/java/com/github/tonivade/purefun/stream/PureStreamTest.java
index e00275742..a18f0c606 100644
--- a/stream/src/test/java/com/github/tonivade/purefun/stream/PureStreamTest.java
+++ b/stream/src/test/java/com/github/tonivade/purefun/stream/PureStreamTest.java
@@ -26,34 +26,29 @@
 import com.github.tonivade.purefun.core.Tuple2;
 import com.github.tonivade.purefun.data.Sequence;
 import com.github.tonivade.purefun.effect.EIO;
-import com.github.tonivade.purefun.effect.EIO_;
 import com.github.tonivade.purefun.effect.Task;
-import com.github.tonivade.purefun.effect.Task_;
 import com.github.tonivade.purefun.effect.UIO;
-import com.github.tonivade.purefun.effect.UIO_;
 import com.github.tonivade.purefun.effect.URIO;
 import com.github.tonivade.purefun.effect.PureIO;
-import com.github.tonivade.purefun.effect.PureIO_;
 import com.github.tonivade.purefun.instances.PureStreamInstances;
 import com.github.tonivade.purefun.monad.IO;
-import com.github.tonivade.purefun.monad.IO_;
 import com.github.tonivade.purefun.stream.PureStream.Of;
 import com.github.tonivade.purefun.type.Option;
 
 public class PureStreamTest {
 
-  private final Of<IO_> streamOfIO = PureStreamInstances.ofIO();
-  private final Of<UIO_> streamOfUIO = PureStreamInstances.ofUIO();
-  private final Of<Task_> streamOfTask = PureStreamInstances.ofTask();
-  private final Of<Kind<EIO_, Throwable>> streamOfEIO = PureStreamInstances.ofEIO();
-  private final Of<Kind<Kind<PureIO_, Void>, Throwable>> streamOfPureIO = PureStreamInstances.ofPureIO();
+  private final Of<IO<?>> streamOfIO = PureStreamInstances.ofIO();
+  private final Of<UIO<?>> streamOfUIO = PureStreamInstances.ofUIO();
+  private final Of<Task<?>> streamOfTask = PureStreamInstances.ofTask();
+  private final Of<Kind<EIO<?, ?>, Throwable>> streamOfEIO = PureStreamInstances.ofEIO();
+  private final Of<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>> streamOfPureIO = PureStreamInstances.ofPureIO();
 
   @Test
   public void map() {
-    PureStream<IO_, String> pure1 = PureStream.pure("hola");
-    PureStream<IO_, String> pure2 = PureStream.pure(" mundo");
+    PureStream<IO<?>, String> pure1 = PureStream.pure("hola");
+    PureStream<IO<?>, String> pure2 = PureStream.pure(" mundo");
 
-    PureStream<IO_, String> result = pure1.concat(pure2).map(String::toUpperCase);
+    PureStream<IO<?>, String> result = pure1.concat(pure2).map(String::toUpperCase);
 
     IO<String> foldRight = result.foldRight(IO.pure(""), (a, b) -> b.fix(toIO()).map(x -> x + a))
         .fix(toIO());
@@ -63,10 +58,10 @@ public void map() {
 
   @Test
   public void flatMap() {
-    PureStream<IO_, String> pure1 = PureStream.pure("hola");
-    PureStream<IO_, String> pure2 = PureStream.pure(" mundo");
+    PureStream<IO<?>, String> pure1 = PureStream.pure("hola");
+    PureStream<IO<?>, String> pure2 = PureStream.pure(" mundo");
 
-    PureStream<IO_, String> result = pure1.concat(pure2).flatMap(string -> PureStream.pure(string.toUpperCase()));
+    PureStream<IO<?>, String> result = pure1.concat(pure2).flatMap(string -> PureStream.pure(string.toUpperCase()));
 
     IO<String> foldLeft = result.asString().fix(toIO());
 
@@ -75,115 +70,115 @@ public void flatMap() {
 
   @Test
   public void mapEval() {
-    PureStream<IO_, Integer> stream = PureStream.from(listOf(1, 2, 3));
+    PureStream<IO<?>, Integer> stream = PureStream.from(listOf(1, 2, 3));
 
-    PureStream<IO_, Integer> result = stream.mapEval(i -> IO.task(() -> i * 2));
+    PureStream<IO<?>, Integer> result = stream.mapEval(i -> IO.task(() -> i * 2));
 
     assertEquals(Integer.valueOf(12), run(result.foldLeft(0, Integer::sum)));
   }
 
   @Test
   public void append() {
-    PureStream<IO_, Integer> stream = PureStream.from(listOf(1, 2, 3));
+    PureStream<IO<?>, Integer> stream = PureStream.from(listOf(1, 2, 3));
 
-    PureStream<IO_, Integer> result = stream.append(IO.pure(4));
+    PureStream<IO<?>, Integer> result = stream.append(IO.pure(4));
 
     assertEquals(listOf(1, 2, 3, 4), run(result.asSequence()));
   }
 
   @Test
   public void prepend() {
-    PureStream<IO_, Integer> stream = PureStream.from(listOf(1, 2, 3));
+    PureStream<IO<?>, Integer> stream = PureStream.from(listOf(1, 2, 3));
 
-    PureStream<IO_, Integer> result = stream.prepend(IO.pure(0));
+    PureStream<IO<?>, Integer> result = stream.prepend(IO.pure(0));
 
     assertEquals(listOf(0, 1, 2, 3), run(result.asSequence()));
   }
 
   @Test
   public void take() {
-    PureStream<IO_, Integer> stream = PureStream.from(listOf(1, 2, 3));
+    PureStream<IO<?>, Integer> stream = PureStream.from(listOf(1, 2, 3));
 
-    PureStream<IO_, Integer> result = stream.take(2);
+    PureStream<IO<?>, Integer> result = stream.take(2);
 
     assertEquals(listOf(1, 2), run(result.asSequence()));
   }
 
   @Test
   public void drop() {
-    PureStream<IO_, Integer> stream = PureStream.from(listOf(1, 2, 3));
+    PureStream<IO<?>, Integer> stream = PureStream.from(listOf(1, 2, 3));
 
-    PureStream<IO_, Integer> result = stream.drop(2);
+    PureStream<IO<?>, Integer> result = stream.drop(2);
 
     assertEquals(listOf(3), run(result.asSequence()));
   }
 
   @Test
   public void takeWhile() {
-    PureStream<IO_, Integer> stream = PureStream.from(listOf(1, 2, 3, 4, 5));
+    PureStream<IO<?>, Integer> stream = PureStream.from(listOf(1, 2, 3, 4, 5));
 
-    PureStream<IO_, Integer> result = stream.takeWhile(t -> t < 4);
+    PureStream<IO<?>, Integer> result = stream.takeWhile(t -> t < 4);
 
     assertEquals(listOf(1, 2, 3), run(result.asSequence()));
   }
 
   @Test
   public void dropWhile() {
-    PureStream<IO_, Integer> stream = PureStream.from(listOf(1, 2, 3, 4, 5));
+    PureStream<IO<?>, Integer> stream = PureStream.from(listOf(1, 2, 3, 4, 5));
 
-    PureStream<IO_, Integer> result = stream.dropWhile(t -> t < 4);
+    PureStream<IO<?>, Integer> result = stream.dropWhile(t -> t < 4);
 
     assertEquals(listOf(4, 5), run(result.asSequence()));
   }
 
   @Test
   public void filter() {
-    PureStream<IO_, Integer> stream = PureStream.from(java.util.stream.Stream.of(1, 2, 3, 4, 5));
+    PureStream<IO<?>, Integer> stream = PureStream.from(java.util.stream.Stream.of(1, 2, 3, 4, 5));
 
-    PureStream<IO_, Integer> result = stream.filter(t -> (t % 2) == 0);
+    PureStream<IO<?>, Integer> result = stream.filter(t -> (t % 2) == 0);
 
     assertEquals(listOf(2, 4), run(result.asSequence()));
   }
 
   @Test
   public void collect() {
-    PureStream<IO_, Integer> stream = PureStream.of(IO_.class).of(1, 2, 3, 4, 5);
+    PureStream<IO<?>, Integer> stream = PureStream.<IO<?>>of().of(1, 2, 3, 4, 5);
 
-    PureStream<IO_, Integer> result = stream.collect(PartialFunction1.of(t -> (t % 2) == 0, x -> x * 2));
+    PureStream<IO<?>, Integer> result = stream.collect(PartialFunction1.of(t -> (t % 2) == 0, x -> x * 2));
 
     assertEquals(listOf(4, 8), run(result.asSequence()));
   }
 
   @Test
   public void iterate() {
-    PureStream<IO_, Integer> stream = PureStream.iterate(0, i -> i + 1);
+    PureStream<IO<?>, Integer> stream = PureStream.iterate(0, i -> i + 1);
 
-    PureStream<IO_, Integer> result = stream.takeWhile(t -> t < 4).dropWhile(t -> t < 2);
+    PureStream<IO<?>, Integer> result = stream.takeWhile(t -> t < 4).dropWhile(t -> t < 2);
 
     assertEquals(listOf(2, 3), run(result.asSequence()));
   }
 
   @Test
   public void repeat() {
-    PureStream<IO_, Integer> stream = PureStream.<IO_>of().of(1, 2, 3);
+    PureStream<IO<?>, Integer> stream = PureStream.<IO<?>>of().of(1, 2, 3);
 
-    PureStream<IO_, Integer> result = stream.repeat().take(7);
+    PureStream<IO<?>, Integer> result = stream.repeat().take(7);
 
     assertEquals(listOf(1, 2, 3, 1, 2, 3, 1), run(result.asSequence()));
   }
 
   @Test
   public void intersperse() {
-    PureStream<IO_, Integer> stream = PureStream.<IO_>of().of(1, 2);
+    PureStream<IO<?>, Integer> stream = PureStream.<IO<?>>of().of(1, 2);
 
-    PureStream<IO_, Integer> result = stream.intersperse(IO.pure(0));
+    PureStream<IO<?>, Integer> result = stream.intersperse(IO.pure(0));
 
     assertEquals(listOf(1, 0, 2, 0), run(result.asSequence()));
   }
 
   @Test
   public void zip() {
-    PureStream<IO_, String> stream = PureStream.from(listOf("a", "b", "c"));
+    PureStream<IO<?>, String> stream = PureStream.from(listOf("a", "b", "c"));
 
     IO<Sequence<Tuple2<String, Integer>>> zip = PureStream.zipWithIndex(stream).asSequence().fix(toIO());
 
@@ -192,20 +187,20 @@ public void zip() {
 
   @Test
   public void merge() {
-    PureStream<IO_, Integer> stream1 = PureStream.<IO_>of().of(1, 2, 3);
-    PureStream<IO_, Integer> stream2 = PureStream.<IO_>of().of(4, 5, 6, 7);
+    PureStream<IO<?>, Integer> stream1 = PureStream.<IO<?>>of().of(1, 2, 3);
+    PureStream<IO<?>, Integer> stream2 = PureStream.<IO<?>>of().of(4, 5, 6, 7);
 
-    PureStream<IO_, Integer> merge = PureStream.merge(stream1, stream2);
+    PureStream<IO<?>, Integer> merge = PureStream.merge(stream1, stream2);
 
     assertEquals(listOf(1, 4, 2, 5, 3, 6), run(merge.asSequence()));
   }
 
   @Test
   public void forAll() {
-    PureStream<IO_, String> stream = PureStream.from(listOf("a", "b", "c"));
+    PureStream<IO<?>, String> stream = PureStream.from(listOf("a", "b", "c"));
 
-    Kind<IO_, Boolean> all = stream.exists(x -> x.toLowerCase().equals(x));
-    Kind<IO_, Boolean> notAll = stream.exists(x -> x.toUpperCase().equals(x));
+    Kind<IO<?>, Boolean> all = stream.exists(x -> x.toLowerCase().equals(x));
+    Kind<IO<?>, Boolean> notAll = stream.exists(x -> x.toUpperCase().equals(x));
 
     assertTrue(run(all));
     assertFalse(run(notAll));
@@ -213,10 +208,10 @@ public void forAll() {
 
   @Test
   public void exists() {
-    PureStream<IO_, String> stream = PureStream.from(listOf("a", "b", "c"));
+    PureStream<IO<?>, String> stream = PureStream.from(listOf("a", "b", "c"));
 
-    Kind<IO_, Boolean> exists = stream.exists(x -> "c".equals(x));
-    Kind<IO_, Boolean> notExists = stream.exists(x -> "z".equals(x));
+    Kind<IO<?>, Boolean> exists = stream.exists(x -> "c".equals(x));
+    Kind<IO<?>, Boolean> notExists = stream.exists(x -> "z".equals(x));
 
     assertTrue(run(exists));
     assertFalse(run(notExists));
@@ -298,7 +293,7 @@ public void readFileAsync() {
 
   @Test
   public void test() {
-    PureStream<IO_, Integer> stream = streamOfIO.from(listOf("a", "b", "c")).mapReplace(IO.pure(1));
+    PureStream<IO<?>, Integer> stream = streamOfIO.from(listOf("a", "b", "c")).mapReplace(IO.pure(1));
 
     assertEquals("111", stream.asString().fix(toIO()).unsafeRunSync());
   }
@@ -386,7 +381,7 @@ private BufferedReader reader(String file) {
     }
   }
 
-  private static <T> T run(Kind<IO_, T> effect) {
+  private static <T> T run(Kind<IO<?>, T> effect) {
     return effect.fix(toIO()).unsafeRunSync();
   }
 }
diff --git a/transformer/src/main/java/com/github/tonivade/purefun/transformer/EitherT.java b/transformer/src/main/java/com/github/tonivade/purefun/transformer/EitherT.java
index 42d8a3db1..dd895cbd1 100644
--- a/transformer/src/main/java/com/github/tonivade/purefun/transformer/EitherT.java
+++ b/transformer/src/main/java/com/github/tonivade/purefun/transformer/EitherT.java
@@ -22,7 +22,7 @@
 import com.github.tonivade.purefun.typeclasses.Monad;
 
 @HigherKind
-public non-sealed interface EitherT<F, L, R> extends EitherTOf<F, L, R>, Bindable<Kind<Kind<EitherT_, F>, L>, R> {
+public non-sealed interface EitherT<F, L, R> extends EitherTOf<F, L, R>, Bindable<Kind<Kind<EitherT<?, ?, ?>, F>, L>, R> {
 
   Monad<F> monad();
   Kind<F, Either<L, R>> value();
@@ -33,7 +33,7 @@ default <V> EitherT<F, L, V> map(Function1<? super R, ? extends V> map) {
   }
 
   @Override
-  default <V> EitherT<F, L, V> flatMap(Function1<? super R, ? extends Kind<Kind<Kind<EitherT_, F>, L>, ? extends V>> map) {
+  default <V> EitherT<F, L, V> flatMap(Function1<? super R, ? extends Kind<Kind<Kind<EitherT<?, ?, ?>, F>, L>, ? extends V>> map) {
     return EitherT.of(monad(), flatMapF(v -> map.andThen(EitherTOf::<F, L, V>narrowK).apply(v).value()));
   }
 
diff --git a/transformer/src/main/java/com/github/tonivade/purefun/transformer/Kleisli.java b/transformer/src/main/java/com/github/tonivade/purefun/transformer/Kleisli.java
index 3b5f84c03..fa3c0549f 100644
--- a/transformer/src/main/java/com/github/tonivade/purefun/transformer/Kleisli.java
+++ b/transformer/src/main/java/com/github/tonivade/purefun/transformer/Kleisli.java
@@ -14,7 +14,7 @@
 import com.github.tonivade.purefun.typeclasses.Monad;
 
 @HigherKind
-public non-sealed interface Kleisli<F, Z, A> extends KleisliOf<F, Z, A>, Bindable<Kind<Kind<Kleisli_, F>, Z>, A> {
+public non-sealed interface Kleisli<F, Z, A> extends KleisliOf<F, Z, A>, Bindable<Kind<Kind<Kleisli<?, ?, ?>, F>, Z>, A> {
 
   Monad<F> monad();
   Kind<F, A> run(Z value);
@@ -25,7 +25,7 @@ default <R> Kleisli<F, Z, R> map(Function1<? super A, ? extends R> map) {
   }
 
   @Override
-  default <R> Kleisli<F, Z, R> flatMap(Function1<? super A, ? extends Kind<Kind<Kind<Kleisli_, F>, Z>, ? extends R>> map) {
+  default <R> Kleisli<F, Z, R> flatMap(Function1<? super A, ? extends Kind<Kind<Kind<Kleisli<?, ?, ?>, F>, Z>, ? extends R>> map) {
     return Kleisli.of(monad(), value -> monad().flatMap(run(value), a -> map.andThen(KleisliOf::<F, Z, R>narrowK).apply(a).run(value)));
   }
 
diff --git a/transformer/src/main/java/com/github/tonivade/purefun/transformer/OptionT.java b/transformer/src/main/java/com/github/tonivade/purefun/transformer/OptionT.java
index 90964ae1f..edc5f6c3d 100644
--- a/transformer/src/main/java/com/github/tonivade/purefun/transformer/OptionT.java
+++ b/transformer/src/main/java/com/github/tonivade/purefun/transformer/OptionT.java
@@ -20,7 +20,7 @@
 import com.github.tonivade.purefun.typeclasses.Monad;
 
 @HigherKind
-public non-sealed interface OptionT<F, T> extends OptionTOf<F, T>, Bindable<Kind<OptionT_, F>, T> {
+public non-sealed interface OptionT<F, T> extends OptionTOf<F, T>, Bindable<Kind<OptionT<?, ?>, F>, T> {
 
   Monad<F> monad();
   Kind<F, Option<T>> value();
@@ -31,7 +31,7 @@ default <R> OptionT<F, R> map(Function1<? super T, ? extends R> map) {
   }
 
   @Override
-  default <R> OptionT<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<OptionT_, F>, ? extends R>> map) {
+  default <R> OptionT<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<OptionT<?, ?>, F>, ? extends R>> map) {
     return OptionT.of(monad(), flatMapF(v -> map.andThen(OptionTOf::<F, R>narrowK).apply(v).value()));
   }
 
diff --git a/transformer/src/main/java/com/github/tonivade/purefun/transformer/StateT.java b/transformer/src/main/java/com/github/tonivade/purefun/transformer/StateT.java
index a20713f9c..3da60ff32 100644
--- a/transformer/src/main/java/com/github/tonivade/purefun/transformer/StateT.java
+++ b/transformer/src/main/java/com/github/tonivade/purefun/transformer/StateT.java
@@ -21,7 +21,7 @@
 import com.github.tonivade.purefun.typeclasses.Monad;
 
 @HigherKind
-public non-sealed interface StateT<F, S, A> extends StateTOf<F, S, A>, Bindable<Kind<Kind<StateT_, F>, S>, A> {
+public non-sealed interface StateT<F, S, A> extends StateTOf<F, S, A>, Bindable<Kind<Kind<StateT<?, ?, ?>, F>, S>, A> {
 
   Monad<F> monad();
   Kind<F, Tuple2<S, A>> run(S state);
@@ -36,7 +36,7 @@ default <R> StateT<F, S, R> map(Function1<? super A, ? extends R> map) {
   }
 
   @Override
-  default <R> StateT<F, S, R> flatMap(Function1<? super A, ? extends Kind<Kind<Kind<StateT_, F>, S>, ? extends R>> map) {
+  default <R> StateT<F, S, R> flatMap(Function1<? super A, ? extends Kind<Kind<Kind<StateT<?, ?, ?>, F>, S>, ? extends R>> map) {
     return state(monad(), state -> {
       Kind<F, Tuple2<S, A>> newState = run(state);
       return monad().flatMap(newState, state2 -> map.andThen(StateTOf::<F, S, R>narrowK).apply(state2.get2()).run(state2.get1()));
diff --git a/transformer/src/main/java/com/github/tonivade/purefun/transformer/WriterT.java b/transformer/src/main/java/com/github/tonivade/purefun/transformer/WriterT.java
index 1a0b66bdf..063094105 100644
--- a/transformer/src/main/java/com/github/tonivade/purefun/transformer/WriterT.java
+++ b/transformer/src/main/java/com/github/tonivade/purefun/transformer/WriterT.java
@@ -20,7 +20,7 @@
 import com.github.tonivade.purefun.typeclasses.Monoid;
 
 @HigherKind
-public non-sealed interface WriterT<F, L, A> extends WriterTOf<F, L, A>, Bindable<Kind<Kind<WriterT_, F>, L>, A> {
+public non-sealed interface WriterT<F, L, A> extends WriterTOf<F, L, A>, Bindable<Kind<Kind<WriterT<?, ?, ?>, F>, L>, A> {
 
   Monoid<L> monoid();
   Monad<F> monad();
@@ -66,7 +66,7 @@ default <G> WriterT<G, L, A> mapK(Monad<G> monadG, FunctionK<F, G> functionK) {
   }
 
   @Override
-  default <R> WriterT<F, L, R> flatMap(Function1<? super A, ? extends Kind<Kind<Kind<WriterT_, F>, L>, ? extends R>> mapper) {
+  default <R> WriterT<F, L, R> flatMap(Function1<? super A, ? extends Kind<Kind<Kind<WriterT<?, ?, ?>, F>, L>, ? extends R>> mapper) {
     return writer(monoid(), monad(),
         monad().flatMap(value(),
             current -> monad().map(mapper.andThen(WriterTOf::<F, L, R>narrowK).apply(current.get2()).value(),
diff --git a/transformer/src/test/java/com/github/tonivade/purefun/transformer/EitherTTest.java b/transformer/src/test/java/com/github/tonivade/purefun/transformer/EitherTTest.java
index 5906128ac..de873c43d 100644
--- a/transformer/src/test/java/com/github/tonivade/purefun/transformer/EitherTTest.java
+++ b/transformer/src/test/java/com/github/tonivade/purefun/transformer/EitherTTest.java
@@ -10,60 +10,60 @@
 import static com.github.tonivade.purefun.transformer.EitherTOf.toEitherT;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import org.junit.jupiter.api.Test;
+
 import com.github.tonivade.purefun.Kind;
-import com.github.tonivade.purefun.concurrent.Future_;
+import com.github.tonivade.purefun.concurrent.Future;
 import com.github.tonivade.purefun.core.Unit;
 import com.github.tonivade.purefun.instances.EitherTInstances;
 import com.github.tonivade.purefun.instances.FutureInstances;
 import com.github.tonivade.purefun.instances.IOInstances;
 import com.github.tonivade.purefun.instances.IdInstances;
 import com.github.tonivade.purefun.instances.TryInstances;
-import com.github.tonivade.purefun.monad.IO_;
+import com.github.tonivade.purefun.monad.IO;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.type.Id;
-import com.github.tonivade.purefun.type.Id_;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.type.TryOf;
-import com.github.tonivade.purefun.type.Try_;
 import com.github.tonivade.purefun.typeclasses.Monad;
 import com.github.tonivade.purefun.typeclasses.MonadError;
 
 public class EitherTTest {
 
-  private final Monad<Id_> monad = IdInstances.monad();
+  private final Monad<Id<?>> monad = IdInstances.monad();
 
   @Test
   public void map() {
-    EitherT<Id_, Void, String> right = EitherT.right(monad, "abc");
+    EitherT<Id<?>, Void, String> right = EitherT.right(monad, "abc");
 
-    EitherT<Id_, Void, String> map = right.map(String::toUpperCase);
+    EitherT<Id<?>, Void, String> map = right.map(String::toUpperCase);
 
     assertEquals(Id.of("ABC"), map.get());
   }
 
   @Test
   public void flatMap() {
-    EitherT<Id_, Void, String> right = EitherT.right(monad, "abc");
+    EitherT<Id<?>, Void, String> right = EitherT.right(monad, "abc");
 
-    EitherT<Id_, Void, String> map = right.flatMap(value -> EitherT.right(monad, value.toUpperCase()));
+    EitherT<Id<?>, Void, String> map = right.flatMap(value -> EitherT.right(monad, value.toUpperCase()));
 
     assertEquals(Id.of("ABC"), map.get());
   }
 
   @Test
   public void filterOrElse() {
-    EitherT<Id_, Void, String> right = EitherT.right(monad, "abc");
+    EitherT<Id<?>, Void, String> right = EitherT.right(monad, "abc");
 
-    EitherT<Id_, Void, String> filter = right.filterOrElse(String::isEmpty, cons(Either.right("not empty")));
-    EitherT<Id_, Void, String> orElse = EitherT.right(monad, "not empty");
+    EitherT<Id<?>, Void, String> filter = right.filterOrElse(String::isEmpty, cons(Either.right("not empty")));
+    EitherT<Id<?>, Void, String> orElse = EitherT.right(monad, "not empty");
 
     assertEquals(orElse.get(), filter.getOrElse("not empty"));
   }
 
   @Test
   public void left() {
-    EitherT<Id_, Unit, String> left = EitherT.left(monad, unit());
+    EitherT<Id<?>, Unit, String> left = EitherT.left(monad, unit());
 
     assertAll(
         () -> assertEquals(Id.of(true), left.isLeft()),
@@ -73,7 +73,7 @@ public void left() {
 
   @Test
   public void right() {
-    EitherT<Id_, Void, String> right = EitherT.right(monad, "abc");
+    EitherT<Id<?>, Void, String> right = EitherT.right(monad, "abc");
 
     assertAll(
         () -> assertEquals(Id.of(false), right.isLeft()),
@@ -83,9 +83,9 @@ public void right() {
 
   @Test
   public void mapK() {
-    EitherT<IO_, Void, String> rightIo = EitherT.right(IOInstances.monad(), "abc");
+    EitherT<IO<?>, Void, String> rightIo = EitherT.right(IOInstances.monad(), "abc");
 
-    EitherT<Try_, Void, String> rightTry = rightIo.mapK(TryInstances.monad(), new IOToTryFunctionK());
+    EitherT<Try<?>, Void, String> rightTry = rightIo.mapK(TryInstances.monad(), new IOToTryFunctionK());
 
     assertEquals(Try.success("abc"), TryOf.narrowK(rightTry.get()));
   }
@@ -93,16 +93,16 @@ public void mapK() {
   @Test
   public void monadErrorFuture() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<Kind<Kind<EitherT_, Future_>, Throwable>, Throwable> monadError =
+    MonadError<Kind<Kind<EitherT<?, ?, ?>, Future<?>>, Throwable>, Throwable> monadError =
         EitherTInstances.monadError(FutureInstances.monadError());
 
-    Kind<Kind<Kind<EitherT_, Future_>, Throwable>, String> pure = monadError.pure("is not ok");
-    Kind<Kind<Kind<EitherT_, Future_>, Throwable>, String> raiseError = monadError.raiseError(error);
-    Kind<Kind<Kind<EitherT_, Future_>, Throwable>, String> handleError =
+    Kind<Kind<Kind<EitherT<?, ?, ?>, Future<?>>, Throwable>, String> pure = monadError.pure("is not ok");
+    Kind<Kind<Kind<EitherT<?, ?, ?>, Future<?>>, Throwable>, String> raiseError = monadError.raiseError(error);
+    Kind<Kind<Kind<EitherT<?, ?, ?>, Future<?>>, Throwable>, String> handleError =
         monadError.handleError(raiseError, e -> "not an error");
-    Kind<Kind<Kind<EitherT_, Future_>, Throwable>, String> ensureOk =
+    Kind<Kind<Kind<EitherT<?, ?, ?>, Future<?>>, Throwable>, String> ensureOk =
         monadError.ensure(pure, () -> error, value -> "is not ok".equals(value));
-    Kind<Kind<Kind<EitherT_, Future_>, Throwable>, String> ensureError =
+    Kind<Kind<Kind<EitherT<?, ?, ?>, Future<?>>, Throwable>, String> ensureError =
         monadError.ensure(pure, () -> error, value -> "is ok?".equals(value));
 
     assertAll(
@@ -115,16 +115,16 @@ public void monadErrorFuture() {
   @Test
   public void monadErrorIO() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<Kind<Kind<EitherT_, Id_>, Throwable>, Throwable> monadError =
+    MonadError<Kind<Kind<EitherT<?, ?, ?>, Id<?>>, Throwable>, Throwable> monadError =
         EitherTInstances.monadError(monad);
 
-    Kind<Kind<Kind<EitherT_, Id_>, Throwable>, String> pure = monadError.pure("is not ok");
-    Kind<Kind<Kind<EitherT_, Id_>, Throwable>, String> raiseError = monadError.raiseError(error);
-    Kind<Kind<Kind<EitherT_, Id_>, Throwable>, String> handleError =
+    Kind<Kind<Kind<EitherT<?, ?, ?>, Id<?>>, Throwable>, String> pure = monadError.pure("is not ok");
+    Kind<Kind<Kind<EitherT<?, ?, ?>, Id<?>>, Throwable>, String> raiseError = monadError.raiseError(error);
+    Kind<Kind<Kind<EitherT<?, ?, ?>, Id<?>>, Throwable>, String> handleError =
         monadError.handleError(raiseError, e -> "not an error");
-    Kind<Kind<Kind<EitherT_, Id_>, Throwable>, String> ensureOk =
+    Kind<Kind<Kind<EitherT<?, ?, ?>, Id<?>>, Throwable>, String> ensureOk =
         monadError.ensure(pure, () -> error, "is not ok"::equals);
-    Kind<Kind<Kind<EitherT_, Id_>, Throwable>, String> ensureError =
+    Kind<Kind<Kind<EitherT<?, ?, ?>, Id<?>>, Throwable>, String> ensureError =
         monadError.ensure(pure, () -> error, "is ok?"::equals);
 
     assertAll(
diff --git a/transformer/src/test/java/com/github/tonivade/purefun/transformer/KleisliTest.java b/transformer/src/test/java/com/github/tonivade/purefun/transformer/KleisliTest.java
index 2ff97a567..0c394b52f 100644
--- a/transformer/src/test/java/com/github/tonivade/purefun/transformer/KleisliTest.java
+++ b/transformer/src/test/java/com/github/tonivade/purefun/transformer/KleisliTest.java
@@ -11,26 +11,25 @@
 import com.github.tonivade.purefun.core.Tuple2;
 import com.github.tonivade.purefun.instances.TryInstances;
 import com.github.tonivade.purefun.type.Try;
-import com.github.tonivade.purefun.type.Try_;
 
 public class KleisliTest {
 
   @Test
   public void compose() {
-    Kleisli<Try_, String, Integer> toInt = Kleisli.lift(TryInstances.monad(), Integer::parseInt);
-    Kleisli<Try_, Integer, Double> half = Kleisli.lift(TryInstances.monad(), i -> i / 2.);
+    Kleisli<Try<?>, String, Integer> toInt = Kleisli.lift(TryInstances.monad(), Integer::parseInt);
+    Kleisli<Try<?>, Integer, Double> half = Kleisli.lift(TryInstances.monad(), i -> i / 2.);
 
-    Kind<Try_, Double> result = toInt.compose(half).run("123");
+    Kind<Try<?>, Double> result = toInt.compose(half).run("123");
 
     assertEquals(Try.success(61.5), result);
   }
 
   @Test
   public void flatMap() {
-    Kleisli<Try_, String, Integer> toInt = Kleisli.lift(TryInstances.monad(), Integer::parseInt);
-    Kleisli<Try_, String, Double> toDouble = Kleisli.lift(TryInstances.monad(), Double::parseDouble);
+    Kleisli<Try<?>, String, Integer> toInt = Kleisli.lift(TryInstances.monad(), Integer::parseInt);
+    Kleisli<Try<?>, String, Double> toDouble = Kleisli.lift(TryInstances.monad(), Double::parseDouble);
 
-    Kleisli<Try_, String, Tuple2<Integer, Double>> flatMap =
+    Kleisli<Try<?>, String, Tuple2<Integer, Double>> flatMap =
         toInt.flatMap(integer -> toDouble.map(double_ -> Tuple.of(integer, double_)));
 
     assertEquals(Try.success(Tuple.of(123, 123.)), flatMap.run("123"));
diff --git a/transformer/src/test/java/com/github/tonivade/purefun/transformer/OptionTTest.java b/transformer/src/test/java/com/github/tonivade/purefun/transformer/OptionTTest.java
index 6e9285567..3eff089ff 100644
--- a/transformer/src/test/java/com/github/tonivade/purefun/transformer/OptionTTest.java
+++ b/transformer/src/test/java/com/github/tonivade/purefun/transformer/OptionTTest.java
@@ -14,7 +14,7 @@
 
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.concurrent.FutureOf;
-import com.github.tonivade.purefun.concurrent.Future_;
+import com.github.tonivade.purefun.concurrent.Future;
 import com.github.tonivade.purefun.core.Eq;
 import com.github.tonivade.purefun.core.Unit;
 import com.github.tonivade.purefun.instances.FutureInstances;
@@ -22,52 +22,50 @@
 import com.github.tonivade.purefun.instances.IdInstances;
 import com.github.tonivade.purefun.instances.OptionTInstances;
 import com.github.tonivade.purefun.instances.TryInstances;
-import com.github.tonivade.purefun.monad.IO_;
+import com.github.tonivade.purefun.monad.IO;
 import com.github.tonivade.purefun.type.Id;
-import com.github.tonivade.purefun.type.Id_;
 import com.github.tonivade.purefun.type.Option;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.type.TryOf;
-import com.github.tonivade.purefun.type.Try_;
 import com.github.tonivade.purefun.typeclasses.FunctionK;
 import com.github.tonivade.purefun.typeclasses.Monad;
 import com.github.tonivade.purefun.typeclasses.MonadError;
 
 public class OptionTTest {
 
-  private final Monad<Id_> monad = IdInstances.monad();
+  private final Monad<Id<?>> monad = IdInstances.monad();
 
   @Test
   public void map() {
-    OptionT<Id_, String> some = OptionT.some(monad, "abc");
+    OptionT<Id<?>, String> some = OptionT.some(monad, "abc");
 
-    OptionT<Id_, String> map = some.map(String::toUpperCase);
+    OptionT<Id<?>, String> map = some.map(String::toUpperCase);
 
     assertEquals(Id.of("ABC"), map.getOrElseThrow());
   }
 
   @Test
   public void flatMap() {
-    OptionT<Id_, String> some = OptionT.some(monad, "abc");
+    OptionT<Id<?>, String> some = OptionT.some(monad, "abc");
 
-    OptionT<Id_, String> map = some.flatMap(value -> OptionT.some(monad, value.toUpperCase()));
+    OptionT<Id<?>, String> map = some.flatMap(value -> OptionT.some(monad, value.toUpperCase()));
 
     assertEquals(Id.of("ABC"), map.getOrElseThrow());
   }
 
   @Test
   public void filter() {
-    OptionT<Id_, String> some = OptionT.some(monad, "abc");
+    OptionT<Id<?>, String> some = OptionT.some(monad, "abc");
 
-    OptionT<Id_, String> filter = some.filter(String::isEmpty);
-    OptionT<Id_, String> orElse = OptionT.some(monad, "not empty");
+    OptionT<Id<?>, String> filter = some.filter(String::isEmpty);
+    OptionT<Id<?>, String> orElse = OptionT.some(monad, "not empty");
 
     assertEquals(orElse.getOrElseThrow(), filter.getOrElse("not empty"));
   }
 
   @Test
   public void none() {
-    OptionT<Id_, String> none = OptionT.none(monad);
+    OptionT<Id<?>, String> none = OptionT.none(monad);
 
     assertAll(
         () -> assertEquals(Id.of(true), none.isEmpty()),
@@ -76,7 +74,7 @@ public void none() {
 
   @Test
   public void some() {
-    OptionT<Id_, String> some = OptionT.some(monad, "abc");
+    OptionT<Id<?>, String> some = OptionT.some(monad, "abc");
 
     assertAll(
         () -> assertEquals(Id.of(false), some.isEmpty()),
@@ -85,21 +83,21 @@ public void some() {
 
   @Test
   public void mapK() {
-    OptionT<IO_, String> someIo = OptionT.some(IOInstances.monad(), "abc");
+    OptionT<IO<?>, String> someIo = OptionT.some(IOInstances.monad(), "abc");
 
-    OptionT<Try_, String> someTry = someIo.mapK(TryInstances.monad(), new IOToTryFunctionK());
+    OptionT<Try<?>, String> someTry = someIo.mapK(TryInstances.monad(), new IOToTryFunctionK());
 
     assertEquals(Try.success("abc"), TryOf.narrowK(someTry.getOrElseThrow()));
   }
 
   @Test
   public void eq() {
-    OptionT<Id_, String> some1 = OptionT.some(monad, "abc");
-    OptionT<Id_, String> some2 = OptionT.some(monad, "abc");
-    OptionT<Id_, String> none1 = OptionT.none(monad);
-    OptionT<Id_, String> none2 = OptionT.none(monad);
+    OptionT<Id<?>, String> some1 = OptionT.some(monad, "abc");
+    OptionT<Id<?>, String> some2 = OptionT.some(monad, "abc");
+    OptionT<Id<?>, String> none1 = OptionT.none(monad);
+    OptionT<Id<?>, String> none2 = OptionT.none(monad);
 
-    Eq<Kind<Kind<OptionT_, Id_>, String>> instance = OptionTInstances.eq(IdInstances.eq(Eq.any()));
+    Eq<Kind<Kind<OptionT<?, ?>, Id<?>>, String>> instance = OptionTInstances.eq(IdInstances.eq(Eq.any()));
 
     assertAll(
         () -> assertTrue(instance.eqv(some1, some2)),
@@ -111,16 +109,16 @@ public void eq() {
   @Test
   public void monadErrorFuture() {
     RuntimeException error = new RuntimeException("error");
-    MonadError<Kind<OptionT_, Future_>, Throwable> monadError =
+    MonadError<Kind<OptionT<?, ?>, Future<?>>, Throwable> monadError =
         OptionTInstances.monadError(FutureInstances.monadError());
 
-    Kind<Kind<OptionT_, Future_>, String> pure = monadError.pure("is not ok");
-    Kind<Kind<OptionT_, Future_>, String> raiseError = monadError.raiseError(error);
-    Kind<Kind<OptionT_, Future_>, String> handleError =
+    Kind<Kind<OptionT<?, ?>, Future<?>>, String> pure = monadError.pure("is not ok");
+    Kind<Kind<OptionT<?, ?>, Future<?>>, String> raiseError = monadError.raiseError(error);
+    Kind<Kind<OptionT<?, ?>, Future<?>>, String> handleError =
         monadError.handleError(raiseError, e -> "not an error");
-    Kind<Kind<OptionT_, Future_>, String> ensureOk =
+    Kind<Kind<OptionT<?, ?>, Future<?>>, String> ensureOk =
         monadError.ensure(pure, () -> error, value -> "is not ok".equals(value));
-    Kind<Kind<OptionT_, Future_>, String> ensureError =
+    Kind<Kind<OptionT<?, ?>, Future<?>>, String> ensureError =
         monadError.ensure(pure, () -> error, value -> "is ok?".equals(value));
 
     assertAll(
@@ -132,15 +130,15 @@ public void monadErrorFuture() {
 
   @Test
   public void monadErrorIO() {
-    MonadError<Kind<OptionT_, Id_>, Unit> monadError = OptionTInstances.monadError(monad);
+    MonadError<Kind<OptionT<?, ?>, Id<?>>, Unit> monadError = OptionTInstances.monadError(monad);
 
-    Kind<Kind<OptionT_, Id_>, String> pure = monadError.pure("is not ok");
-    Kind<Kind<OptionT_, Id_>, String> raiseError = monadError.raiseError(unit());
-    Kind<Kind<OptionT_, Id_>, String> handleError =
+    Kind<Kind<OptionT<?, ?>, Id<?>>, String> pure = monadError.pure("is not ok");
+    Kind<Kind<OptionT<?, ?>, Id<?>>, String> raiseError = monadError.raiseError(unit());
+    Kind<Kind<OptionT<?, ?>, Id<?>>, String> handleError =
         monadError.handleError(raiseError, e -> "not an error");
-    Kind<Kind<OptionT_, Id_>, String> ensureOk =
+    Kind<Kind<OptionT<?, ?>, Id<?>>, String> ensureOk =
         monadError.ensure(pure, Unit::unit, "is not ok"::equals);
-    Kind<Kind<OptionT_, Id_>, String> ensureError =
+    Kind<Kind<OptionT<?, ?>, Id<?>>, String> ensureError =
         monadError.ensure(pure, Unit::unit, "is ok?"::equals);
 
     assertAll(
@@ -151,10 +149,10 @@ public void monadErrorIO() {
   }
 }
 
-class IOToTryFunctionK implements FunctionK<IO_, Try_> {
+class IOToTryFunctionK implements FunctionK<IO<?>, Try<?>> {
 
   @Override
-  public <T> Kind<Try_, T> apply(Kind<IO_, ? extends T> from) {
+  public <T> Kind<Try<?>, T> apply(Kind<IO<?>, ? extends T> from) {
     return Try.of(from.fix(toIO())::unsafeRunSync);
   }
 }
diff --git a/transformer/src/test/java/com/github/tonivade/purefun/transformer/StateTTest.java b/transformer/src/test/java/com/github/tonivade/purefun/transformer/StateTTest.java
index 3cfa1763f..7d2c94537 100644
--- a/transformer/src/test/java/com/github/tonivade/purefun/transformer/StateTTest.java
+++ b/transformer/src/test/java/com/github/tonivade/purefun/transformer/StateTTest.java
@@ -6,7 +6,9 @@
 
 import static com.github.tonivade.purefun.core.Unit.unit;
 import static com.github.tonivade.purefun.data.Sequence.listOf;
+import static com.github.tonivade.purefun.monad.IOOf.toIO;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import org.junit.jupiter.api.Test;
 
 import com.github.tonivade.purefun.Kind;
@@ -20,45 +22,42 @@
 import com.github.tonivade.purefun.instances.TryInstances;
 import com.github.tonivade.purefun.monad.IO;
 import com.github.tonivade.purefun.monad.IOOf;
-import static com.github.tonivade.purefun.monad.IOOf.toIO;
-import com.github.tonivade.purefun.monad.IO_;
 import com.github.tonivade.purefun.type.Option;
 import com.github.tonivade.purefun.type.Try;
 import com.github.tonivade.purefun.type.TryOf;
-import com.github.tonivade.purefun.type.Try_;
 import com.github.tonivade.purefun.typeclasses.Monad;
 
 public class StateTTest {
 
-  private Monad<IO_> monad = IOInstances.monad();
+  private Monad<IO<?>> monad = IOInstances.monad();
 
   @Test
   public void get() {
-    Kind<IO_, Tuple2<Object, Object>> run = StateT.get(monad).run("abc");
+    Kind<IO<?>, Tuple2<Object, Object>> run = StateT.get(monad).run("abc");
     assertEquals(Tuple.of("abc", "abc"), run.fix(toIO()).unsafeRunSync());
   }
 
   @Test
   public void set() {
-    Kind<IO_, Tuple2<String, Unit>> run = StateT.set(monad, "abc").run("zzz");
+    Kind<IO<?>, Tuple2<String, Unit>> run = StateT.set(monad, "abc").run("zzz");
     assertEquals(Tuple.of("abc", unit()), run.fix(toIO()).unsafeRunSync());
   }
 
   @Test
   public void gets() {
-    Kind<IO_, String> eval = StateT.<IO_, String, String>inspect(monad, String::toUpperCase).eval("abc");
+    Kind<IO<?>, String> eval = StateT.<IO<?>, String, String>inspect(monad, String::toUpperCase).eval("abc");
     assertEquals("ABC", eval.fix(toIO()).unsafeRunSync());
   }
 
   @Test
   public void modify() {
-    Kind<IO_, Tuple2<String, Unit>> run = StateT.<IO_, String>modify(monad, String::toUpperCase).run("abc");
+    Kind<IO<?>, Tuple2<String, Unit>> run = StateT.<IO<?>, String>modify(monad, String::toUpperCase).run("abc");
     assertEquals(Tuple.of("ABC", unit()), run.fix(toIO()).unsafeRunSync());
   }
 
   @Test
   public void flatMap() {
-    StateT<IO_, ImmutableList<String>, Unit> state =
+    StateT<IO<?>, ImmutableList<String>, Unit> state =
         pure("a").flatMap(append("b")).flatMap(append("c")).flatMap(end());
 
     IO<Tuple2<ImmutableList<String>, Unit>> result = IOOf.narrowK(state.run(ImmutableList.empty()));
@@ -68,18 +67,18 @@ public void flatMap() {
 
   @Test
   public void traverse() {
-    StateT<IO_, Unit, String> sa = StateT.pure(monad, "a");
-    StateT<IO_, Unit, String> sb = StateT.pure(monad, "b");
-    StateT<IO_, Unit, String> sc = StateT.pure(monad, "c");
+    StateT<IO<?>, Unit, String> sa = StateT.pure(monad, "a");
+    StateT<IO<?>, Unit, String> sb = StateT.pure(monad, "b");
+    StateT<IO<?>, Unit, String> sc = StateT.pure(monad, "c");
 
-    Kind<IO_, Tuple2<Unit, Sequence<String>>> result = StateT.traverse(monad, listOf(sa, sb, sc)).run(unit());
+    Kind<IO<?>, Tuple2<Unit, Sequence<String>>> result = StateT.traverse(monad, listOf(sa, sb, sc)).run(unit());
 
     assertEquals(Tuple.of(unit(), listOf("a", "b", "c")), IOOf.narrowK(result).unsafeRunSync());
   }
 
   @Test
   public void run() {
-    StateT<IO_, ImmutableList<String>, Option<String>> read =
+    StateT<IO<?>, ImmutableList<String>, Option<String>> read =
         StateT.lift(monad, state -> Tuple.of(state.tail(), state.head()));
 
     IO<Tuple2<ImmutableList<String>, Option<String>>> result = IOOf.narrowK(read.run(listOf("a", "b", "c")));
@@ -89,22 +88,22 @@ public void run() {
 
   @Test
   public void mapK() {
-    StateT<IO_, Unit, String> stateIo = StateT.pure(monad, "abc");
+    StateT<IO<?>, Unit, String> stateIo = StateT.pure(monad, "abc");
 
-    StateT<Try_, Unit, String> stateTry = stateIo.mapK(TryInstances.monad(), new IOToTryFunctionK());
+    StateT<Try<?>, Unit, String> stateTry = stateIo.mapK(TryInstances.monad(), new IOToTryFunctionK());
 
     assertEquals(Try.success(Tuple2.of(unit(), "abc")), TryOf.narrowK(stateTry.run(unit())));
   }
 
-  private StateT<IO_, ImmutableList<String>, String> pure(String value) {
+  private StateT<IO<?>, ImmutableList<String>, String> pure(String value) {
     return StateT.pure(monad, value);
   }
 
-  private <T> Function1<T, StateT<IO_, ImmutableList<T>, T>> append(T nextVal) {
+  private <T> Function1<T, StateT<IO<?>, ImmutableList<T>, T>> append(T nextVal) {
     return value -> StateT.lift(monad, state -> Tuple.of(state.append(value), nextVal));
   }
 
-  private <T> Function1<T, StateT<IO_, ImmutableList<T>, Unit>> end() {
+  private <T> Function1<T, StateT<IO<?>, ImmutableList<T>, Unit>> end() {
     return value -> StateT.lift(monad, state -> Tuple.of(state.append(value), unit()));
   }
 }
diff --git a/transformer/src/test/java/com/github/tonivade/purefun/transformer/WriterTTest.java b/transformer/src/test/java/com/github/tonivade/purefun/transformer/WriterTTest.java
index 2ee1bdf24..c9426518c 100644
--- a/transformer/src/test/java/com/github/tonivade/purefun/transformer/WriterTTest.java
+++ b/transformer/src/test/java/com/github/tonivade/purefun/transformer/WriterTTest.java
@@ -16,19 +16,18 @@
 import com.github.tonivade.purefun.instances.IdInstances;
 import com.github.tonivade.purefun.instances.SequenceInstances;
 import com.github.tonivade.purefun.type.Id;
-import com.github.tonivade.purefun.type.Id_;
 import com.github.tonivade.purefun.typeclasses.Monad;
 import com.github.tonivade.purefun.typeclasses.Monoid;
 
 public class WriterTTest {
 
   private final Monoid<Sequence<String>> monoid = SequenceInstances.monoid();
-  private final Monad<Id_> monad = IdInstances.monad();
+  private final Monad<Id<?>> monad = IdInstances.monad();
 
   @Test
   public void writerTest() {
-    WriterT<Id_, Sequence<String>, Integer> writer =
-        WriterT.<Id_, Sequence<String>, Integer>pure(monoid, monad, 5)
+    WriterT<Id<?>, Sequence<String>, Integer> writer =
+        WriterT.<Id<?>, Sequence<String>, Integer>pure(monoid, monad, 5)
         .flatMap(value -> lift(monoid, monad, Tuple.of(listOf("add 5"), value + 5)))
         .flatMap(value -> lift(monoid, monad, Tuple.of(listOf("plus 2"), value * 2)));
 
diff --git a/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Instance.java b/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Instance.java
index 808ade08e..f5c80c8da 100644
--- a/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Instance.java
+++ b/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Instance.java
@@ -12,16 +12,17 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.lang.reflect.WildcardType;
 import java.util.Arrays;
 
 
 import com.github.tonivade.purefun.type.Try;
 
 public abstract class Instance<F> {
-  
+
   private final Class<?> kindType;
   private final Type type;
-  
+
   protected Instance(Class<F> clazz) {
     this.kindType = clazz;
     this.type = clazz;
@@ -118,9 +119,9 @@ public Traverse<F> traverse(Object...params) {
   }
 
   protected String instanceName() {
-    return "com.github.tonivade.purefun.instances." + kindType.getSimpleName().replace("_", "Instances");
+    return "com.github.tonivade.purefun.instances." + kindType.getSimpleName() + "Instances";
   }
-  
+
   private static Type genericType(Type type) {
     if (type instanceof ParameterizedType parameterizedType) {
       return parameterizedType.getActualTypeArguments()[0];
@@ -128,12 +129,14 @@ private static Type genericType(Type type) {
     throw new UnsupportedOperationException("not supported " + type.getTypeName());
   }
 
-  @SuppressWarnings("unchecked")
   private static Class<?> kindType(Type type) {
     if (type instanceof ParameterizedType parameterizedType) {
       if (parameterizedType.getActualTypeArguments()[0] instanceof ParameterizedType) {
         return kindType(parameterizedType.getActualTypeArguments()[0]);
       }
+      if (parameterizedType.getActualTypeArguments()[0] instanceof WildcardType) {
+        return (Class<?>) parameterizedType.getRawType();
+      }
       if (parameterizedType.getActualTypeArguments()[0] instanceof Class) {
         return (Class<?>) parameterizedType.getActualTypeArguments()[0];
       }
@@ -154,7 +157,7 @@ private static <F> Class<?> findClass(Instance<F> instance)
     return Class.forName(instance.instanceName());
   }
 
-  private static Method findMethod(Class<?> instanceClass, Class<?> typeClass, Object... args) 
+  private static Method findMethod(Class<?> instanceClass, Class<?> typeClass, Object... args)
       throws NoSuchMethodException {
     String simpleName = typeClass.getSimpleName();
     String methodName = toLowerCase(simpleName.charAt(0)) + simpleName.substring(1);
@@ -167,7 +170,7 @@ private static Method findMethod(Class<?> instanceClass, Class<?> typeClass, Obj
   }
 
   @SuppressWarnings("unchecked")
-  private static <T> T getInstance(Method method, Object...args) 
+  private static <T> T getInstance(Method method, Object...args)
       throws IllegalAccessException, InvocationTargetException {
     return (T) method.invoke(null, args);
   }
diff --git a/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Monoid.java b/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Monoid.java
index f19c34565..6badaab29 100644
--- a/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Monoid.java
+++ b/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Monoid.java
@@ -44,12 +44,12 @@ public T combine(T t1, T t2) {
   }
 }
 
-interface MonoidInvariant extends Invariant<Monoid_> {
+interface MonoidInvariant extends Invariant<Monoid<?>> {
 
   MonoidInvariant INSTANCE = new MonoidInvariant() { };
 
   @Override
-  default <A, B> Kind<Monoid_, B> imap(Kind<Monoid_, ? extends A> value,
+  default <A, B> Kind<Monoid<?>, B> imap(Kind<Monoid<?>, ? extends A> value,
                                        Function1<? super A, ? extends B> map,
                                        Function1<? super B, ? extends A> comap) {
     return new Monoid<>() {
diff --git a/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Resource.java b/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Resource.java
index af3109e83..6f44e93f9 100644
--- a/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Resource.java
+++ b/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Resource.java
@@ -30,7 +30,7 @@ public <R> Resource<F, R> map(Function1<? super T, ? extends R> mapper) {
     return flatMap(t -> pure(monad, mapper.andThen(monad::<R>pure).apply(t)));
   }
   
-  public <R> Resource<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<Resource_, F>, ? extends R>> mapper) {
+  public <R> Resource<F, R> flatMap(Function1<? super T, ? extends Kind<Kind<Resource<?, ?>, F>, ? extends R>> mapper) {
     return new Resource<>(monad, monad.flatMap(resource, 
         t -> monad.map(mapper.andThen(ResourceOf::narrowK).apply(t.get1()).resource, 
             r -> Tuple.of(r.get1(), (Consumer1<R>) ignore -> releaseAndThen(t, r)))));
diff --git a/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Traverse.java b/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Traverse.java
index faeff408e..2e755f2ef 100644
--- a/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Traverse.java
+++ b/typeclasses/src/main/java/com/github/tonivade/purefun/typeclasses/Traverse.java
@@ -11,7 +11,6 @@
 
 import com.github.tonivade.purefun.core.Function1;
 import com.github.tonivade.purefun.type.Id;
-import com.github.tonivade.purefun.type.Id_;
 
 public interface Traverse<F> extends Functor<F>, Foldable<F> {
 
@@ -25,7 +24,7 @@ default <G, T> Kind<G, Kind<F, T>> sequence(Applicative<G> applicative,
 
   @Override
   default <T, R> Kind<F, R> map(Kind<F, ? extends T> value, Function1<? super T, ? extends R> map) {
-    Kind<Id_, Kind<F, R>> traverse = traverse(Instances.<Id_>applicative(), value, t -> Id.of(map.apply(t)));
+    Kind<Id<?>, Kind<F, R>> traverse = traverse(Instances.<Id<?>>applicative(), value, t -> Id.of(map.apply(t)));
     return traverse.fix(toId()).value();
   }
 
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ConcurrentTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ConcurrentTest.java
index 05956a264..e1a64ba6d 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ConcurrentTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ConcurrentTest.java
@@ -14,9 +14,7 @@
 
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.effect.PureIO;
-import com.github.tonivade.purefun.effect.PureIO_;
 import com.github.tonivade.purefun.monad.IO;
-import com.github.tonivade.purefun.monad.IO_;
 import com.github.tonivade.purefun.type.Either;
 
 public class ConcurrentTest {
@@ -25,9 +23,9 @@ public class ConcurrentTest {
 
   @Test
   public void ioRaceA() {
-    Concurrent<IO_> concurrent = Instances.<IO_>concurrent();
+    Concurrent<IO<?>> concurrent = Instances.<IO<?>>concurrent();
 
-    Kind<IO_, Either<Integer, String>> race = concurrent.race(
+    Kind<IO<?>, Either<Integer, String>> race = concurrent.race(
         IO.delay(Duration.ofMillis(10), () -> 10),
         IO.delay(Duration.ofMillis(100), () -> "b"));
 
@@ -38,9 +36,9 @@ public void ioRaceA() {
 
   @Test
   public void ioRaceB() {
-    Concurrent<IO_> concurrent = Instances.<IO_>concurrent();
+    Concurrent<IO<?>> concurrent = Instances.<IO<?>>concurrent();
 
-    Kind<IO_, Either<Integer, String>> race = concurrent.race(
+    Kind<IO<?>, Either<Integer, String>> race = concurrent.race(
         IO.delay(Duration.ofMillis(100), () -> 10),
         IO.delay(Duration.ofMillis(10), () -> "b"));
 
@@ -51,10 +49,10 @@ public void ioRaceB() {
 
   @Test
   public void PureIORaceA() {
-    Concurrent<Kind<Kind<PureIO_, Void>, Throwable>> concurrent =
-        new Instance<Kind<Kind<PureIO_, Void>, Throwable>>() { }.concurrent();
+    Concurrent<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>> concurrent =
+        new Instance<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>>() { }.concurrent();
 
-    Kind<Kind<Kind<PureIO_, Void>, Throwable>, Either<Integer, String>> race = concurrent.race(
+    Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, Either<Integer, String>> race = concurrent.race(
         PureIO.<Void, Throwable>sleep(Duration.ofMillis(10)).andThen(PureIO.task(() -> 10)),
         PureIO.<Void, Throwable>sleep(Duration.ofMillis(100)).andThen(PureIO.task(() -> "b")));
 
@@ -66,10 +64,10 @@ public void PureIORaceA() {
 
   @Test
   public void PureIORaceB() {
-    Concurrent<Kind<Kind<PureIO_, Void>, Throwable>> concurrent =
-        new Instance<Kind<Kind<PureIO_, Void>, Throwable>>() { }.concurrent();
+    Concurrent<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>> concurrent =
+        new Instance<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>>() { }.concurrent();
 
-    Kind<Kind<Kind<PureIO_, Void>, Throwable>, Either<Integer, String>> race = concurrent.race(
+    Kind<Kind<Kind<PureIO<?, ?, ?>, Void>, Throwable>, Either<Integer, String>> race = concurrent.race(
         PureIO.<Void, Throwable>sleep(Duration.ofMillis(100)).andThen(PureIO.task(() -> 10)),
         PureIO.<Void, Throwable>sleep(Duration.ofMillis(10)).andThen(PureIO.task(() -> "b")));
 
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/EqTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/EqTest.java
index 73e905ba1..c6c01fcc7 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/EqTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/EqTest.java
@@ -8,21 +8,21 @@
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+
 import org.junit.jupiter.api.Test;
 
 import com.github.tonivade.purefun.Kind;
 import com.github.tonivade.purefun.core.Eq;
-import com.github.tonivade.purefun.data.Sequence_;
+import com.github.tonivade.purefun.data.Sequence;
 import com.github.tonivade.purefun.instances.EitherInstances;
 import com.github.tonivade.purefun.instances.SequenceInstances;
 import com.github.tonivade.purefun.type.Either;
-import com.github.tonivade.purefun.type.Either_;
 
 public class EqTest {
 
   @Test
   public void sequence() {
-    Eq<Kind<Sequence_, Integer>> instance = SequenceInstances.eq(Eq.any());
+    Eq<Kind<Sequence<?>, Integer>> instance = SequenceInstances.eq(Eq.any());
 
     assertAll(
         () -> assertTrue(instance.eqv(listOf(1, 2, 3), listOf(1, 2, 3))),
@@ -37,7 +37,7 @@ public void either() {
     Either<Integer, String> right1 = Either.right("hola");
     Either<Integer, String> right2 = Either.right("hola");
 
-    Eq<Kind<Kind<Either_, Integer>, String>> instance = EitherInstances.eq(Eq.any(), Eq.any());
+    Eq<Kind<Kind<Either<?, ?>, Integer>, String>> instance = EitherInstances.eq(Eq.any(), Eq.any());
 
     assertAll(
         () -> assertTrue(instance.eqv(left1, left2)),
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ForTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ForTest.java
index ddb4d323e..cba094ffe 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ForTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ForTest.java
@@ -22,14 +22,12 @@
 import com.github.tonivade.purefun.core.Producer;
 import com.github.tonivade.purefun.core.Tuple;
 import com.github.tonivade.purefun.monad.IO;
-import com.github.tonivade.purefun.monad.IO_;
 import com.github.tonivade.purefun.type.Id;
-import com.github.tonivade.purefun.type.Id_;
 
 @ExtendWith(MockitoExtension.class)
 public class ForTest {
 
-  final Monad<Id_> monad = Instances.<Id_>monad();
+  final Monad<Id<?>> monad = Instances.<Id<?>>monad();
 
   @Test
   public void map() {
@@ -57,9 +55,9 @@ public void returns(@Mock Function1<String, String> mapper) {
 
   @Test
   public void flatMap() {
-    Id<String> result = For.with(Instances.<Id_>monad())
-        .andThen(() -> Instances.<Id_>monad().pure("value"))
-        .flatMap(string -> Instances.<Id_>monad().pure(string.toUpperCase()))
+    Id<String> result = For.with(Instances.<Id<?>>monad())
+        .andThen(() -> Instances.<Id<?>>monad().pure("value"))
+        .flatMap(string -> Instances.<Id<?>>monad().pure(string.toUpperCase()))
         .fix(toId());
 
     assertEquals(Id.of("VALUE"), result);
@@ -70,7 +68,7 @@ public void applyBug(@Mock Producer<String> task1, @Mock Producer<String> task2)
     when(task1.get()).thenReturn("hola toni");
     when(task2.get()).thenReturn("adios toni");
 
-    Applicative<IO_> monad = Instances.applicative(IO_.class);
+    Applicative<IO<?>> monad = Instances.<IO<?>>applicative();
     var result = For.with(monad)
       .then(IO.task(task1))
       .then(IO.task(task2))
@@ -99,13 +97,13 @@ public void apply() {
 
   @Test
   public void applyVsYield() {
-    var program1 = For.with(Instances.<IO_>monad())
+    var program1 = For.with(Instances.<IO<?>>monad())
         .and(1)
         .and(2)
         .and(3)
         .and(4)
         .and(5);
-    var program2 = For.with(Instances.<IO_>applicative())
+    var program2 = For.with(Instances.<IO<?>>applicative())
         .and(1)
         .and(2)
         .and(3)
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/IOReferenceTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/IOReferenceTest.java
index 32e7cc5d8..e2f8a8cb8 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/IOReferenceTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/IOReferenceTest.java
@@ -4,11 +4,11 @@
  */
 package com.github.tonivade.purefun.typeclasses;
 
-import com.github.tonivade.purefun.monad.IO_;
+import com.github.tonivade.purefun.monad.IO;
 
-public class IOReferenceTest extends ReferenceTest<IO_> {
+public class IOReferenceTest extends ReferenceTest<IO<?>> {
 
   public IOReferenceTest() {
-    super(IO_.class);
+    super(new Instance<IO<?>>() {});
   }
 }
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/IOResourceTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/IOResourceTest.java
index 378449bd4..f7181f814 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/IOResourceTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/IOResourceTest.java
@@ -4,11 +4,11 @@
  */
 package com.github.tonivade.purefun.typeclasses;
 
-import com.github.tonivade.purefun.monad.IO_;
+import com.github.tonivade.purefun.monad.IO;
 
-public class IOResourceTest extends ResourceTest<IO_> {
+public class IOResourceTest extends ResourceTest<IO<?>> {
 
   public IOResourceTest() {
-    super(IO_.class);
+    super(new Instance<IO<?>>() {});
   }
 }
\ No newline at end of file
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/InstanceTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/InstanceTest.java
index 74365177e..beeb07bff 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/InstanceTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/InstanceTest.java
@@ -15,24 +15,21 @@
 import com.github.tonivade.purefun.Kind;
 
 import com.github.tonivade.purefun.effect.PureIO;
-import com.github.tonivade.purefun.effect.PureIO_;
 import com.github.tonivade.purefun.type.Either;
-import com.github.tonivade.purefun.type.Either_;
 import com.github.tonivade.purefun.type.Id;
-import com.github.tonivade.purefun.type.Id_;
 
 public class InstanceTest {
 
   @Test
   public void testSimple() {
-    Id<Integer> result = Instances.<Id_>functor().map(Id.of(1), x -> x + 1).fix(toId());
+    Id<Integer> result = Instances.<Id<?>>functor().map(Id.of(1), x -> x + 1).fix(toId());
 
     assertEquals(Id.of(2), result);
   }
 
   @Test
   public void testComplex() {
-    Instance<Kind<Either_, String>> instance = new Instance<Kind<Either_, String>>(){};
+    Instance<Kind<Either<?, ?>, String>> instance = new Instance<Kind<Either<?, ?>, String>>(){};
 
     Either<String, Integer> result = instance.functor().map(Either.right(1), x -> x + 1).fix(toEither());
 
@@ -41,7 +38,7 @@ public void testComplex() {
 
   @Test
   public void testPureIO() {
-    Instance<Kind<Kind<PureIO_, Void>, String>> instance = new Instance<Kind<Kind<PureIO_, Void>, String>>(){};
+    Instance<Kind<Kind<PureIO<?, ?, ?>, Void>, String>> instance = new Instance<Kind<Kind<PureIO<?, ?, ?>, Void>, String>>(){};
 
     PureIO<Void, String, Integer> result = instance.functor().map(PureIO.pure(1), x -> x + 1).fix(toPureIO());
 
@@ -50,18 +47,18 @@ public void testPureIO() {
 
   @Test
   public void notFoundSimple() {
-    InstanceNotFoundException exception = assertThrows(InstanceNotFoundException.class, () -> Instances.<Id_, String>monadError());
+    InstanceNotFoundException exception = assertThrows(InstanceNotFoundException.class, () -> Instances.<Id<?>, String>monadError());
 
-    assertEquals("instance of type MonadError for type com.github.tonivade.purefun.type.Id_ not found", exception.getMessage());
+    assertEquals("instance of type MonadError for type com.github.tonivade.purefun.type.Id not found", exception.getMessage());
   }
 
   @Test
   public void notFoundComplex() {
-    Instance<Kind<Either_, String>> instance = new Instance<Kind<Either_, String>>(){};
+    Instance<Kind<Either<?, ?>, String>> instance = new Instance<Kind<Either<?, ?>, String>>(){};
 
     InstanceNotFoundException exception = assertThrows(InstanceNotFoundException.class, () -> instance.monadDefer());
 
-    assertEquals("instance of type MonadDefer for type com.github.tonivade.purefun.Kind<com.github.tonivade.purefun.type.Either_, java.lang.String> not found",
+    assertEquals("instance of type MonadDefer for type com.github.tonivade.purefun.Kind<com.github.tonivade.purefun.type.Either<?, ?>, java.lang.String> not found",
         exception.getMessage());
   }
 
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/MonadStateTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/MonadStateTest.java
index 8265d2a95..d917e2944 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/MonadStateTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/MonadStateTest.java
@@ -12,12 +12,11 @@
 
 import com.github.tonivade.purefun.data.ImmutableArray;
 import com.github.tonivade.purefun.monad.IO;
-import com.github.tonivade.purefun.monad.IO_;
 
 public class MonadStateTest {
 
-  private MonadState<IO_, ImmutableArray<String>> monadState =
-      MonadState.from(Instances.<IO_>monadDefer(), ImmutableArray.empty());
+  private MonadState<IO<?>, ImmutableArray<String>> monadState =
+      MonadState.from(Instances.<IO<?>>monadDefer(), ImmutableArray.empty());
 
   @Test
   public void program() {
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ReferenceTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ReferenceTest.java
index 6bf6a8e5a..0a87e2930 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ReferenceTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ReferenceTest.java
@@ -10,23 +10,23 @@
 
 
 public abstract class ReferenceTest<F> {
-  
-  private final Class<F> type;
-  
-  public ReferenceTest(Class<F> type) {
-    this.type = type;
+
+  private final Instance<F> instance;
+
+  public ReferenceTest(Instance<F> instance) {
+    this.instance = instance;
   }
 
   protected <T> Reference<F, T> makeRef(T value) {
-    return Instances.monadDefer(type).ref(value);
+    return instance.monadDefer().ref(value);
   }
-  
+
   protected <T, R> Kind<F, R> doAndThen(Kind<F, T> value, Kind<F, R> next) {
-    return Instances.monad(type).andThen(value, () -> next);
+    return instance.monad().andThen(value, () -> next);
   }
-  
+
   protected <T> T run(Kind<F, T> value) {
-    return Instances.runtime(type).run(value);
+    return instance.runtime().run(value);
   }
 
   @Test
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ResourceTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ResourceTest.java
index 641804bb1..dcad9c18c 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ResourceTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ResourceTest.java
@@ -27,67 +27,67 @@
 
 @ExtendWith(MockitoExtension.class)
 public abstract class ResourceTest<F> {
-  
-  private final Class<F> type;
-  
-  protected ResourceTest(Class<F> type) {
-    this.type = type;
+
+  private final Instance<F> instance;
+
+  protected ResourceTest(Instance<F> instance) {
+    this.instance = instance;
   }
-  
+
   protected <T extends AutoCloseable> Resource<F, T> makeResource(Kind<F, T> acquire) {
     return makeResource(acquire, AutoCloseable::close);
   }
 
   protected <T> Resource<F, T> makeResource(Kind<F, T> acquire, Consumer1<T> release) {
-    return Instances.monadDefer(type).resource(acquire, release);
+    return instance.monadDefer().resource(acquire, release);
   }
-  
+
   protected <T> T run(Kind<F, T> result) {
-    return Instances.runtime(type).run(result);
+    return instance.runtime().run(result);
   }
-  
+
   protected <T> Kind<F, T> pure(T value) {
-    return Instances.monadDefer(type).pure(value);
+    return instance.monadDefer().pure(value);
   }
 
   protected <T> Kind<F, T> later(Producer<T> value) {
-    return Instances.monadDefer(type).later(value);
+    return instance.monadDefer().later(value);
   }
 
   @Test
   public void use(@Mock Consumer1<String> release) {
     Resource<F, String> resource = makeResource(pure("hola"), release);
-    
+
     Kind<F, String> use = resource.use(string -> pure(string.toUpperCase()));
-    
+
     assertEquals("HOLA", run(use));
     verify(release).accept("hola");
   }
-  
+
   @Test
   public void map(@Mock Consumer1<String> release) {
     Resource<F, String> resource = makeResource(pure("hola"), release).map(String::toUpperCase);
-    
+
     Kind<F, Integer> use = resource.use(string -> pure(string.length()));
-    
+
     assertEquals(4, run(use));
     verify(release).accept("hola");
   }
-  
+
   @Test
-  public void flatMap(@Mock DataSource dataSource, @Mock Connection connection, 
+  public void flatMap(@Mock DataSource dataSource, @Mock Connection connection,
       @Mock PreparedStatement statement, @Mock ResultSet resultSet) throws SQLException {
     when(dataSource.getConnection()).thenReturn(connection);
     when(connection.prepareStatement("sql")).thenReturn(statement);
     when(statement.executeQuery()).thenReturn(resultSet);
     when(resultSet.getString(0)).thenReturn("result");
-    
+
     Resource<F, ResultSet> flatMap = makeResource(later(dataSource::getConnection))
       .flatMap(conn -> makeResource(later(() -> conn.prepareStatement("sql"))))
       .flatMap(stmt -> makeResource(later(() -> stmt.executeQuery())));
-    
+
     Kind<F, String> use = flatMap.use(rs -> later(() -> rs.getString(0)));
-    
+
     assertEquals("result", run(use));
     InOrder inOrder = inOrder(resultSet, statement, connection);
     inOrder.verify(resultSet).close();
@@ -99,9 +99,9 @@ public void flatMap(@Mock DataSource dataSource, @Mock Connection connection,
   public void combine(@Mock Consumer1<String> release1, @Mock Consumer1<Integer> release2) {
     Resource<F, String> res1 = makeResource(pure("hola"), release1);
     Resource<F, Integer> res2 = makeResource(pure(5), release2);
-    
+
     Resource<F, Tuple2<String, Integer>> combine = res1.combine(res2);
-    
+
     Kind<F, String> use = combine.use(tuple -> later(tuple::toString));
 
     assertEquals("Tuple2(hola, 5)", run(use));
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ScheduleTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ScheduleTest.java
index 8fe663f27..6328fc663 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ScheduleTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/ScheduleTest.java
@@ -26,19 +26,17 @@
 import com.github.tonivade.purefun.data.Sequence;
 import com.github.tonivade.purefun.effect.UIO;
 import com.github.tonivade.purefun.effect.UIOOf;
-import com.github.tonivade.purefun.effect.UIO_;
 import com.github.tonivade.purefun.monad.IO;
-import com.github.tonivade.purefun.monad.IO_;
 
 @ExtendWith(MockitoExtension.class)
 public class ScheduleTest {
 
-  private final MonadError<IO_, Throwable> monadError = Instances.<IO_, Throwable>monadError();
+  private final MonadError<IO<?>, Throwable> monadError = Instances.<IO<?>, Throwable>monadError();
 
   @Test
   public void repeat(@Mock Consumer1<String> console) {
     IO<Unit> print = IO.exec(() -> console.accept("hola"));
-    Schedule<IO_, Unit, Unit> schedule = Schedule.<IO_, Unit>recurs(2).zipRight(Schedule.identity());
+    Schedule<IO<?>, Unit, Unit> schedule = Schedule.<IO<?>, Unit>recurs(2).zipRight(Schedule.identity());
 
     IO<Unit> repeat = monadError.repeat(print, schedule).fix(toIO());
 
@@ -51,7 +49,7 @@ public void repeat(@Mock Consumer1<String> console) {
   @Test
   public void repeatStackSafeIO(@Mock Consumer1<String> console) {
     IO<Unit> print = IO.exec(() -> console.accept("hola"));
-    Schedule<IO_, Unit, Unit> schedule = Schedule.<IO_, Unit>recurs(10000).zipRight(Schedule.identity());
+    Schedule<IO<?>, Unit, Unit> schedule = Schedule.<IO<?>, Unit>recurs(10000).zipRight(Schedule.identity());
 
     IO<Unit> repeat = monadError.repeat(print, schedule).fix(toIO());
 
@@ -64,9 +62,9 @@ public void repeatStackSafeIO(@Mock Consumer1<String> console) {
   @Test
   public void repeatStackSafeUIO(@Mock Consumer1<String> console) {
     UIO<Unit> print = UIO.exec(() -> console.accept("hola"));
-    Schedule<UIO_, Unit, Unit> schedule = Schedule.<UIO_, Unit>recurs(10000).zipRight(Schedule.identity());
+    Schedule<UIO<?>, Unit, Unit> schedule = Schedule.<UIO<?>, Unit>recurs(10000).zipRight(Schedule.identity());
 
-    UIO<Unit> repeat = Instances.<UIO_, Throwable>monadError().repeat(print, schedule).fix(UIOOf.toUIO());
+    UIO<Unit> repeat = Instances.<UIO<?>, Throwable>monadError().repeat(print, schedule).fix(UIOOf.toUIO());
 
     Unit result = repeat.unsafeRunSync();
 
@@ -77,9 +75,9 @@ public void repeatStackSafeUIO(@Mock Consumer1<String> console) {
   @Test
   public void repeatDelay(@Mock Consumer1<String> console) {
     IO<Unit> print = IO.exec(() -> console.accept("hola"));
-    Schedule<IO_, Unit, Unit> recurs = Schedule.<IO_, Unit>recurs(2).zipRight(Schedule.identity());
-    Schedule<IO_, Unit, Integer> spaced = Schedule.spaced(Duration.ofMillis(500));
-    Schedule<IO_, Unit, Unit> schedule = recurs.zipLeft(spaced);
+    Schedule<IO<?>, Unit, Unit> recurs = Schedule.<IO<?>, Unit>recurs(2).zipRight(Schedule.identity());
+    Schedule<IO<?>, Unit, Integer> spaced = Schedule.spaced(Duration.ofMillis(500));
+    Schedule<IO<?>, Unit, Unit> schedule = recurs.zipLeft(spaced);
 
     IO<Unit> repeat = monadError.repeat(print, schedule).fix(toIO());
     IO<Tuple2<Duration, Unit>> timed = repeat.timed();
@@ -121,8 +119,8 @@ public void retryDelay(@Mock Producer<String> console) {
     when(console.get()).thenThrow(RuntimeException.class).thenReturn("hola");
 
     IO<String> read = IO.task(console::get);
-    Schedule<IO_, Throwable, Integer> recurs = Schedule.recurs(2);
-    Schedule<IO_, Throwable, Integer> spaced = Schedule.spaced(Duration.ofMillis(500));
+    Schedule<IO<?>, Throwable, Integer> recurs = Schedule.recurs(2);
+    Schedule<IO<?>, Throwable, Integer> spaced = Schedule.spaced(Duration.ofMillis(500));
     IO<Tuple2<Duration, String>> retry = monadError.retry(read, recurs.zip(spaced)).fix(toIO()).timed();
 
     Tuple2<Duration, String> result = retry.unsafeRunSync();
@@ -144,8 +142,8 @@ public void noRetry(@Mock Producer<String> console) {
 
   @Test
   public void andThen(@Mock Consumer1<String> console) {
-    Schedule<IO_, Unit, Integer> two =
-        Schedule.<IO_, Unit>recurs(1).andThen(Schedule.<IO_, Unit>recurs(1));
+    Schedule<IO<?>, Unit, Integer> two =
+        Schedule.<IO<?>, Unit>recurs(1).andThen(Schedule.<IO<?>, Unit>recurs(1));
 
     IO<Unit> print = IO.exec(() -> console.accept("hola"));
     IO<Integer> repeat = monadError.repeat(print, two).fix(toIO());
@@ -158,8 +156,8 @@ public void andThen(@Mock Consumer1<String> console) {
 
   @Test
   public void compose(@Mock Consumer1<String> console) {
-    Schedule<IO_, Unit, Integer> two =
-      Schedule.<IO_, Unit>recurs(2).compose(Schedule.<IO_, Integer>recurs(2));
+    Schedule<IO<?>, Unit, Integer> two =
+      Schedule.<IO<?>, Unit>recurs(2).compose(Schedule.<IO<?>, Integer>recurs(2));
 
     IO<Unit> print = IO.exec(() -> console.accept("hola"));
     IO<Integer> repeat = monadError.repeat(print, two).fix(toIO());
@@ -174,7 +172,7 @@ public void compose(@Mock Consumer1<String> console) {
   public void collect() {
     IO<Unit> pure = IO.unit();
 
-    Schedule<IO_, Unit, Sequence<Integer>> schedule = Schedule.<IO_, Unit>recurs(5).collectAll().zipLeft(Schedule.identity());
+    Schedule<IO<?>, Unit, Sequence<Integer>> schedule = Schedule.<IO<?>, Unit>recurs(5).collectAll().zipLeft(Schedule.identity());
     IO<Sequence<Integer>> repeat = monadError.repeat(pure, schedule).fix(toIO());
 
     Sequence<Integer> result = repeat.unsafeRunSync();
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/SelectiveTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/SelectiveTest.java
index 1e38556bb..3af36d902 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/SelectiveTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/SelectiveTest.java
@@ -24,23 +24,20 @@
 import com.github.tonivade.purefun.core.Producer;
 import com.github.tonivade.purefun.core.Unit;
 import com.github.tonivade.purefun.data.Sequence;
-import com.github.tonivade.purefun.data.Sequence_;
 import com.github.tonivade.purefun.instances.SequenceInstances;
 import com.github.tonivade.purefun.instances.ValidationInstances;
 import com.github.tonivade.purefun.monad.IO;
-import com.github.tonivade.purefun.monad.IO_;
 import com.github.tonivade.purefun.type.Either;
 import com.github.tonivade.purefun.type.Validation;
-import com.github.tonivade.purefun.type.Validation_;
 
 @ExtendWith(MockitoExtension.class)
 class SelectiveTest {
 
-  private final Selective<IO_> monad = Instances.<IO_>monad();
+  private final Selective<IO<?>> monad = Instances.<IO<?>>monad();
 
   @Test
   void apply() {
-    Selective<Kind<Validation_, Sequence<String>>> selective =
+    Selective<Kind<Validation<?, ?>, Sequence<String>>> selective =
         ValidationInstances.selective(SequenceInstances.semigroup());
 
     var validValue = Validation.<Sequence<String>, Integer>valid(1);
@@ -140,9 +137,9 @@ void orS() {
 
   @Test
   void allS() {
-    var match = monad.<Sequence_, String>allS(
+    var match = monad.<Sequence<?>, String>allS(
             listOf("a", "b", "c"), a -> monad.pure(a.length() == 1));
-    var notMatch = monad.<Sequence_, String>allS(
+    var notMatch = monad.<Sequence<?>, String>allS(
             listOf("a", "b", "cd"), a -> monad.pure(a.length() == 1));
 
     assertAll(
@@ -153,9 +150,9 @@ void allS() {
 
   @Test
   void anyS() {
-    var match = monad.<Sequence_, String>anyS(
+    var match = monad.<Sequence<?>, String>anyS(
             listOf("a", "b", "cd"), a -> monad.pure(a.length() > 1));
-    var notMatch = monad.<Sequence_, String>anyS(
+    var notMatch = monad.<Sequence<?>, String>anyS(
             listOf("a", "b", "c"), a -> monad.pure(a.length() > 1));
 
     assertAll(
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TaskResourceTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TaskResourceTest.java
index 8d387e021..5e2adb994 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TaskResourceTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TaskResourceTest.java
@@ -4,11 +4,11 @@
  */
 package com.github.tonivade.purefun.typeclasses;
 
-import com.github.tonivade.purefun.effect.Task_;
+import com.github.tonivade.purefun.effect.Task;
 
-public class TaskResourceTest extends ResourceTest<Task_> {
+public class TaskResourceTest extends ResourceTest<Task<?>> {
 
   public TaskResourceTest() {
-    super(Task_.class);
+    super(new Instance<Task<?>>() { });
   }
 }
\ No newline at end of file
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK1Test.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK1Test.java
index 25f4702f1..d7f347996 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK1Test.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK1Test.java
@@ -15,14 +15,14 @@
 import org.mockito.junit.jupiter.MockitoExtension;
 
 import com.github.tonivade.purefun.core.Consumer1;
-import com.github.tonivade.purefun.type.Option_;
+import com.github.tonivade.purefun.type.Option;
 
 @ExtendWith(MockitoExtension.class)
 public class TupleK1Test {
-  
+
   @Test
   public void tuple() {
-    TupleK1<Option_, String> tuple = TupleK.of(some("value"));
+    TupleK1<Option<?>, String> tuple = TupleK.of(some("value"));
 
     assertAll(
       () -> assertEquals(TupleK.of(some("value")), tuple),
@@ -34,7 +34,7 @@ public void tuple() {
 
   @Test
   public void forEach(@Mock Consumer1<Object> callback) {
-    TupleK1<Option_, String> tuple = TupleK.of(some("value"));
+    TupleK1<Option<?>, String> tuple = TupleK.of(some("value"));
 
     tuple.forEach(callback);
 
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK2Test.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK2Test.java
index c3b440d5f..9b061adcf 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK2Test.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK2Test.java
@@ -10,13 +10,13 @@
 
 import org.junit.jupiter.api.Test;
 
-import com.github.tonivade.purefun.type.Option_;
+import com.github.tonivade.purefun.type.Option;
 
 public class TupleK2Test {
-  
+
   @Test
   public void tuple() {
-    TupleK2<Option_, String, Integer> tuple = TupleK.of(some("value"), some(10));
+    TupleK2<Option<?>, String, Integer> tuple = TupleK.of(some("value"), some(10));
 
     assertAll(() -> assertEquals(TupleK.of(some("value"), some(10)), tuple),
               () -> assertEquals(TupleK.of(some("VALUE"), some(10)), tuple.map1(String::toUpperCase)),
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK3Test.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK3Test.java
index b6f8338de..d29dd95d2 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK3Test.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK3Test.java
@@ -12,14 +12,14 @@
 
 import org.junit.jupiter.api.Test;
 
-import com.github.tonivade.purefun.type.Option_;
+import com.github.tonivade.purefun.type.Option;
 
 public class TupleK3Test {
 
   @Test
   public void tuple() {
 
-    TupleK3<Option_, String, Integer, LocalDate> tuple = TupleK.of(some("value"), some(10), some(LocalDate.of(2018, 11, 5)));
+    TupleK3<Option<?>, String, Integer, LocalDate> tuple = TupleK.of(some("value"), some(10), some(LocalDate.of(2018, 11, 5)));
 
     assertAll(() -> assertEquals(TupleK.of(some("value"), some(10), some(LocalDate.of(2018, 11, 5))), tuple),
               () -> assertEquals(TupleK.of(some("VALUE"), some(10), some(LocalDate.of(2018, 11, 5))), tuple.map1(String::toUpperCase)),
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK4Test.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK4Test.java
index 7dfa8815a..e5cf4a487 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK4Test.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK4Test.java
@@ -14,13 +14,13 @@
 import org.junit.jupiter.api.Test;
 
 import com.github.tonivade.purefun.core.Unit;
-import com.github.tonivade.purefun.type.Option_;
+import com.github.tonivade.purefun.type.Option;
 
 public class TupleK4Test {
 
   @Test
   public void tuple() {
-    TupleK4<Option_, String, Integer, LocalDate, Unit> tuple =
+    TupleK4<Option<?>, String, Integer, LocalDate, Unit> tuple =
         TupleK.of(some("value"), some(10), some(LocalDate.of(2018, 11, 5)), none());
 
     assertAll(() -> assertEquals(TupleK.of(some("value"), some(10), some(LocalDate.of(2018, 11, 5)), none()), tuple),
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK5Test.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK5Test.java
index c9dfc4136..fc324bbb7 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK5Test.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/TupleK5Test.java
@@ -14,13 +14,13 @@
 import org.junit.jupiter.api.Test;
 
 import com.github.tonivade.purefun.core.Unit;
-import com.github.tonivade.purefun.type.Option_;
+import com.github.tonivade.purefun.type.Option;
 
 public class TupleK5Test {
 
   @Test
   public void tuple() {
-    TupleK5<Option_, String, Integer, LocalDate, Unit, Double> tuple =
+    TupleK5<Option<?>, String, Integer, LocalDate, Unit, Double> tuple =
         TupleK.of(some("value"), some(10), some(LocalDate.of(2018, 11, 5)), none(), some(1.0));
 
     assertAll(() -> assertEquals(TupleK.of(some("value"), some(10), some(LocalDate.of(2018, 11, 5)), none(), some(1.0)), tuple),
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/UIOReferenceTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/UIOReferenceTest.java
index 73005647c..5b912779a 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/UIOReferenceTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/UIOReferenceTest.java
@@ -4,11 +4,11 @@
  */
 package com.github.tonivade.purefun.typeclasses;
 
-import com.github.tonivade.purefun.effect.UIO_;
+import com.github.tonivade.purefun.effect.UIO;
 
-public class UIOReferenceTest extends ReferenceTest<UIO_> {
+public class UIOReferenceTest extends ReferenceTest<UIO<?>> {
 
   public UIOReferenceTest() {
-    super(UIO_.class);
+    super(new Instance<UIO<?>>() {});
   }
 }
diff --git a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/UIOResourceTest.java b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/UIOResourceTest.java
index 5d6a39aea..cd935b4b3 100644
--- a/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/UIOResourceTest.java
+++ b/typeclasses/src/test/java/com/github/tonivade/purefun/typeclasses/UIOResourceTest.java
@@ -4,11 +4,11 @@
  */
 package com.github.tonivade.purefun.typeclasses;
 
-import com.github.tonivade.purefun.effect.UIO_;
+import com.github.tonivade.purefun.effect.UIO;
 
-public class UIOResourceTest extends ResourceTest<UIO_> {
+public class UIOResourceTest extends ResourceTest<UIO<?>> {
 
   public UIOResourceTest() {
-    super(UIO_.class);
+    super(new Instance<UIO<?>>() {});
   }
 }
\ No newline at end of file