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 8e8e1e4..f3542fe 100644
--- a/src/main/java/com/github/tonivade/vavr/effect/IO.java
+++ b/src/main/java/com/github/tonivade/vavr/effect/IO.java
@@ -113,22 +113,6 @@
   default <X extends Throwable> IO<T> recover(Class<X> type, Function1<? super X, ? extends T> function) {
     return recoverWith(partialFunction(error -> error.getClass().equals(type), t -> function.andThen(IO::pure).apply((X) t)));
   }
-  
-  @SuppressWarnings("serial")
-  static <A, B> PartialFunction<A, B> partialFunction(Predicate<? super A> matcher, Function1<? super A, ? extends B> function) {
-    return new PartialFunction<>() {
-      
-      @Override
-      public boolean isDefinedAt(A value) {
-        return matcher.test(value);
-      }
-      
-      @Override
-      public B apply(A t) {
-        return function.apply(t);
-      }
-    };
-  }
 
   default IO<T> recoverWith(PartialFunction<? super Throwable, IO<? extends T>> mapper) {
     return new Recover<>(this, mapper);
@@ -434,6 +418,22 @@
   private static <T> Either<Throwable, T> toEither(Option<? extends T> task) {
     return task.fold(() -> Either.left(new NoSuchElementException()), Either::right);
   }
+  
+  @SuppressWarnings("serial")
+  private static <A, B> PartialFunction<A, B> partialFunction(Predicate<? super A> matcher, Function1<? super A, ? extends B> function) {
+    return new PartialFunction<>() {
+      
+      @Override
+      public boolean isDefinedAt(A value) {
+        return matcher.test(value);
+      }
+      
+      @Override
+      public B apply(A t) {
+        return function.apply(t);
+      }
+    };
+  }
 
   private static Supplier<Unit> asSupplier(CheckedRunnable task) {
     return () -> {
diff --git a/src/main/java/com/github/tonivade/vavr/effect/Schedule.java b/src/main/java/com/github/tonivade/vavr/effect/Schedule.java
new file mode 100644
index 0000000..dc65f7d
--- /dev/null
+++ b/src/main/java/com/github/tonivade/vavr/effect/Schedule.java
@@ -0,0 +1,383 @@
+/*
+ * Copyright (c) 2018-2021, 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 java.time.Duration;
+import java.util.Objects;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+import io.vavr.Function1;
+import io.vavr.Function2;
+import io.vavr.Tuple;
+import io.vavr.Tuple2;
+import io.vavr.collection.List;
+import io.vavr.collection.Seq;
+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);
+
+  default <C, D> Schedule<C, D> dimap(Function1<? super C, ? extends A> comap, Function1<? super B, ? extends D> map) {
+    Schedule<C, B> contramap = contramap(comap);
+    return contramap.map(map);
+  }
+
+  default <C> Schedule<A, C> as(C value) {
+    return map(ignore -> value);
+  }
+
+  default Schedule<A, Unit> unit() {
+    return as(Unit.unit());
+  }
+
+  default Schedule<A, B> andThen(Schedule<A, B> next) {
+    return andThenEither(next).map(Schedule::merge);
+  }
+
+  <C> Schedule<A, Either<B, C>> andThenEither(Schedule<A, C> next);
+
+  <C> Schedule<A, Tuple2<B, C>> zip(Schedule<A, C> other);
+
+  default <C> Schedule<A, B> zipLeft(Schedule<A, C> other) {
+    return zip(other).map(Tuple2::_1);
+  }
+
+  default <C> Schedule<A, C> zipRight(Schedule<A, C> other) {
+    return zip(other).map(Tuple2::_2);
+  }
+
+  <C> Schedule<A, C> compose(Schedule<B, C> other);
+
+  default Schedule<A, Seq<B>> collectAll() {
+    return this.<Seq<B>>fold(List.<B>empty(), Seq::append);
+  }
+
+  default <Z> Schedule<A, Z> fold(Z zero, Function2<? super Z, ? super B, ? extends Z> next) {
+    return foldM(zero, (z, b) -> IO.pure(next.andThen(Either::<Unit, Z>right).apply(z, b)));
+  }
+
+  <Z> Schedule<A, Z> foldM(Z zero, Function2<? super Z, ? super B, ? extends IO<Either<Unit, ? extends Z>>> next);
+
+  default Schedule<A, B> addDelay(Function1<B, Duration> map) {
+    return addDelayM(map.andThen(IO::pure));
+  }
+
+  Schedule<A, B> addDelayM(Function1<B, IO<Duration>> map);
+
+  default Schedule<A, B> whileInput(Predicate<A> condition) {
+    return whileInputM(asFunction(condition).andThen(IO::pure));
+  }
+
+  default Schedule<A, B> whileInputM(Function1<A, IO<Boolean>> condition) {
+    return check((a, b) -> condition.apply(a));
+  }
+
+  default Schedule<A, B> whileOutput(Predicate<B> condition) {
+    return whileOutputM(asFunction(condition).andThen(IO::pure));
+  }
+
+  default Schedule<A, B> whileOutputM(Function1<B, IO<Boolean>> condition) {
+    return check((a, b) -> condition.apply(b));
+  }
+
+  default Schedule<A, B> untilInput(Predicate<A> condition) {
+    return untilInputM(asFunction(condition).andThen(IO::pure));
+  }
+
+  Schedule<A, B> untilInputM(Function1<A, IO<Boolean>> condition);
+
+  default Schedule<A, B> untilOutput(Predicate<B> condition) {
+    return untilOutputM(asFunction(condition).andThen(IO::pure));
+  }
+
+  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();
+  }
+
+  static <A> Schedule<A, Integer> recurs(int times) {
+    return Schedule.<A>forever().whileOutput(x -> x < times);
+  }
+
+  static <A> Schedule<A, Integer> spaced(Duration delay) {
+    return Schedule.<A>forever().addDelay(x -> delay);
+  }
+
+  static <A> Schedule<A, Duration> linear(Duration delay) {
+    return delayed(Schedule.<A>forever().map(i -> delay.multipliedBy(i + 1L)));
+  }
+
+  static <A> Schedule<A, Duration> exponential(Duration delay) {
+    return exponential(delay, 2.0);
+  }
+
+  static <A> Schedule<A, Duration> exponential(Duration delay, double factor) {
+    return delayed(Schedule.<A>forever().map(i -> delay.multipliedBy((long) Math.pow(factor, i.doubleValue()))));
+  }
+
+  static <A> Schedule<A, Duration> delayed(Schedule<A, Duration> schedule) {
+    return schedule.addDelay(x -> x);
+  }
+
+  static <A> Schedule<A, Tuple2<Integer, Integer>> recursSpaced(Duration delay, int times) {
+    return Schedule.<A>recurs(times).zip(Schedule.<A>spaced(delay));
+  }
+
+  static <A> Schedule<A, Unit> never() {
+    return ScheduleImpl.of(
+      IO.pure(Unit.unit()),
+      (a, s) -> IO.pure(Either.left(Unit.unit())),
+      (a, s) -> s);
+  }
+
+  static <A> Schedule<A, Integer> forever() {
+    return unfold(0, a -> a + 1);
+  }
+
+  static <A, B> Schedule<A, B> succeed(B value) {
+    return Schedule.<A>forever().as(value);
+  }
+
+  static <A> Schedule<A, A> identity() {
+    return ScheduleImpl.of(
+      IO.pure(Unit.unit()),
+      (a, s) -> IO.pure(Either.right(Unit.unit())),
+      (a, s) -> a);
+  }
+
+  static <A> Schedule<A, A> doWhile(Predicate<A> condition) {
+    return Schedule.doWhileM(asFunction(condition).andThen(IO::pure));
+  }
+
+  static <A> Schedule<A, A> doWhileM(Function1<A, IO<Boolean>> condition) {
+    return Schedule.<A>identity().whileInputM(condition);
+  }
+
+  static <A> Schedule<A, A> doUntil(Predicate<A> condition) {
+    return doUntilM(asFunction(condition).andThen(IO::pure));
+  }
+
+  static <A> Schedule<A, A> doUntilM(Function1<A, IO<Boolean>> condition) {
+    return Schedule.<A>identity().untilInputM(condition);
+  }
+
+  static <A, B> Schedule<A, B> unfold(B initial, UnaryOperator<B> next) {
+    return unfoldM(IO.pure(initial), next.andThen(Either::<Unit, B>right).andThen(IO::pure)::apply);
+  }
+
+  static <A, B> Schedule<A, B> unfoldM(
+    IO<B> initial, Function1<B, IO<Either<Unit, B>>> next) {
+    return ScheduleImpl.<B, A, B>of(initial, (a, s) -> next.apply(s), (a, s) -> s);
+  }
+
+  @FunctionalInterface
+  interface Update<S, A> {
+
+    IO<Either<Unit, S>> update(A last, S state);
+
+  }
+
+  @FunctionalInterface
+  interface Extract<A, S, B> {
+
+    B extract(A last, S state);
+
+  }
+  
+  private static <A> A merge(Either<A, A> either) {
+    return either.fold(Function1.identity(), Function1.identity());
+  }
+
+  private static <A> Function1<A, Boolean> asFunction(Predicate<A> condition) {
+    return condition::test;
+  }
+}
+
+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);
+  }
+
+  @Override
+  public <C> Schedule<A, C> map(Function1<? super B, ? extends C> mapper) {
+    return ScheduleImpl.of(
+      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), 
+      (c, s) -> extract(comap.apply(c), s));
+  }
+
+  @Override
+  public Schedule<A, B> andThen(Schedule<A, B> next) {
+    return andThenEither(next).map(ScheduleImpl::merge);
+  }
+
+  public <C> Schedule<A, Either<B, C>> andThenEither(Schedule<A, C> next) {
+    return doAndThenEither((ScheduleImpl<?, A, C>) next);
+  }
+
+  @Override
+  public <C> Schedule<A, Tuple2<B, C>> zip(Schedule<A, C> other) {
+    return doZip((ScheduleImpl<?, A, C>) other);
+  }
+
+  @Override
+  public <C> Schedule<A, C> compose(Schedule<B, C> other) {
+    return doCompose((ScheduleImpl<?, B, C>) other);
+  }
+
+  @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)), 
+      (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.parMap2(
+          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));
+      });
+    });
+  }
+
+  @Override
+  public Schedule<A, B> untilInputM(Function1<A, IO<Boolean>> condition) {
+    return updated(u -> (a, s) -> {
+      IO<Boolean> apply = condition.apply(a);
+      return apply.flatMap(test -> test ? IO.pure(Either.left(Unit.unit())) : update(a, s));
+    });
+  }
+
+  @Override
+  public Schedule<A, B> untilOutputM(Function1<B, IO<Boolean>> condition) {
+    return updated(u -> (a, s) -> {
+      IO<Boolean> apply = condition.apply(extract(a, s));
+      return apply.flatMap(test -> test ? IO.pure(Either.<Unit, S>left(Unit.unit())) : update(a, s));
+    });
+  }
+
+  @Override
+  public Schedule<A, B> check(Function2<A, B, IO<Boolean>> condition) {
+    return updated(u -> (a, s) -> {
+      IO<Boolean> apply = condition.apply(a, extract(a, s));
+      return apply.flatMap(result -> result ? u.update(a, s) : IO.pure(Either.left(Unit.unit())));
+    });
+  }
+
+  private <T, C> ScheduleImpl<Either<S, T>, A, Either<B, C>> doAndThenEither(ScheduleImpl<T, A, C> other) {
+    return ScheduleImpl.<Either<S, T>, A, Either<B, C>>of(
+        initial.map(Either::<S, T>left),
+        (a, st) -> st.fold(
+            s -> {
+              IO<Either<Unit, Either<S, T>>> orElse =
+                  other.initial.flatMap(t -> {
+                    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 = 
+                  this.update(a, s).map(e -> e.map(Either::<S, T>left));
+              return IO.parMap2(map, orElse, Either<Unit, Either<S, T>>::orElse);
+            },
+            t -> other.update(a, t).map(e -> e.map(Either::<S, T>right))),
+        (a, st) -> st.fold(
+            s -> Either.left(this.extract(a, s)),
+            t -> Either.right(other.extract(a, t))));
+  }
+
+  private <T, C> ScheduleImpl<Tuple2<S, T>, A, Tuple2<B, C>> doZip(ScheduleImpl<T, A, C> other) {
+    return ScheduleImpl.<Tuple2<S, T>, A, Tuple2<B, C>>of(
+        tuple(this.initial, other.initial),
+        (a, st) -> {
+          IO<Either<Unit, S>> self = this.update(a, st._1());
+          IO<Either<Unit, T>> next = other.update(a, st._2());
+          return IO.parMap2(self, next, (x, y) -> map2(x, y, Tuple::of));
+        },
+        (a, st) -> Tuple.of(
+            this.extract(a, st._1),
+            other.extract(a, st._2())));
+  }
+
+  private <T, C> ScheduleImpl<Tuple2<S, T>, A, C> doCompose(ScheduleImpl<T, B, C> other) {
+    return ScheduleImpl.<Tuple2<S, T>, A, C>of(
+        tuple(this.initial, other.initial),
+        (a, st) -> {
+          IO<Either<Unit, S>> self = this.update(a, st._1());
+          IO<Either<Unit, T>> next = other.update(this.extract(a, st._1()), st._2());
+          return IO.parMap2(self, next, (x, y) -> map2(x, y, Tuple::of));
+        },
+        (a, st) -> other.extract(this.extract(a, st._1()), st._2()));
+  }
+
+  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) {
+    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());
+  }
+
+  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, 
+      Update<S, A> update,
+      Extract<A, S, B> extract) {
+    return new ScheduleImpl<>(initial, update, extract);
+  }
+}