Package com.github.tonivade.purefun.typeclasses

Interface Schedule<F extends Kind<F,?>,A,B>

All Superinterfaces:

Kind<Schedule<F,A,?>,B>, ScheduleOf<F,A,B>

All Known Implementing Classes:

ScheduleImpl

public sealed interface Schedule<F extends Kind<F,?>,A,B>
extends ScheduleOf<F,A,B>
permits ScheduleImpl<F,S,A,B>

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static interface	Schedule.Extract<A,S,B>
static interface	Schedule.Of<F extends Kind<F,?>>
static interface	Schedule.Update<F extends Kind<F,?>,S,A>

Method Summary

Modifier and Type	Method	Description
default Schedule<F,A,B>	addDelay(Function1<B,Duration> map)
Schedule<F,A,B>	addDelayM(Function1<B,Kind<F,Duration>> map)
default Schedule<F,A,B>	andThen(Schedule<F,A,B> next)
<C> Schedule<F,A,Either<B,C>>	andThenEither(Schedule<F,A,C> next)
default <C> Schedule<F,A,C>	as(C value)
Schedule<F,A,B>	check(Function2<A,B,Kind<F,Boolean>> condition)
default Schedule<F,A,Sequence<B>>	collectAll()
<C> Schedule<F,A,C>	compose(Schedule<F,B,C> other)
<C> Schedule<F,C,B>	contramap(Function1<? super C,? extends A> comap)
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	delayed(Schedule<F,A,Duration> schedule, F... reified)
default <C, D> Schedule<F,C,D>	dimap(Function1<? super C,? extends A> comap, Function1<? super B,? extends D> map)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	doUntil(Matcher1<A> condition, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	doUntilM(Function1<A,Kind<F,Boolean>> condition, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	doWhile(Matcher1<A> condition, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	doWhileM(Function1<A,Kind<F,Boolean>> condition, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	exponential(Duration delay, double factor, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	exponential(Duration delay, F... reified)
default <Z> Schedule<F,A,Z>	fold(Z zero, Function2<? super Z,? super B,? extends Z> next)
<Z> Schedule<F,A,Z>	foldM(Z zero, Function2<? super Z,? super B,? extends Kind<F,Either<Unit,? extends Z>>> next)
static <F extends Kind<F, ?>, A> Schedule<F,A,Integer>	forever(F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	identity(F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	linear(Duration delay, F... reified)
<C> Schedule<F,A,C>	map(Function1<? super B,? extends C> mapper)
MonadDefer<F>	monadDefer()
static <F extends Kind<F, ?>, A> Schedule<F,A,Unit>	never(F... reified)
static <F extends Kind<F, ?>> Schedule.Of<F>	of(MonadDefer<F> monad)
static <F extends Kind<F, ?>> Schedule.Of<F>	of(F... reified)
static <F extends Kind<F, ?>> Schedule.Of<F>	of(Class<F> type)
static <F extends Kind<F, ?>, A> Schedule<F,A,Unit>	once(F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,Integer>	recurs(int times, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,Tuple2<Integer,Integer>>	recursSpaced(Duration delay, int times, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,Integer>	spaced(Duration delay, F... reified)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	succeed(B value, F... reified)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	unfold(B initial, Operator1<B> next, F... reified)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	unfoldM(Kind<F,B> initial, Function1<B,Kind<F,Either<Unit,B>>> next, F... reified)
default Schedule<F,A,Unit>	unit()
default Schedule<F,A,B>	untilInput(Matcher1<A> condition)
Schedule<F,A,B>	untilInputM(Function1<A,Kind<F,Boolean>> condition)
default Schedule<F,A,B>	untilOutput(Matcher1<B> condition)
Schedule<F,A,B>	untilOutputM(Function1<B,Kind<F,Boolean>> condition)
default Schedule<F,A,B>	whileInput(Matcher1<A> condition)
default Schedule<F,A,B>	whileInputM(Function1<A,Kind<F,Boolean>> condition)
default Schedule<F,A,B>	whileOutput(Matcher1<B> condition)
default Schedule<F,A,B>	whileOutputM(Function1<B,Kind<F,Boolean>> condition)
<C> Schedule<F,A,Tuple2<B,C>>	zip(Schedule<F,A,C> other)
default <C> Schedule<F,A,B>	zipLeft(Schedule<F,A,C> other)
default <C> Schedule<F,A,C>	zipRight(Schedule<F,A,C> other)

Methods inherited from interface com.github.tonivade.purefun.Kind

fix, kind

Method Details

of

static <F extends Kind<F,
?>> Schedule.Of<F> of(MonadDefer<F> monad)

of

static <F extends Kind<F,
?>> Schedule.Of<F> of(Class<F> type)

of

@SafeVarargs
static <F extends Kind<F,
?>> Schedule.Of<F> of(F... reified)

monadDefer

MonadDefer<F> monadDefer()

map

<C> Schedule<F,A,C> map(Function1<? super B,? extends C> mapper)

contramap

<C> Schedule<F,C,B> contramap(Function1<? super C,? extends A> comap)

dimap

default <C,
D> Schedule<F,C,D> dimap(Function1<? super C,? extends A> comap,
 Function1<? super B,? extends D> map)

as

default <C> Schedule<F,A,C> as(C value)

unit

default Schedule<F,A,Unit> unit()

andThen

default Schedule<F,A,B> andThen(Schedule<F,A,B> next)

andThenEither

<C> Schedule<F,A,Either<B,C>> andThenEither(Schedule<F,A,C> next)

zip

<C> Schedule<F,A,Tuple2<B,C>> zip(Schedule<F,A,C> other)

zipLeft

default <C> Schedule<F,A,B> zipLeft(Schedule<F,A,C> other)

zipRight

default <C> Schedule<F,A,C> zipRight(Schedule<F,A,C> other)

compose

<C> Schedule<F,A,C> compose(Schedule<F,B,C> other)

collectAll

default Schedule<F,A,Sequence<B>> collectAll()

fold

default <Z> Schedule<F,A,Z> fold(Z zero,
 Function2<? super Z,? super B,? extends Z> next)

foldM

<Z> Schedule<F,A,Z> foldM(Z zero,
 Function2<? super Z,? super B,? extends Kind<F,Either<Unit,? extends Z>>> next)

addDelay

default Schedule<F,A,B> addDelay(Function1<B,Duration> map)

addDelayM

Schedule<F,A,B> addDelayM(Function1<B,Kind<F,Duration>> map)

whileInput

default Schedule<F,A,B> whileInput(Matcher1<A> condition)

whileInputM

default Schedule<F,A,B> whileInputM(Function1<A,Kind<F,Boolean>> condition)

whileOutput

default Schedule<F,A,B> whileOutput(Matcher1<B> condition)

whileOutputM

default Schedule<F,A,B> whileOutputM(Function1<B,Kind<F,Boolean>> condition)

untilInput

default Schedule<F,A,B> untilInput(Matcher1<A> condition)

untilInputM

Schedule<F,A,B> untilInputM(Function1<A,Kind<F,Boolean>> condition)

untilOutput

default Schedule<F,A,B> untilOutput(Matcher1<B> condition)

untilOutputM

Schedule<F,A,B> untilOutputM(Function1<B,Kind<F,Boolean>> condition)

check

Schedule<F,A,B> check(Function2<A,B,Kind<F,Boolean>> condition)

once

@SafeVarargs
static <F extends Kind<F,
?>,
A> Schedule<F,A,Unit> once(F... reified)

recurs

@SafeVarargs
static <F extends Kind<F,
?>,
A>
Schedule<F,A,Integer> recurs(int times,
 F... reified)

spaced

@SafeVarargs
static <F extends Kind<F,
?>,
A>
Schedule<F,A,Integer> spaced(Duration delay,
 F... reified)

linear

@SafeVarargs
static <F extends Kind<F,
?>,
A>
Schedule<F,A,Duration> linear(Duration delay,
 F... reified)

exponential

@SafeVarargs
static <F extends Kind<F,
?>,
A>
Schedule<F,A,Duration> exponential(Duration delay,
 F... reified)

exponential

@SafeVarargs
static <F extends Kind<F,
?>,
A>
Schedule<F,A,Duration> exponential(Duration delay,
 double factor,
 F... reified)

delayed

@SafeVarargs
static <F extends Kind<F,
?>,
A>
Schedule<F,A,Duration> delayed(Schedule<F,A,Duration> schedule,
 F... reified)

recursSpaced

@SafeVarargs
static <F extends Kind<F,
?>,
A>
Schedule<F,A,Tuple2<Integer,Integer>> recursSpaced(Duration delay,
 int times,
 F... reified)

never

@SafeVarargs
static <F extends Kind<F,
?>,
A> Schedule<F,A,Unit> never(F... reified)

forever

@SafeVarargs
static <F extends Kind<F,
?>,
A>
Schedule<F,A,Integer> forever(F... reified)

succeed

@SafeVarargs
static <F extends Kind<F,
?>,
A,
B> Schedule<F,A,B> succeed(B value,
 F... reified)

identity

@SafeVarargs
static <F extends Kind<F,
?>,
A> Schedule<F,A,A> identity(F... reified)

doWhile

@SafeVarargs
static <F extends Kind<F,
?>,
A> Schedule<F,A,A> doWhile(Matcher1<A> condition,
 F... reified)

doWhileM

@SafeVarargs
static <F extends Kind<F,
?>,
A> Schedule<F,A,A> doWhileM(Function1<A,Kind<F,Boolean>> condition,
 F... reified)

doUntil

@SafeVarargs
static <F extends Kind<F,
?>,
A> Schedule<F,A,A> doUntil(Matcher1<A> condition,
 F... reified)

doUntilM

@SafeVarargs
static <F extends Kind<F,
?>,
A> Schedule<F,A,A> doUntilM(Function1<A,Kind<F,Boolean>> condition,
 F... reified)

unfold

@SafeVarargs
static <F extends Kind<F,
?>,
A,
B> Schedule<F,A,B> unfold(B initial,
 Operator1<B> next,
 F... reified)

unfoldM

@SafeVarargs
static <F extends Kind<F,
?>,
A,
B> Schedule<F,A,B> unfoldM(Kind<F,B> initial,
 Function1<B,Kind<F,Either<Unit,B>>> next,
 F... reified)