diff --git a/src/main/java/com/github/tonivade/vavr/effect/Fiber.java b/src/main/java/com/github/tonivade/vavr/effect/Fiber.java
index 3afe2ec..6fcab2f 100644
--- a/src/main/java/com/github/tonivade/vavr/effect/Fiber.java
+++ b/src/main/java/com/github/tonivade/vavr/effect/Fiber.java
@@ -4,15 +4,6 @@
  */
 package com.github.tonivade.vavr.effect;
 
-public sealed interface Fiber<T> {
+public record Fiber<T>(IO<T> join, IO<Unit> cancel) {
 
-  IO<T> join();
-
-  IO<Unit> cancel();
-
-  static <T> Fiber<T> of(IO<T> join, IO<Unit> cancel) {
-    return new FiberImpl<>(join, cancel);
-  }
-
-  record FiberImpl<T>(IO<T> join, IO<Unit> cancel) implements Fiber<T> {}
 }
\ No newline at end of file
diff --git a/src/main/java/com/github/tonivade/vavr/effect/IO.java b/src/main/java/com/github/tonivade/vavr/effect/IO.java
index 2f0df53..33b477e 100644
--- a/src/main/java/com/github/tonivade/vavr/effect/IO.java
+++ b/src/main/java/com/github/tonivade/vavr/effect/IO.java
@@ -124,7 +124,7 @@
   }
 
   default IO<Tuple2<Duration, T>> timed() {
-    return IO.task(System::nanoTime).flatMap(
+    return task(System::nanoTime).flatMap(
       start -> map(result -> Tuple.of(Duration.ofNanos(System.nanoTime() - start), result)));
   }
 
@@ -136,7 +136,7 @@
       IO<T> join = fromFuture(promise.future());
       IO<Unit> cancel = exec(connection::cancel);
 
-      callback.accept(Try.success(Fiber.of(join, cancel)));
+      callback.accept(Try.success(new Fiber<>(join, cancel)));
     });
   }
 
@@ -147,7 +147,7 @@
   default IO<T> timeout(Executor executor, Duration duration) {
     return racePair(executor, this, sleep(duration)).flatMap(either -> either.fold(
         ta -> ta._2().cancel().map(x -> ta._1()),
-        tb -> tb._1().cancel().flatMap(x -> IO.raiseError(new TimeoutException()))));
+        tb -> tb._1().cancel().flatMap(x -> raiseError(new TimeoutException()))));
   }
 
   default IO<T> repeat() {
@@ -233,21 +233,24 @@
         tb -> tb._1().cancel().map(x -> Either.right(tb._2()))));
   }
 
-  static <A, B> IO<Either<Tuple2<A, Fiber<B>>, Tuple2<Fiber<A>, B>>> racePair(Executor executor, IO<? extends A> fa, IO<? extends B> fb) {
+  static <A, B> IO<Either<Tuple2<A, Fiber<B>>, Tuple2<Fiber<A>, B>>> racePair(
+      Executor executor, IO<? extends A> fa, IO<? extends B> fb) {
     return cancellable(callback -> {
 
       IOConnection connection1 = IOConnection.cancellable();
       IOConnection connection2 = IOConnection.cancellable();
 
-      Promise<A> promiseA = runAsync(IO.forked(executor).andThen(fa), connection1);
-      Promise<B> promiseB = runAsync(IO.forked(executor).andThen(fb), connection2);
+      Promise<A> promiseA = runAsync(forked(executor).andThen(fa), connection1);
+      Promise<B> promiseB = runAsync(forked(executor).andThen(fb), connection2);
 
       promiseA.future().onComplete(result -> callback.accept(
-          result.map(a -> Either.left(Tuple.of(a, Fiber.of(IO.fromFuture(promiseB.future()), IO.exec(connection2::cancel)))))));
+          result.map(a -> Either.left(
+              Tuple.of(a, new Fiber<>(fromFuture(promiseB.future()), exec(connection2::cancel)))))));
       promiseB.future().onComplete(result -> callback.accept(
-          result.map(b -> Either.right(Tuple.of(Fiber.of(IO.fromFuture(promiseA.future()), IO.exec(connection2::cancel)), b)))));
+          result.map(b -> Either.right(
+              Tuple.of(new Fiber<>(fromFuture(promiseA.future()), exec(connection2::cancel)), b)))));
 
