How to use com.oath.cyclops.types.functor

@Override
default <R> IO<R> retry(Function<? super T, ? extends R> fn) {
  return (IO<R>)ReactiveTransformable.super.retry(fn);
}
default <R> IO<R> checkedRetry(CheckedFunction<? super T,? extends R> checkedFunction, int retries, long delay, TimeUnit timeUnit){

@Override
default LazyEither3<LT1, LT2, RT> bipeek(final Consumer<? super LT2> c1, final Consumer<? super RT> c2) {
  return (LazyEither3<LT1, LT2, RT>) BiTransformable.super.bipeek(c1, c2);
}

@Override
default LazyEither3<LT1, LT2, RT> peek(final Consumer<? super RT> c) {
  return (LazyEither3<LT1, LT2, RT>) Transformable.super.peek(c);
}

/**
 * Peek at the current value of this Transformable, without transforming it
 *
 * <pre>
 * {@code
 *
 *
 *    of(1,2,3).map(System.out::println)
 *
 *    1
 *    2
 *    3
 *
 * }
 * </pre>
 * @param c Consumer that recieves each element from this Transformable
 * @return Transformable that will peek at each value
 */
default Transformable<T> peek(final Consumer<? super T> c) {
  return map(input -> {
    c.accept(input);
    return input;
  });
}

@Override
default Traversable<T> filterNot(final Predicate<? super T> predicate) {
  return (Traversable<T>)FilterableTransformable.super.filterNot(predicate);
}

/**
 * Peek at two data types simulatanously (typically to perform a side-effect with each data point)
 *
 * <pre>
 * {@code
 *     MapX<String,Integer> map = MapXs.of("hello",2);
 *     map.bipeek(s->System.out.pritnln("key = " + s),System.out::println);
 * }
 * </pre>
 *
 * @param c1 consumer for the first type
 * @param c2 consumer for the second type
 * @return New BiTransformable with the same data
 */
default BiTransformable<T1, T2> bipeek(final Consumer<? super T1> c1, final Consumer<? super T2> c2) {
  return bimap(input -> {
    c1.accept(input);
    return input;
  } , input -> {
    c2.accept(input);
    return input;
  });
}

@Override
default Either<LT, RT> bipeek(Consumer<? super LT> c1, Consumer<? super RT> c2) {
  return (Either<LT, RT>)BiTransformable.super.bipeek(c1, c2);
}

@Override
default LazyEither5<LT1, LT2, LT3,LT4, RT> peek(final Consumer<? super RT> c) {
  return (LazyEither5<LT1, LT2, LT3, LT4, RT>) Transformable.super.peek(c);
}

/**
 * Retry a transformation if it fails. Default settings are to retry up to 7
 * times, with an doubling backoff period starting @ 2 seconds delay before
 * retry.
 *
 *
 * @param fn
 *            Function to retry if fails
 *
 */
default <R> Transformable<R> retry(final Function<? super T, ? extends R> fn) {
  return retry(fn, 7, 2, TimeUnit.SECONDS);
}

public static <T> Unrestricted<T> liftF(final Transformable<T> functor){
  return new Suspend<T>(functor.map(Unrestricted::done));
}

@Override
default ImmutableMap<K, V> bipeek(Consumer<? super K> c1, Consumer<? super V> c2) {
  return (ImmutableMap<K,V>)BiTransformable.super.bipeek(c1,c2);
}

@Override
default ImmutableMap<K,V> peek(Consumer<? super V> c) {
  return (ImmutableMap<K,V>)Transformable.super.peek(c);
}

@Override
default <R> IO<R> retry(Function<? super T, ? extends R> fn, int retries, long delay, TimeUnit timeUnit) {
  return (IO<R>)ReactiveTransformable.super.retry(fn,retries,delay,timeUnit);
}

@Override
default LazyEither4<LT1, LT2, LT3, RT> bipeek(final Consumer<? super LT3> c1, final Consumer<? super RT> c2) {
  return (LazyEither4<LT1, LT2, LT3, RT>) BiTransformable.super.bipeek(c1, c2);
}

@Override
public Tuple1<T> peek(Consumer<? super T> c) {
  return (Tuple1<T>)Transformable.super.peek(c);
}

/**
 * Retry a transformation if it fails. Retries up to <b>retries</b>
 * times, with an doubling backoff period starting @ <b>delay</b> TimeUnits delay before
 * retry.
 *
 * <pre>
 * {@code
 *
 *
 *
 *         String result = ReactiveSeq.of( 1,  2, 3)
 *                 .retry(this::makeIOCall, 7, 2, TimeUnit.SECONDS)
 *                 .firstValue();
 *
 *         //result = [service call result]
 * }
 * </pre>
 *
 * @param fn
 *            Function to retry if fails
 * @param retries
 *            Number of retries
 * @param delay
 *            Delay in TimeUnits
 * @param timeUnit
 *            TimeUnit to use for delay
 */
default <R> ReactiveSeq<R> retry(final Function<? super T, ? extends R> fn, final int retries, final long delay, final TimeUnit timeUnit) {
  return (ReactiveSeq) ReactiveTransformable.super.retry(fn, retries, delay, timeUnit);
}

@Override
default LazyEither5<LT1, LT2, LT3, LT4, RT> bipeek(final Consumer<? super LT4> c1, final Consumer<? super RT> c2) {
  return (LazyEither5<LT1, LT2, LT3,LT4, RT>) BiTransformable.super.bipeek(c1, c2);
}

@Override
default LazyEither4<LT1, LT2, LT3, RT> peek(final Consumer<? super RT> c) {
  return (LazyEither4<LT1, LT2, LT3, RT>) Transformable.super.peek(c);
}

@Override
default Ior<LT, RT> bipeek(final Consumer<? super LT> c1, final Consumer<? super RT> c2) {
  return (Ior<LT, RT>) BiTransformable.super.bipeek(c1, c2);
}

@Override
public LazyImmutable<T> peek(final Consumer<? super T> c) {
  return (LazyImmutable<T>) Transformable.super.peek(c);
}