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 f3542fe..5379e95 100644
--- a/src/main/java/com/github/tonivade/vavr/effect/IO.java
+++ b/src/main/java/com/github/tonivade/vavr/effect/IO.java
@@ -150,7 +150,7 @@
   }
 
   default IO<T> repeat(int times) {
-    return repeat(this, unit(), times);
+    return repeat(Schedule.<T>recurs(times).zipRight(Schedule.identity()));
   }
 
   default IO<T> repeat(Duration delay) {
@@ -158,7 +158,23 @@
   }
 
   default IO<T> repeat(Duration delay, int times) {
-    return repeat(this, sleep(delay), times);
+    return repeat(Schedule.<T>recursSpaced(delay, times).zipRight(Schedule.identity()));
+  }
+  
+  default <B> IO<B> repeat(Schedule<T, B> schedule) {
+    return repeatOrElse(schedule, (e, b) -> raiseError(e));
+  }
+
+  default <B> IO<B> repeatOrElse(
+      Schedule<T, B> schedule,
+      Function2<Throwable, Option<B>, IO<B>> orElse) {
+    return repeatOrElseEither(schedule, orElse).map(IO::merge);
+  }
+
+  default <B, C> IO<Either<C, B>> repeatOrElseEither(
+      Schedule<T, B> schedule,
+      Function2<Throwable, Option<B>, IO<C>> orElse) {
+    return new Repeat<>(this, schedule, orElse).run();
   }
 
   default IO<T> retry() {
@@ -166,7 +182,7 @@
   }
 
   default IO<T> retry(int maxRetries) {
-    return retry(this, unit(), maxRetries);
+    return retry(Schedule.recurs(maxRetries));
   }
 
   default IO<T> retry(Duration delay) {
@@ -174,7 +190,23 @@
   }
 
   default IO<T> retry(Duration delay, int maxRetries) {
-    return retry(this, sleep(delay), maxRetries);
+    return retry(Schedule.<Throwable>recursSpaced(delay, maxRetries));
+  }
+  
+  default <B> IO<T> retry(Schedule<Throwable, B> schedule) {
+    return retryOrElse(schedule, (e, b) -> raiseError(e));
+  }
+
+  default <B> IO<T> retryOrElse(
+      Schedule<Throwable, B> schedule,
+      Function2<Throwable, B, IO<T>> orElse) {
+    return retryOrElseEither(schedule, orElse).map(IO::merge);
+  }
+
+  default <B, C> IO<Either<B, T>> retryOrElseEither(
+      Schedule<Throwable, C> schedule,
+      Function2<Throwable, C, IO<B>> orElse) {
+    return new Retry<>(this, schedule, orElse).run();
   }
 
   @SuppressWarnings("unchecked")
@@ -419,6 +451,10 @@
     return task.fold(() -> Either.left(new NoSuchElementException()), Either::right);
   }
   
+  private static <A> A merge(Either<A, A> either) {
+    return either.fold(Function1.identity(), Function1.identity());
+  }
+  
   @SuppressWarnings("serial")
   private static <A, B> PartialFunction<A, B> partialFunction(Predicate<? super A> matcher, Function1<? super A, ? extends B> function) {
     return new PartialFunction<>() {
@@ -542,22 +578,6 @@
     return promise;
   }
 
-  private static <T> IO<T> repeat(IO<T> self, IO<Unit> pause, int times) {
-    return self.redeemWith(IO::raiseError, value -> {
-      if (times > 0) {
-        return pause.andThen(repeat(self, pause, times - 1));
-      } else return IO.pure(value);
-    });
-  }
-
-  private static <T> IO<T> retry(IO<T> self, IO<Unit> pause, int maxRetries) {
-    return self.redeemWith(error -> {
-      if (maxRetries > 0) {
-        return pause.andThen(retry(self, pause.repeat(), maxRetries - 1));
-      } else return IO.raiseError(error);
-    }, IO::pure);
-  }
-
   final class Pure<T> implements IO<T> {
 
     private final T value;
@@ -662,6 +682,64 @@
   }
 }
 