-      return IO.exec(() -> {
+      return exec(() -> {
         try {
           connection1.cancel();
         } finally {
@@ -314,7 +317,7 @@
     return cancellable(callback -> {
       Future<Unit> sleep = FutureModule.sleep(executor,duration)
         .onComplete(result -> callback.accept(Try.success(Unit.unit())));
-      return IO.exec(() -> sleep.cancel(true));
+      return exec(() -> sleep.cancel(true));
     });
   }
 
@@ -356,8 +359,8 @@
       Function1<A, IO<IO<T>>> result = a -> r.modify(map -> map.get(a).fold(() -> {
         Promise<T> promise = Promise.make();
         function.apply(a).safeRunAsync(executor, promise::tryComplete);
-        return Tuple.of(IO.fromFuture(promise.future()), map.put(a, promise));
-      }, promise -> Tuple.of(IO.fromFuture(promise.future()), map)));
+        return Tuple.of(fromFuture(promise.future()), map.put(a, promise));
+      }, promise -> Tuple.of(fromFuture(promise.future()), map)));
       return result.andThen(io -> io.flatMap(identity()));
     });
   }
@@ -381,7 +384,7 @@
             .onComplete(ignore -> callback.accept(result))
         ));
 
-      return IO.exec(cancellable::cancel);
+      return exec(cancellable::cancel);
     });
   }
 
