Skip to main content Link Search Menu Expand Document (external link)
effect

Schedule overview

Added in v2.0.0

Table of contents

alternatives

either

Returns a new schedule that performs a geometric union on the intervals defined by both schedules.

Signature

export declare const either: {
  <Out2, In2, R2>(
    that: Schedule<Out2, In2, R2>
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
  <Out, In, R, Out2, In2, R2>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>
  ): Schedule<[Out, Out2], In & In2, R | R2>
}

Added in v2.0.0

eitherWith

The same as either followed by map.

Signature

export declare const eitherWith: {
  <Out2, In2, R2>(
    that: Schedule<Out2, In2, R2>,
    f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
  <Out, In, R, Out2, In2, R2>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>,
    f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
  ): Schedule<[Out, Out2], In & In2, R | R2>
}

Added in v2.0.0

constructors

asVoid

Returns a new schedule that maps the output of this schedule to unit.

Signature

export declare const asVoid: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<void, In, R>

Added in v2.0.0

collectAllInputs

A schedule that recurs anywhere, collecting all inputs into a Chunk.

Signature

export declare const collectAllInputs: <A>() => Schedule<Chunk.Chunk<A>, A>

Added in v2.0.0

count

A schedule that always recurs, which counts the number of recurrences.

Signature

export declare const count: Schedule<number, unknown, never>

Added in v2.0.0

cron

Cron schedule that recurs every interval that matches the schedule.

It triggers at the beginning of each cron interval, producing the timestamps of the cron window.

NOTE: expression parameter is validated lazily. Must be a valid cron expression.

Signature

export declare const cron: {
  (cron: Cron.Cron): Schedule<[number, number]>
  (expression: string, tz?: DateTime.TimeZone | string): Schedule<[number, number]>
}

Added in v2.0.0

dayOfMonth

Cron-like schedule that recurs every specified day of month. Won’t recur on months containing less days than specified in day param.

It triggers at zero hour of the day. Producing a count of repeats: 0, 1, 2.

NOTE: day parameter is validated lazily. Must be in range 1…31.

Signature

export declare const dayOfMonth: (day: number) => Schedule<number>

Added in v2.0.0

dayOfWeek

Cron-like schedule that recurs every specified day of each week. It triggers at zero hour of the week. Producing a count of repeats: 0, 1, 2.

NOTE: day parameter is validated lazily. Must be in range 1 (Monday)…7 (Sunday).

Signature

export declare const dayOfWeek: (day: number) => Schedule<number>

Added in v2.0.0

delayedEffect

Returns a new schedule with the specified effectfully computed delay added before the start of each interval produced by this schedule.

Signature