+final class Repeat<S, A, B, C> {
+  
+  private final IO<A> current;
+  private final ScheduleImpl<S, A, B> schedule;
+  private final Function2<Throwable, Option<B>, IO<C>> orElse;
+
+  @SuppressWarnings("unchecked")
+  Repeat(IO<A> current, Schedule<A, B> schedule, Function2<Throwable, Option<B>, IO<C>> orElse) {
+    this.current = Objects.requireNonNull(current);
+    this.schedule = (ScheduleImpl<S, A, B>) Objects.requireNonNull(schedule);
+    this.orElse = Objects.requireNonNull(orElse);
+  }
+  
+  IO<Either<C, B>> run() {
+    return current.attempt().flatMap(either -> either.fold(
+        error -> orElse.apply(error, Option.none()).map(Either::<C, B>left),
+        a -> schedule.initial().flatMap(s -> loop(a, s))));
+  }
+
+  private IO<Either<C, B>> loop(A later, S state) {
+    return schedule.update(later, state).flatMap(decision -> decision.fold(
+      ignore -> IO.pure(Either.right(schedule.extract(later, state))), 
+      s -> current.attempt().flatMap(either -> either.fold(
+        e -> orElse.apply(e, Option.some(schedule.extract(later, state))).map(Either::<C, B>left), 
+        a -> loop(a, s)))));
+  }
+}
+
+final class Retry<A, B, S> {
+
+  private final IO<A> current;
+  private final ScheduleImpl<S, Throwable, S> schedule;
+  private final Function2<Throwable, S, IO<B>> orElse;
+
+  @SuppressWarnings("unchecked")
+  Retry(IO<A> current, Schedule<Throwable, S> schedule, Function2<Throwable, S, IO<B>> orElse) {
+    this.current = Objects.requireNonNull(current);
+    this.schedule = (ScheduleImpl<S, Throwable, S>) Objects.requireNonNull(schedule);
+    this.orElse = Objects.requireNonNull(orElse);
+  }
+
+  public IO<Either<B, A>> run() {
+    return schedule.initial().flatMap(this::loop);
+  }
+
+  private IO<Either<B, A>> loop(S state) {
+    return current.attempt().flatMap(either -> either.fold(
+      error -> {
+        IO<Either<Unit, S>> update = schedule.update(error, state);
+        return update.flatMap(decision -> decision.fold(
+          ignore -> orElse.apply(error, state).map(Either::<B, A>left), 
+          this::loop));
+      }, 
+      a -> IO.pure(Either.right(a)))
+      );
+  }
+}
+
 sealed interface IOConnection {
   
   IOConnection UNCANCELLABLE = new Uncancellable();
diff --git a/src/test/java/com/github/tonivade/vavr/effect/ScheduleTest.java b/src/test/java/com/github/tonivade/vavr/effect/ScheduleTest.java
new file mode 100644
index 0000000..b6843f4
--- /dev/null
+++ b/src/test/java/com/github/tonivade/vavr/effect/ScheduleTest.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2022, Antonio Gabriel Muñoz Conejo <antoniogmc at gmail dot com>
+ * Distributed under the terms of the MIT License
+ */
+package com.github.tonivade.vavr.effect;
+
+import static com.github.tonivade.vavr.effect.Unit.unit;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+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;
+import org.mockito.junit.jupiter.MockitoExtension;
+import io.vavr.Tuple2;
+import io.vavr.collection.List;
+import io.vavr.collection.Seq;
+import io.vavr.control.Either;
+
+@ExtendWith(MockitoExtension.class)
+class ScheduleTest {
+
+  @Test
+  void repeat(@Mock Consumer<String> console) {
+    IO<Unit> print = IO.exec(() -> console.accept("hola"));
+    Schedule<Unit, Unit> schedule = Schedule.<Unit>recurs(2).zipRight(Schedule.identity());
+    
+    IO<Unit> repeat = print.repeat(schedule);
+    
+    Unit result = repeat.unsafeRunSync();
+    
+    assertEquals(unit(), result);
+    verify(console, times(3)).accept("hola");
+  }
+
+  @Test
+  void repeatDelay(@Mock Consumer<String> console) {
+    IO<Unit> print = IO.exec(() -> console.accept("hola"));
+    Schedule<Unit, Unit> recurs = Schedule.<Unit>recurs(2).zipRight(Schedule.identity());
+    Schedule<Unit, Integer> spaced = Schedule.spaced(Duration.ofMillis(500));
+    Schedule<Unit, Unit> schedule = recurs.zipLeft(spaced);
+
+    IO<Unit> repeat = print.repeat(schedule);
+    IO<Tuple2<Duration, Unit>> timed = repeat.timed();
+    
+    Tuple2<Duration, Unit> result = timed.unsafeRunSync();
+    
+    assertTrue(result._1().toMillis() > 1000);
+    verify(console, times(3)).accept("hola");
+  }
+  
+  @Test
+  void noRepeat(@Mock Consumer<String> console) {
+    IO<Unit> print = IO.exec(() -> console.accept("hola"));
+    IO<Unit> repeat = print.repeat(Schedule.never());
+    
+    Unit result = repeat.unsafeRunSync();
+    
+    assertEquals(unit(), result);
+    verify(console).accept("hola");
+  }
+
+  @Test
+  void retry(@Mock Supplier<String> console) {
+    when(console.get())
+      .thenThrow(RuntimeException.class)
+      .thenReturn("hola");
+
+    IO<String> read = IO.task(console::get);
+    IO<String> retry = read.retry(Schedule.recurs(1));
+    
+    String provide = retry.unsafeRunSync();
+    
+    assertEquals("hola", provide);
+    verify(console, times(2)).get();
+  }
+
+  @Test
+  void retryDelay(@Mock Supplier<String> console) {
+    when(console.get()).thenThrow(RuntimeException.class).thenReturn("hola");
+
+    IO<String> read = IO.task(console::get);
+    Schedule<Throwable, Integer> recurs = Schedule.recurs(2);
+    Schedule<Throwable, Integer> spaced = Schedule.spaced(Duration.ofMillis(500));
+    IO<Tuple2<Duration, String>> retry = read.retry(recurs.zip(spaced)).timed();
+    
+    Tuple2<Duration, String> result = retry.unsafeRunSync();
+    
+    assertTrue(result._1().toMillis() > 500);
+    assertEquals("hola", result._2());
+    verify(console, times(2)).get();
+  }
+  
+  @Test
+  void noRetry(@Mock Supplier<String> console) {
+    when(console.get()).thenThrow(UnsupportedOperationException.class).thenReturn("hola");
+    
+    IO<String> read = IO.task(console::get);
+    IO<String> retry = read.retry(Schedule.never());
+    
+    assertThrows(UnsupportedOperationException.class, retry::unsafeRunSync);
+  }
+  
+  @Test
+  void andThen(@Mock Consumer<String> console) {
+    Schedule<Unit, Integer> two =
+        Schedule.<Unit>recurs(1).andThen(Schedule.<Unit>recurs(1));
+
+    IO<Unit> print = IO.exec(() -> console.accept("hola"));
+    IO<Integer> repeat = print.repeat(two);
+    
+    Integer provide = repeat.unsafeRunSync();
+    
+    assertEquals(1, provide);
+    verify(console, times(3)).accept("hola");
+  }
+  
+  @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));
+
+    IO<Unit> print = IO.exec(() -> console.accept("hola"));
+    IO<Integer> repeat = print.repeat(two);
+    
+    Integer provide = repeat.unsafeRunSync();
+    
+    assertEquals(Either.right(1), provide);
+    verify(console, times(3)).accept("hola");
+  }
+  
+  @Test
+  void collect() {
+    IO<Unit> pure = IO.unit();
+    
+    Schedule<Unit, Seq<Integer>> schedule = Schedule.<Unit>recurs(5).collectAll().zipLeft(Schedule.identity());
+    IO<Seq<Integer>> repeat = pure.repeat(schedule);
+    
+    Seq<Integer> result = repeat.unsafeRunSync();
+    
+    assertEquals(List.of(0, 1, 2, 3, 4), result);
+  }
+}