@@ -396,8 +399,8 @@
   }
 
   static IO<Unit> sequence(Seq<IO<?>> sequence) {
-    IO<?> initial = IO.unit();
-    return sequence.foldLeft(initial, (IO<?> a, IO<?> b) -> a.andThen(b)).andThen(IO.unit());
+    IO<?> initial = unit();
+    return sequence.foldLeft(initial, (IO<?> a, IO<?> b) -> a.andThen(b)).andThen(unit());
   }
 
   static <A> IO<Seq<A>> traverse(Seq<IO<A>> sequence) {
@@ -421,12 +424,12 @@
       IOConnection connection1 = IOConnection.cancellable();
       IOConnection connection2 = IOConnection.cancellable();
 
-      Promise<A> promiseA = runAsync(IO.forked(executor).andThen(fa), connection1);
-      Promise<B> promiseB = runAsync(IO.forked(executor).andThen(fb), connection2);
+      Promise<A> promiseA = runAsync(forked(executor).andThen(fa), connection1);
+      Promise<B> promiseB = runAsync(forked(executor).andThen(fb), connection2);
 
       promiseA.future().onComplete(a -> promiseB.future().onComplete(b -> callback.accept(map2(a, b, mapper))));
 
-      return IO.exec(() -> {
+      return exec(() -> {
         try {
           connection1.cancel();
         } finally {
@@ -508,13 +511,13 @@
           stack.push();
 
           var flatMapped = (FlatMapped<U, T>) current;
-          IO<U> source = IO.narrowK(unwrap(flatMapped.current, stack, u -> u.flatMap(flatMapped.next)));
+          IO<U> source = narrowK(unwrap(flatMapped.current, stack, u -> u.flatMap(flatMapped.next)));
 
           if (source instanceof Async<U> async) {
             Promise<U> nextPromise = Promise.make();
 
             nextPromise.future().andThen(tryU -> tryU.onFailure(promise::failure)
-                .onSuccess(u -> runAsync(IO.narrowK(flatMapped.next.apply(u)), connection, stack, promise)));
+                .onSuccess(u -> runAsync(narrowK(flatMapped.next.apply(u)), connection, stack, promise)));
 
             executeAsync(async, connection, nextPromise);
 
@@ -551,9 +554,9 @@
         stack.add(partialFunction(recover.mapper::isDefinedAt, recover.mapper.andThen(next)));
         current = recover.current;
       } else if (current instanceof Suspend<T> suspend) {
-        current = IO.narrowK(suspend.lazy.get());
+        current = narrowK(suspend.lazy.get());
       } else if (current instanceof Delay<T> delay) {
-        return IO.pure(delay.task.unchecked().get());
+        return pure(delay.task.unchecked().get());
       } else if (current instanceof Pure) {
         return current;
       } else if (current instanceof FlatMapped) {
@@ -582,12 +585,10 @@
     return promise;
   }
 
-  final class Pure<T> implements IO<T> {
+  record Pure<T>(T value) implements IO<T> {
 
-    private final T value;
-
-    private Pure(T value) {
-      this.value = Objects.requireNonNull(value);
+    public Pure {
+      Objects.requireNonNull(value);
     }
 
     @Override
@@ -596,12 +597,10 @@
     }
   }
 
-  final class Failure<T> implements IO<T> {
+  record Failure<T>(Throwable error) implements IO<T> {
 
-    private final Throwable error;
-
-    private Failure(Throwable error) {
-      this.error = Objects.requireNonNull(error);
+    public Failure {
+      Objects.requireNonNull(error);
     }
 
     @Override
@@ -610,15 +609,11 @@
     }
   }
 
-  final class FlatMapped<T, R> implements IO<R> {
+  record FlatMapped<T, R>(IO<? extends T> current, Function1<? super T, ? extends IO<? extends R>> next)  implements IO<R> {
 
-    private final IO<? extends T> current;
-    private final Function1<? super T, ? extends IO<? extends R>> next;
-
-    private FlatMapped(IO<? extends T> current,
-                         Function1<? super T, ? extends IO<? extends R>> next) {
-      this.current = Objects.requireNonNull(current);
-      this.next = Objects.requireNonNull(next);
+    public FlatMapped {
+      Objects.requireNonNull(current);
+      Objects.requireNonNull(next);
     }
 
     @Override
@@ -627,12 +622,10 @@
     }
   }
 
-  final class Delay<T> implements IO<T> {
+  record Delay<T>(CheckedFunction0<? extends T> task) implements IO<T> {
 
-    private final CheckedFunction0<? extends T> task;
-
-    private Delay(CheckedFunction0<? extends T> task) {
-      this.task = Objects.requireNonNull(task);
+    public Delay {
+      Objects.requireNonNull(task);
     }
 
     @Override
@@ -641,12 +634,10 @@
     }
   }
 
-  final class Async<T> implements IO<T> {
+  record Async<T>(Function1<Consumer<? super Try<? extends T>>, IO<Unit>> callback) implements IO<T> {
 
-    private final Function1<Consumer<? super Try<? extends T>>, IO<Unit>> callback;
-
-    private Async(Function1<Consumer<? super Try<? extends T>>, IO<Unit>> callback) {
-      this.callback = Objects.requireNonNull(callback);
+    public Async {
+      Objects.requireNonNull(callback);
     }
 
     @Override
@@ -655,12 +646,10 @@
     }
   }
 
-  final class Suspend<T> implements IO<T> {
+  record Suspend<T>(Supplier<? extends IO<? extends T>> lazy) implements IO<T> {
 
-    private final Supplier<? extends IO<? extends T>> lazy;
-
-    private Suspend(Supplier<? extends IO<? extends T>> lazy) {
-      this.lazy = Objects.requireNonNull(lazy);
+    public Suspend {
+      Objects.requireNonNull(lazy);
     }
 
     @Override
@@ -669,14 +658,11 @@
     }
   }
 
-  final class Recover<T> implements IO<T> {
+  record Recover<T>(IO<T> current, PartialFunction<? super Throwable, ? extends IO<? extends T>> mapper) implements IO<T> {
 
-    private final IO<T> current;
-    private final PartialFunction<? super Throwable, ? extends IO<? extends T>> mapper;
-
-    private Recover(IO<T> current, PartialFunction<? super Throwable, ? extends IO<? extends T>> mapper) {
-      this.current = Objects.requireNonNull(current);
-      this.mapper = Objects.requireNonNull(mapper);
+    public Recover {
+      Objects.requireNonNull(current);
+      Objects.requireNonNull(mapper);
     }
 
     @Override
diff --git a/src/main/java/com/github/tonivade/vavr/effect/Schedule.java b/src/main/java/com/github/tonivade/vavr/effect/Schedule.java
index 176f20e..949ccb8 100644
--- a/src/main/java/com/github/tonivade/vavr/effect/Schedule.java
+++ b/src/main/java/com/github/tonivade/vavr/effect/Schedule.java
@@ -17,7 +17,7 @@
 import io.vavr.control.Either;
 
 public sealed interface Schedule<A, B> {
-  
+
   <C> Schedule<A, C> map(Function1<? super B, ? extends C> mapper);
 
   <C> Schedule<C, B> contramap(Function1<? super C, ? extends A> comap);
@@ -98,7 +98,7 @@
   Schedule<A, B> untilOutputM(Function1<B, IO<Boolean>> condition);
 
   Schedule<A, B> check(Function2<A, B, IO<Boolean>> condition);
-  
+
   static <A> Schedule<A, Unit> once() {
     return Schedule.<A>recurs(1).unit();
   }
@@ -191,7 +191,7 @@
     B extract(A last, S state);
 
   }
-  
+
   private static <A> A merge(Either<A, A> either) {
     return either.fold(Function1.identity(), Function1.identity());
   }
@@ -202,26 +202,26 @@
 }
 
 final class ScheduleImpl<S, A, B> implements Schedule<A, B>, Schedule.Update<S, A>, Schedule.Extract<A, S, B> {
-  
+
   private final IO<S> initial;
   private final Update<S, A> update;
   private final Extract<A, S, B> extract;
-  
+
   private ScheduleImpl(IO<S> initial, Update<S, A> update, Extract<A, S, B> extract) {
     this.initial = Objects.requireNonNull(initial);
     this.update = Objects.requireNonNull(update);
     this.extract = Objects.requireNonNull(extract);
   }
-  
+
   public IO<S> initial() {
     return initial;
   }
-  
+
   @Override
   public IO<Either<Unit, S>> update(A last, S state) {
     return update.update(last, state);
   }
-  
+
   @Override
   public B extract(A last, S state) {
     return extract.extract(last, state);
@@ -230,16 +230,16 @@
   @Override
   public <C> Schedule<A, C> map(Function1<? super B, ? extends C> mapper) {
     return ScheduleImpl.of(
-      initial, 
-      update, 
+      initial,
+      update,
       (a, s) -> mapper.apply(extract(a, s)));
   }
 
   @Override
   public <C> Schedule<C, B> contramap(Function1<? super C, ? extends A> comap) {
     return ScheduleImpl.of(
-      initial, 
-      (c, s) -> update(comap.apply(c), s), 
+      initial,
+      (c, s) -> update(comap.apply(c), s),
       (c, s) -> extract(comap.apply(c), s));
   }
 
@@ -248,6 +248,7 @@
     return andThenEither(next).map(ScheduleImpl::merge);
   }
 
+  @Override
   public <C> Schedule<A, Either<B, C>> andThenEither(Schedule<A, C> next) {
     return doAndThenEither((ScheduleImpl<?, A, C>) next);
   }
@@ -265,24 +266,24 @@
   @Override
   public <Z> Schedule<A, Z> foldM(Z zero, Function2<? super Z, ? super B, ? extends IO<Either<Unit, ? extends Z>>> next) {
     return ScheduleImpl.of(
-      initial.map(s -> Tuple.of(s, zero)), 
+      initial.map(s -> Tuple.of(s, zero)),
       (a, sz) -> {
         IO<Either<Unit, S>> update = update(a, sz._1());
         IO<Either<Unit, Z>> other = next.apply(sz._2(), extract(a, sz._1())).map(Either::narrow);
         return IO.parMap2(update, other, (x, y) -> ScheduleImpl.<Unit, S, Z, Tuple2<S, Z>>map2(x, y, Tuple::of));
-      }, 
+      },
       (a, sz) -> sz._2());
   }
 
   @Override
   public Schedule<A, B> addDelayM(Function1<B, IO<Duration>> map) {
     return updated(u -> (a, s) -> {
-      IO<Either<Unit, Tuple2<Duration, S>>> map2 = 
+      IO<Either<Unit, Tuple2<Duration, S>>> map2 =
         IO.parMap2(
-          map.apply(extract(a, s)), 
-          u.update(a, s), 
+          map.apply(extract(a, s)),
+          u.update(a, s),
           (duration, either) -> either.map(x -> Tuple.of(duration, x)));
-      
+
       return map2.flatMap((Either<Unit, Tuple2<Duration, S>> either) -> {
         IO<Unit> fold = either.fold(IO::pure, tuple -> IO.sleep(tuple._1()));
         return fold.map(ignore -> either.map(Tuple2<Duration, S>::_2));
@@ -324,7 +325,7 @@
                     IO<Either<Unit, T>> u = other.update(a, t);
                     return u.map(e -> e.map(Either::<S, T>right));
                   });
-              IO<Either<Unit, Either<S, T>>> map = 
+              IO<Either<Unit, Either<S, T>>> map =
                   this.update(a, s).map(e -> e.map(Either::<S, T>left));
               return IO.parMap2(map, orElse, Either<Unit, Either<S, T>>::orElse);
             },
@@ -361,11 +362,12 @@
   private static <A, B> IO<Tuple2<A, B>> tuple(IO<A> a, IO<B> b) {
     return IO.parMap2(a, b, Tuple::of);
   }
-  
-  private static<E, A, B, C> Either<E, C> map2(Either<E, A> a, Either<E, B> b, Function2<? super A, ? super B, ? extends C> map) {
+
+  private static<E, A, B, C> Either<E, C> map2(
+      Either<E, A> a, Either<E, B> b, Function2<? super A, ? super B, ? extends C> map) {
     return a.flatMap(x -> b.map(y -> map.apply(x, y)));
   }
-  
+
   private static <A> A merge(Either<A, A> either) {
     return either.fold(Function1.identity(), Function1.identity());
   }
@@ -373,9 +375,9 @@
   private ScheduleImpl<S, A, B> updated(Function1<Update<S, A>, Update<S, A>> update) {
     return ScheduleImpl.of(initial, update.apply(this.update), this.extract);
   }
-  
+
   public static <S, A, B> ScheduleImpl<S, A, B> of(
-      IO<S> initial, 
+      IO<S> initial,
       Update<S, A> update,
       Extract<A, S, B> extract) {
     return new ScheduleImpl<>(initial, update, extract);
diff --git a/src/test/java/com/github/tonivade/vavr/effect/ScheduleTest.java b/src/test/java/com/github/tonivade/vavr/effect/ScheduleTest.java
index 7cdd9fa..260e441 100644
--- a/src/test/java/com/github/tonivade/vavr/effect/ScheduleTest.java
+++ b/src/test/java/com/github/tonivade/vavr/effect/ScheduleTest.java
@@ -14,7 +14,6 @@
 import java.time.Duration;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
@@ -22,7 +21,6 @@
 import io.vavr.Tuple2;
 import io.vavr.collection.List;
 import io.vavr.collection.Seq;
-import io.vavr.control.Either;
 
 @ExtendWith(MockitoExtension.class)
 class ScheduleTest {
@@ -136,17 +134,16 @@
   }
 
   @Test
-  @Disabled("I don't understand very well this")
   void compose(@Mock Consumer<String> console) {
     Schedule<Unit, Integer> two =
-      Schedule.<Unit>recurs(1).compose(Schedule.<Integer>recurs(1));
+      Schedule.<Unit>recurs(2).compose(Schedule.<Integer>recurs(2));
 
     IO<Unit> print = IO.exec(() -> console.accept("hola"));
     IO<Integer> repeat = print.repeat(two);
 
     Integer provide = repeat.unsafeRunSync();
 
-    assertEquals(Either.right(1), provide);
+    assertEquals(2, provide);
     verify(console, times(3)).accept("hola");
   }