export declare const delayedEffect: {
  <R2>(
    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
  <Out, In, R, R2>(
    self: Schedule<Out, In, R>,
    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
  ): Schedule<Out, In, R | R2>
}

Added in v2.0.0

delayedSchedule

Takes a schedule that produces a delay, and returns a new schedule that uses this delay to further delay intervals in the resulting schedule.

Signature

export declare const delayedSchedule: <In, R>(
  schedule: Schedule<Duration.Duration, In, R>
) => Schedule<Duration.Duration, In, R>

Added in v2.0.0

delays

Returns a new schedule that outputs the delay between each occurence.

Signature

export declare const delays: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Duration.Duration, In, R>

Added in v2.0.0

duration

A schedule that can recur one time, the specified amount of time into the future.

Signature

export declare const duration: (duration: Duration.DurationInput) => Schedule<Duration.Duration>

Added in v2.0.0

elapsed

A schedule that occurs everywhere, which returns the total elapsed duration since the first step.

Signature

export declare const elapsed: Schedule<Duration.Duration, unknown, never>

Added in v2.0.0

exponential

A schedule that always recurs, but will wait a certain amount between repetitions, given by base * factor.pow(n), where n is the number of repetitions so far. Returns the current duration between recurrences.

Signature

export declare const exponential: (base: Duration.DurationInput, factor?: number) => Schedule<Duration.Duration>

Added in v2.0.0

fibonacci

A schedule that always recurs, increasing delays by summing the preceding two delays (similar to the fibonacci sequence). Returns the current duration between recurrences.

Signature

export declare const fibonacci: (one: Duration.DurationInput) => Schedule<Duration.Duration>

Added in v2.0.0

fixed

A schedule that recurs on a fixed interval. Returns the number of repetitions of the schedule so far.

If the action run between updates takes longer than the interval, then the action will be run immediately, but re-runs will not “pile up”.

|-----interval-----|-----interval-----|-----interval-----|
|---------action--------||action|-----|action|-----------|

Signature

export declare const fixed: (interval: Duration.DurationInput) => Schedule<number>

Added in v2.0.0

forever

A schedule that always recurs, producing a count of repeats: 0, 1, 2.

Signature

export declare const forever: Schedule<number, unknown, never>

Added in v2.0.0

fromDelay

A schedule that recurs once with the specified delay.

Signature

export declare const fromDelay: (delay: Duration.DurationInput) => Schedule<Duration.Duration>

Added in v2.0.0

fromDelays

A schedule that recurs once for each of the specified durations, delaying each time for the length of the specified duration. Returns the length of the current duration between recurrences.

Signature

export declare const fromDelays: (
  delay: Duration.DurationInput,
  ...delays: Array<Duration.DurationInput>
) => Schedule<Duration.Duration>

Added in v2.0.0

fromFunction

A schedule that always recurs, mapping input values through the specified function.

Signature

export declare const fromFunction: <A, B>(f: (a: A) => B) => Schedule<B, A>

Added in v2.0.0

hourOfDay

Cron-like schedule that recurs every specified hour of each day. It triggers at zero minute of the hour. Producing a count of repeats: 0, 1, 2.

NOTE: hour parameter is validated lazily. Must be in range 0…23.

Signature

export declare const hourOfDay: (hour: number) => Schedule<number>

Added in v2.0.0

identity

A schedule that always recurs, which returns inputs as outputs.

Signature

export declare const identity: <A>() => Schedule<A, A>

Added in v2.0.0

jittered

Returns a new schedule that randomly modifies the size of the intervals of this schedule.

Defaults min to 0.8 and max to 1.2.

The new interval size is between min * old interval size and max * old interval size.

Signature

export declare const jittered: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>

Added in v2.0.0

jitteredWith

Returns a new schedule that randomly modifies the size of the intervals of this schedule.

The new interval size is between min * old interval size and max * old interval size.

Signature

export declare const jitteredWith: {
  (options: {
    min?: number | undefined
    max?: number | undefined
  }): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(
    self: Schedule<Out, In, R>,
    options: { min?: number | undefined; max?: number | undefined }
  ): Schedule<Out, In, R>
}

Added in v2.0.0

linear

A schedule that always recurs, but will repeat on a linear time interval, given by base * n where n is the number of repetitions so far. Returns the current duration between recurrences.

Signature

export declare const linear: (base: Duration.DurationInput) => Schedule<Duration.Duration>

Added in v2.0.0

makeWithState

Constructs a new Schedule with the specified initial state and the specified step function.

Signature

export declare const makeWithState: <S, In, Out, R = never>(
  initial: S,
  step: (
    now: number,
    input: In,
    state: S
  ) => Effect.Effect<readonly [S, Out, ScheduleDecision.ScheduleDecision], never, R>
) => Schedule<Out, In, R>

Added in v2.0.0

minuteOfHour

Cron-like schedule that recurs every specified minute of each hour. It triggers at zero second of the minute. Producing a count of repeats: 0, 1, 2.

NOTE: minute parameter is validated lazily. Must be in range 0…59.

Signature

export declare const minuteOfHour: (minute: number) => Schedule<number>

Added in v2.0.0

once

A schedule that recurs one time.

Signature

export declare const once: Schedule<void, unknown, never>

Added in v2.0.0

recurs

A schedule spanning all time, which can be stepped only the specified number of times before it terminates.

Signature

export declare const recurs: (n: number) => Schedule<number>

Added in v2.0.0

repeatForever

Returns a new schedule that loops this one continuously, resetting the state when this schedule is done.

Signature

export declare const repeatForever: Schedule<number, unknown, never>

Added in v2.0.0

secondOfMinute

Cron-like schedule that recurs every specified second of each minute. It triggers at zero nanosecond of the second. Producing a count of repeats: 0, 1, 2.

NOTE: second parameter is validated lazily. Must be in range 0…59.

Signature

export declare const secondOfMinute: (second: number) => Schedule<number>

Added in v2.0.0

spaced

Returns a schedule that recurs continuously, each repetition spaced the specified duration from the last run.

Signature

export declare const spaced: (duration: Duration.DurationInput) => Schedule<number>

Added in v2.0.0

stop

A schedule that does not recur, it just stops.

Signature

export declare const stop: Schedule<void, unknown, never>

Added in v2.0.0

succeed

Returns a schedule that repeats one time, producing the specified constant value.

Signature

export declare const succeed: <A>(value: A) => Schedule<A>

Added in v2.0.0

sync

Returns a schedule that repeats one time, producing the specified constant value.

Signature

export declare const sync: <A>(evaluate: LazyArg<A>) => Schedule<A>

Added in v2.0.0

unfold

Unfolds a schedule that repeats one time from the specified state and iterator.

Signature

export declare const unfold: <A>(initial: A, f: (a: A) => A) => Schedule<A>

Added in v2.0.0

windowed

A schedule that divides the timeline to interval-long windows, and sleeps until the nearest window boundary every time it recurs.

For example, windowed(Duration.seconds(10)) would produce a schedule as follows:

     10s        10s        10s       10s
|----------|----------|----------|----------|
|action------|sleep---|act|-sleep|action----|

Signature

export declare const windowed: (interval: Duration.DurationInput) => Schedule<number>

Added in v2.0.0

context

mapInputContext

Transforms the context being provided to this schedule with the specified function.

Signature

export declare const mapInputContext: {
  <R0, R>(
    f: (env0: Context.Context<R0>) => Context.Context<R>
  ): <Out, In>(self: Schedule<Out, In, R>) => Schedule<Out, In, R0>
  <Out, In, R, R0>(
    self: Schedule<Out, In, R>,
    f: (env0: Context.Context<R0>) => Context.Context<R>
  ): Schedule<Out, In, R0>
}

Added in v2.0.0

provideContext

Returns a new schedule with its context provided to it, so the resulting schedule does not require any context.

Signature

export declare const provideContext: {
  <R>(context: Context.Context<R>): <Out, In>(self: Schedule<Out, In, R>) => Schedule<Out, In, never>
  <Out, In, R>(self: Schedule<Out, In, R>, context: Context.Context<R>): Schedule<Out, In, never>
}

Added in v2.0.0

provideService

Returns a new schedule with the single service it requires provided to it. If the schedule requires multiple services use provideContext instead.

Signature

export declare const provideService: {
  <T extends Context.Tag<any, any>>(
    tag: T,
    service: Context.Tag.Service<T>
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, Exclude<R, Context.Tag.Identifier<T>>>
  <Out, In, R, T extends Context.Tag<any, any>>(
    self: Schedule<Out, In, R>,
    tag: T,
    service: Context.Tag.Service<T>
  ): Schedule<Out, In, Exclude<R, Context.Tag.Identifier<T>>>
}

Added in v2.0.0

destructors

run

Runs a schedule using the provided inputs, and collects all outputs.

Signature

export declare const run: {
  <In>(
    now: number,
    input: Iterable<In>
  ): <Out, R>(self: Schedule<Out, In, R>) => Effect.Effect<Chunk.Chunk<Out>, never, R>
  <Out, In, R>(self: Schedule<Out, In, R>, now: number, input: Iterable<In>): Effect.Effect<Chunk.Chunk<Out>, never, R>
}

Added in v2.0.0

finalization

ensuring

Returns a new schedule that will run the specified finalizer as soon as the schedule is complete. Note that unlike Effect.ensuring, this method does not guarantee the finalizer will be run. The Schedule may not initialize or the driver of the schedule may not run to completion. However, if the Schedule ever decides not to continue, then the finalizer will be run.

Signature

export declare const ensuring: {
  <X>(finalizer: Effect.Effect<X, never, never>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R, X>(self: Schedule<Out, In, R>, finalizer: Effect.Effect<X, never, never>): Schedule<Out, In, R>
}

Added in v2.0.0

folding

reduce

Returns a new schedule that folds over the outputs of this one.

Signature

export declare const reduce: {
  <Out, Z>(zero: Z, f: (z: Z, out: Out) => Z): <In, R>(self: Schedule<Out, In, R>) => Schedule<Z, In, R>
  <Out, In, R, Z>(self: Schedule<Out, In, R>, zero: Z, f: (z: Z, out: Out) => Z): Schedule<Z, In, R>
}

Added in v2.0.0

reduceEffect

Returns a new schedule that effectfully folds over the outputs of this one.

Signature

export declare const reduceEffect: {
  <Z, Out, R2>(
    zero: Z,
    f: (z: Z, out: Out) => Effect.Effect<Z, never, R2>
  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Z, In, R2 | R>
  <Out, In, R, Z, R2>(
    self: Schedule<Out, In, R>,
    zero: Z,
    f: (z: Z, out: Out) => Effect.Effect<Z, never, R2>
  ): Schedule<Z, In, R | R2>
}

Added in v2.0.0

getter

driver

Returns a driver that can be used to step the schedule, appropriately handling sleeping.

Signature

export declare const driver: <Out, In, R>(self: Schedule<Out, In, R>) => Effect.Effect<ScheduleDriver<Out, In, R>>

Added in v2.0.0

mapping

as

Returns a new schedule that maps this schedule to a constant output.

Signature

export declare const as: {
  <Out2>(out: Out2): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R>
  <Out, In, R, Out2>(self: Schedule<Out, In, R>, out: Out2): Schedule<Out2, In, R>
}

Added in v2.0.0

map

Returns a new schedule that maps the output of this schedule through the specified function.

Signature

export declare const map: {
  <Out, Out2>(f: (out: Out) => Out2): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R>
  <Out, In, R, Out2>(self: Schedule<Out, In, R>, f: (out: Out) => Out2): Schedule<Out2, In, R>
}

Added in v2.0.0

mapBoth

Returns a new schedule that maps both the input and output.

Signature

export declare const mapBoth: {
  <In2, In, Out, Out2>(options: {
    readonly onInput: (in2: In2) => In
    readonly onOutput: (out: Out) => Out2
  }): <R>(self: Schedule<Out, In, R>) => Schedule<Out2, In2, R>
  <Out, In, R, In2, Out2>(
    self: Schedule<Out, In, R>,
    options: { readonly onInput: (in2: In2) => In; readonly onOutput: (out: Out) => Out2 }
  ): Schedule<Out2, In2, R>
}

Added in v2.0.0

mapBothEffect

Returns a new schedule that maps both the input and output.

Signature

export declare const mapBothEffect: {
  <In2, In, R2, Out, R3, Out2>(options: {
    readonly onInput: (input: In2) => Effect.Effect<In, never, R2>
    readonly onOutput: (out: Out) => Effect.Effect<Out2, never, R3>
  }): <R>(self: Schedule<Out, In, R>) => Schedule<Out2, In2, R2 | R3 | R>
  <Out, In, R, In2, R2, Out2, R3>(
    self: Schedule<Out, In, R>,
    options: {
      readonly onInput: (input: In2) => Effect.Effect<In, never, R2>
      readonly onOutput: (out: Out) => Effect.Effect<Out2, never, R3>
    }
  ): Schedule<Out2, In2, R | R2 | R3>
}

Added in v2.0.0

mapEffect

Returns a new schedule that maps the output of this schedule through the specified effectful function.

Signature

export declare const mapEffect: {
  <Out, Out2, R2>(
    f: (out: Out) => Effect.Effect<Out2, never, R2>
  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R2 | R>
  <Out, In, R, Out2, R2>(
    self: Schedule<Out, In, R>,
    f: (out: Out) => Effect.Effect<Out2, never, R2>
  ): Schedule<Out2, In, R | R2>
}

Added in v2.0.0

mapInput

Returns a new schedule that deals with a narrower class of inputs than this schedule.

Signature

export declare const mapInput: {
  <In, In2>(f: (in2: In2) => In): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In2, R>
  <Out, In, R, In2>(self: Schedule<Out, In, R>, f: (in2: In2) => In): Schedule<Out, In2, R>
}

Added in v2.0.0

mapInputEffect

Returns a new schedule that deals with a narrower class of inputs than this schedule.

Signature

export declare const mapInputEffect: {
  <In2, In, R2>(
    f: (in2: In2) => Effect.Effect<In, never, R2>
  ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In2, R2 | R>
  <Out, In, R, In2, R2>(
    self: Schedule<Out, In, R>,
    f: (in2: In2) => Effect.Effect<In, never, R2>
  ): Schedule<Out, In2, R | R2>
}

Added in v2.0.0

model

Schedule (interface)

A Schedule<Out, In, R> defines a recurring schedule, which consumes values of type In, and which returns values of type Out.

Schedules are defined as a possibly infinite set of intervals spread out over time. Each interval defines a window in which recurrence is possible.

When schedules are used to repeat or retry effects, the starting boundary of each interval produced by a schedule is used as the moment when the effect will be executed again.

Schedules compose in the following primary ways:

  • Union: performs the union of the intervals of two schedules
  • Intersection: performs the intersection of the intervals of two schedules
  • Sequence: concatenates the intervals of one schedule onto another

In addition, schedule inputs and outputs can be transformed, filtered (to terminate a schedule early in response to some input or output), and so forth.

A variety of other operators exist for transforming and combining schedules, and the companion object for Schedule contains all common types of schedules, both for performing retrying, as well as performing repetition.

Signature

export interface Schedule<out Out, in In = unknown, out R = never> extends Schedule.Variance<Out, In, R>, Pipeable {
  /**
   * Initial State
   */
  readonly initial: any
  /**
   * Schedule Step
   */
  step(
    now: number,
    input: In,
    state: any
  ): Effect.Effect<readonly [any, Out, ScheduleDecision.ScheduleDecision], never, R>
}

Added in v2.0.0

models

ScheduleDriver (interface)

Signature

export interface ScheduleDriver<out Out, in In = unknown, out R = never> extends Schedule.DriverVariance<Out, In, R> {
  readonly state: Effect.Effect<unknown>
  readonly last: Effect.Effect<Out, Cause.NoSuchElementException>
  readonly reset: Effect.Effect<void>
  next(input: In): Effect.Effect<Out, Option.Option<never>, R>
}

Added in v2.0.0

sequencing

andThen

The same as andThenEither, but merges the output.

Signature

export declare const andThen: {
  <Out2, In2, R2>(
    that: Schedule<Out2, In2, R2>
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2 | Out, In & In2, R2 | R>
  <Out, In, R, Out2, In2, R2>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>
  ): Schedule<Out | Out2, In & In2, R | R2>
}

Added in v2.0.0

andThenEither

Returns a new schedule that first executes this schedule to completion, and then executes the specified schedule to completion.

Signature

export declare const andThenEither: {
  <Out2, In2, R2>(
    that: Schedule<Out2, In2, R2>
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Either.Either<Out2, Out>, In & In2, R2 | R>
  <Out, In, R, Out2, In2, R2>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>
  ): Schedule<Either.Either<Out2, Out>, In & In2, R | R2>
}

Added in v2.0.0

tapInput

Returns a new schedule that effectfully processes every input to this schedule.

Signature

export declare const tapInput: {
  <In2, X, R2>(
    f: (input: In2) => Effect.Effect<X, never, R2>
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In & In2, R2 | R>
  <Out, In, R, In2, X, R2>(
    self: Schedule<Out, In, R>,
    f: (input: In2) => Effect.Effect<X, never, R2>
  ): Schedule<Out, In & In2, R | R2>
}

Added in v2.0.0

tapOutput

Returns a new schedule that effectfully processes every output from this schedule.

Signature

export declare const tapOutput: {
  <XO extends Out, X, R2, Out>(
    f: (out: XO) => Effect.Effect<X, never, R2>
  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
  <Out, In, R, XO extends Out, X, R2>(
    self: Schedule<Out, In, R>,
    f: (out: XO) => Effect.Effect<X, never, R2>
  ): Schedule<Out, In, R | R2>
}

Added in v2.0.0

symbols

ScheduleDriverTypeId

Signature

export declare const ScheduleDriverTypeId: typeof ScheduleDriverTypeId

Added in v2.0.0

ScheduleDriverTypeId (type alias)

Signature

export type ScheduleDriverTypeId = typeof ScheduleDriverTypeId

Added in v2.0.0

ScheduleTypeId

Signature

export declare const ScheduleTypeId: typeof ScheduleTypeId

Added in v2.0.0

ScheduleTypeId (type alias)

Signature

export type ScheduleTypeId = typeof ScheduleTypeId

Added in v2.0.0

utils

Schedule (namespace)

Added in v2.0.0

DriverVariance (interface)

Signature

export interface DriverVariance<out Out, in In, out R> {
  readonly [ScheduleDriverTypeId]: {
    readonly _Out: Types.Covariant<Out>
    readonly _In: Types.Contravariant<In>
    readonly _R: Types.Covariant<R>
  }
}

Added in v2.0.0

Variance (interface)

Signature

export interface Variance<out Out, in In, out R> {
  readonly [ScheduleTypeId]: {
    readonly _Out: Types.Covariant<Out>
    readonly _In: Types.Contravariant<In>
    readonly _R: Types.Covariant<R>
  }
}

Added in v2.0.0

addDelay

Returns a new schedule with the given delay added to every interval defined by this schedule.

Signature

export declare const addDelay: {
  <Out>(f: (out: Out) => Duration.DurationInput): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(self: Schedule<Out, In, R>, f: (out: Out) => Duration.DurationInput): Schedule<Out, In, R>
}

Added in v2.0.0

addDelayEffect

Returns a new schedule with the given effectfully computed delay added to every interval defined by this schedule.

Signature

export declare const addDelayEffect: {
  <Out, R2>(
    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>
  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
  <Out, In, R, R2>(
    self: Schedule<Out, In, R>,
    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>
  ): Schedule<Out, In, R | R2>
}

Added in v2.0.0

bothInOut

Returns a new schedule that has both the inputs and outputs of this and the specified schedule.

Signature

export declare const bothInOut: {
  <Out2, In2, R2>(
    that: Schedule<Out2, In2, R2>
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], readonly [In, In2], R2 | R>
  <Out, In, R, Out2, In2, R2>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>
  ): Schedule<[Out, Out2], readonly [In, In2], R | R2>
}

Added in v2.0.0

check

Returns a new schedule that passes each input and output of this schedule to the specified function, and then determines whether or not to continue based on the return value of the function.

Signature

export declare const check: {
  <In, Out>(test: (input: In, output: Out) => boolean): <R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(self: Schedule<Out, In, R>, test: (input: In, output: Out) => boolean): Schedule<Out, In, R>
}

Added in v2.0.0

checkEffect

Returns a new schedule that passes each input and output of this schedule to the specified function, and then determines whether or not to continue based on the return value of the function.

Signature

export declare const checkEffect: {
  <In, Out, R2>(
    test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>
  ): <R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
  <Out, In, R, R2>(
    self: Schedule<Out, In, R>,
    test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>
  ): Schedule<Out, In, R | R2>
}

Added in v2.0.0

collectAllOutputs

Returns a new schedule that collects the outputs of this one into a chunk.

Signature

export declare const collectAllOutputs: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Chunk.Chunk<Out>, In, R>

Added in v2.0.0

collectUntil

A schedule that recurs until the condition f fails, collecting all inputs into a list.

Signature

export declare const collectUntil: <A>(f: Predicate<A>) => Schedule<Chunk.Chunk<A>, A>

Added in v2.0.0

collectUntilEffect

A schedule that recurs until the effectful condition f fails, collecting all inputs into a list.

Signature

export declare const collectUntilEffect: <A, R>(
  f: (a: A) => Effect.Effect<boolean, never, R>
) => Schedule<Chunk.Chunk<A>, A, R>

Added in v2.0.0

collectWhile

A schedule that recurs as long as the condition f holds, collecting all inputs into a list.

Signature

export declare const collectWhile: <A>(f: Predicate<A>) => Schedule<Chunk.Chunk<A>, A>

Added in v2.0.0

collectWhileEffect

A schedule that recurs as long as the effectful condition holds, collecting all inputs into a list.

Signature

export declare const collectWhileEffect: <A, R>(
  f: (a: A) => Effect.Effect<boolean, never, R>
) => Schedule<Chunk.Chunk<A>, A, R>

Added in v2.0.0

compose

Returns the composition of this schedule and the specified schedule, by piping the output of this one into the input of the other. Effects described by this schedule will always be executed before the effects described by the second schedule.

Signature

export declare const compose: {
  <Out2, Out, R2>(that: Schedule<Out2, Out, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R2 | R>
  <Out, In, R, Out2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, Out, R2>): Schedule<Out2, In, R | R2>
}

Added in v2.0.0

delayed

Returns a new schedule with the specified effectfully computed delay added before the start of each interval produced by this schedule.

Signature

export declare const delayed: {
  (
    f: (duration: Duration.Duration) => Duration.DurationInput
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(
    self: Schedule<Out, In, R>,
    f: (duration: Duration.Duration) => Duration.DurationInput
  ): Schedule<Out, In, R>
}

Added in v2.0.0

intersect

Returns a new schedule that performs a geometric intersection on the intervals defined by both schedules.

Signature

export declare const intersect: {
  <Out2, In2, R2>(
    that: Schedule<Out2, In2, R2>
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
  <Out, In, R, Out2, In2, R2>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>
  ): Schedule<[Out, Out2], In & In2, R | R2>
}

Added in v2.0.0

intersectWith

Returns a new schedule that combines this schedule with the specified schedule, continuing as long as both schedules want to continue and merging the next intervals according to the specified merge function.

Signature

export declare const intersectWith: {
  <Out2, In2, R2>(
    that: Schedule<Out2, In2, R2>,
    f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
  <Out, In, R, Out2, In2, R2>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>,
    f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
  ): Schedule<[Out, Out2], In & In2, R | R2>
}

Added in v2.0.0

modifyDelay

Returns a new schedule that modifies the delay using the specified function.

Signature

export declare const modifyDelay: {
  <Out>(
    f: (out: Out, duration: Duration.Duration) => Duration.DurationInput
  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(
    self: Schedule<Out, In, R>,
    f: (out: Out, duration: Duration.Duration) => Duration.DurationInput
  ): Schedule<Out, In, R>
}

Added in v2.0.0

modifyDelayEffect

Returns a new schedule that modifies the delay using the specified effectual function.

Signature

export declare const modifyDelayEffect: {
  <Out, R2>(
    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
  <Out, In, R, R2>(
    self: Schedule<Out, In, R>,
    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
  ): Schedule<Out, In, R | R2>
}

Added in v2.0.0

onDecision

Returns a new schedule that applies the current one but runs the specified effect for every decision of this schedule. This can be used to create schedules that log failures, decisions, or computed values.

Signature

export declare const onDecision: {
  <Out, X, R2>(
    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, R2>
  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
  <Out, In, R, X, R2>(
    self: Schedule<Out, In, R>,
    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, R2>
  ): Schedule<Out, In, R | R2>
}

Added in v2.0.0

passthrough

Returns a new schedule that passes through the inputs of this schedule.

Signature

export declare const passthrough: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<In, In, R>

Added in v2.0.0

recurUntil

A schedule that recurs for until the predicate evaluates to true.

Signature

export declare const recurUntil: <A>(f: Predicate<A>) => Schedule<A, A>

Added in v2.0.0

recurUntilEffect

A schedule that recurs for until the predicate evaluates to true.

Signature

export declare const recurUntilEffect: <A, R>(f: (a: A) => Effect.Effect<boolean, never, R>) => Schedule<A, A, R>

Added in v2.0.0

recurUntilOption

A schedule that recurs for until the input value becomes applicable to partial function and then map that value with given function.

Signature

export declare const recurUntilOption: <A, B>(pf: (a: A) => Option.Option<B>) => Schedule<Option.Option<B>, A>

Added in v2.0.0

recurUpTo

A schedule that recurs during the given duration.

Signature

export declare const recurUpTo: (duration: Duration.DurationInput) => Schedule<Duration.Duration>

Added in v2.0.0

recurWhile

A schedule that recurs for as long as the predicate evaluates to true.

Signature

export declare const recurWhile: <A>(f: Predicate<A>) => Schedule<A, A>

Added in v2.0.0

recurWhileEffect

A schedule that recurs for as long as the effectful predicate evaluates to true.

Signature

export declare const recurWhileEffect: <A, R>(f: (a: A) => Effect.Effect<boolean, never, R>) => Schedule<A, A, R>

Added in v2.0.0

repetitions

Returns a new schedule that outputs the number of repetitions of this one.

Signature

export declare const repetitions: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<number, In, R>

Added in v2.0.0

resetAfter

Return a new schedule that automatically resets the schedule to its initial state after some time of inactivity defined by duration.

Signature

export declare const resetAfter: {
  (duration: Duration.DurationInput): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(self: Schedule<Out, In, R>, duration: Duration.DurationInput): Schedule<Out, In, R>
}

Added in v2.0.0

resetWhen

Resets the schedule when the specified predicate on the schedule output evaluates to true.

Signature

export declare const resetWhen: {
  <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>
}

Added in v2.0.0

union

Returns a new schedule that performs a geometric union on the intervals defined by both schedules.

Signature

export declare const union: {
  <Out2, In2, R2>(
    that: Schedule<Out2, In2, R2>
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
  <Out, In, R, Out2, In2, R2>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>
  ): Schedule<[Out, Out2], In & In2, R | R2>
}

Added in v2.0.0

unionWith

Returns a new schedule that combines this schedule with the specified schedule, continuing as long as either schedule wants to continue and merging the next intervals according to the specified merge function.

Signature

export declare const unionWith: {
  <Out2, In2, R2>(
    that: Schedule<Out2, In2, R2>,
    f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
  <Out, In, R, Out2, In2, R2>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>,
    f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
  ): Schedule<[Out, Out2], In & In2, R | R2>
}

Added in v2.0.0

untilInput

Returns a new schedule that continues until the specified predicate on the input evaluates to true.

Signature

export declare const untilInput: {
  <In>(f: Predicate<In>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<In>): Schedule<Out, In, R>
}

Added in v2.0.0

untilInputEffect

Returns a new schedule that continues until the specified effectful predicate on the input evaluates to true.

Signature

export declare const untilInputEffect: {
  <In, R2>(
    f: (input: In) => Effect.Effect<boolean, never, R2>
  ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
  <Out, In, R, R2>(
    self: Schedule<Out, In, R>,
    f: (input: In) => Effect.Effect<boolean, never, R2>
  ): Schedule<Out, In, R | R2>
}

Added in v2.0.0

untilOutput

Returns a new schedule that continues until the specified predicate on the output evaluates to true.

Signature

export declare const untilOutput: {
  <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>
}

Added in v2.0.0

untilOutputEffect

Returns a new schedule that continues until the specified effectful predicate on the output evaluates to true.

Signature

export declare const untilOutputEffect: {
  <Out, R2>(
    f: (out: Out) => Effect.Effect<boolean, never, R2>
  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
  <Out, In, R, R2>(
    self: Schedule<Out, In, R>,
    f: (out: Out) => Effect.Effect<boolean, never, R2>
  ): Schedule<Out, In, R | R2>
}

Added in v2.0.0

upTo

A schedule that recurs during the given duration.

Signature

export declare const upTo: {
  (duration: Duration.DurationInput): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(self: Schedule<Out, In, R>, duration: Duration.DurationInput): Schedule<Out, In, R>
}

Added in v2.0.0

whileInput

Returns a new schedule that continues for as long as the specified predicate on the input evaluates to true.

Signature

export declare const whileInput: {
  <In>(f: Predicate<In>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<In>): Schedule<Out, In, R>
}

Added in v2.0.0

whileInputEffect

Returns a new schedule that continues for as long as the specified effectful predicate on the input evaluates to true.

Signature

export declare const whileInputEffect: {
  <In, R2>(
    f: (input: In) => Effect.Effect<boolean, never, R2>
  ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
  <Out, In, R, R2>(
    self: Schedule<Out, In, R>,
    f: (input: In) => Effect.Effect<boolean, never, R2>
  ): Schedule<Out, In, R | R2>
}

Added in v2.0.0

whileOutput

Returns a new schedule that continues for as long the specified predicate on the output evaluates to true.

Signature

export declare const whileOutput: {
  <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
  <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>
}

Added in v2.0.0

whileOutputEffect

Returns a new schedule that continues for as long the specified effectful predicate on the output evaluates to true.

Signature

export declare const whileOutputEffect: {
  <Out, R2>(
    f: (out: Out) => Effect.Effect<boolean, never, R2>
  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
  <Out, In, R, R2>(
    self: Schedule<Out, In, R>,
    f: (out: Out) => Effect.Effect<boolean, never, R2>
  ): Schedule<Out, In, R | R2>
}

Added in v2.0.0

zipping

zipLeft

The same as intersect but ignores the right output.

Signature

export declare const zipLeft: {
  <Out2, In2, R2>(
    that: Schedule<Out2, In2, R2>
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In & In2, R2 | R>
  <Out, In, R, Out2, In2, R2>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>
  ): Schedule<Out, In & In2, R | R2>
}

Added in v2.0.0

zipRight

The same as intersect but ignores the left output.

Signature

export declare const zipRight: {
  <Out2, In2, R2>(
    that: Schedule<Out2, In2, R2>
  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In & In2, R2 | R>
  <Out, In, R, Out2, In2, R2>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>
  ): Schedule<Out2, In & In2, R | R2>
}

Added in v2.0.0

zipWith

Equivalent to intersect followed by map.

Signature

export declare const zipWith: {
  <Out2, In2, R2, Out, Out3>(
    that: Schedule<Out2, In2, R2>,
    f: (out: Out, out2: Out2) => Out3
  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out3, In & In2, R2 | R>
  <Out, In, R, Out2, In2, R2, Out3>(
    self: Schedule<Out, In, R>,
    that: Schedule<Out2, In2, R2>,
    f: (out: Out, out2: Out2) => Out3
  ): Schedule<Out3, In & In2, R | R2>
}

Added in v2.0.0