@typed/fx 2.0.0-beta.0 → 2.0.0-beta.2

package/src/Fx/combinators/scan.ts

@@ -0,0 +1,82 @@
+import * as Effect from "effect/Effect";
+import { dual, pipe } from "effect/Function";
+import { loop as sinkLoop, loopEffect as sinkLoopEffect } from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+import { Sink } from "../../Sink.js";
+
+/**
+ * Scans the stream with a pure function, emitting the accumulated state after each element.
+ * Emits the initial value first, then for each input `a` emits `f(state, a)` and updates state.
+ *
+ * Semantics align with Effect Stream's `scan`: output is `initial`, `f(initial, a1)`, `f(..., a2)`, ...
+ *
+ * @param initial - Initial state (first value emitted).
+ * @param f - Reducer `(state, value) => nextState`.
+ * @returns An `Fx` that emits the accumulated state at each step.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const scan: {
+  <S, A>(initial: S, f: (s: S, a: A) => S): <E, R>(fx: Fx<A, E, R>) => Fx<S, E, R>;
+  <A, E, R, S>(fx: Fx<A, E, R>, initial: S, f: (s: S, a: A) => S): Fx<S, E, R>;
+} = dual(
+  3,
+  <A, E, R, S>(fx: Fx<A, E, R>, initial: S, f: (s: S, a: A) => S): Fx<S, E, R> =>
+    make<S, E, R>((sink) =>
+      Effect.gen(function* () {
+        yield* sink.onSuccess(initial);
+        yield* fx.run(
+          sinkLoop(sink, initial, (s, a) => {
+            const next = f(s, a);
+            return [next, next] as const;
+          }),
+        );
+      }),
+    ),
+);
+
+/**
+ * Scans the stream with an effectful function, emitting the accumulated state after each element.
+ * Emits the initial value first, then for each input `a` runs `f(state, a)` and emits the resulting state.
+ *
+ * @param initial - Initial state (first value emitted).
+ * @param f - Effectful reducer `(state, value) => Effect<nextState>`.
+ * @returns An `Fx` that emits the accumulated state at each step.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const scanEffect: {
+  <S, A, E2, R2>(
+    initial: S,
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>,
+  ): <E, R>(fx: Fx<A, E, R>) => Fx<S, E | E2, R | R2>;
+  <A, E, R, S, E2, R2>(
+    fx: Fx<A, E, R>,
+    initial: S,
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>,
+  ): Fx<S, E | E2, R | R2>;
+} = dual(
+  3,
+  <A, E, R, S, E2, R2>(
+    fx: Fx<A, E, R>,
+    initial: S,
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>,
+  ): Fx<S, E | E2, R | R2> =>
+    make<S, E | E2, R | R2>(<RSink>(sink: Sink<S, E | E2, RSink>) =>
+      Effect.gen(function* () {
+        const services = yield* Effect.services<R | R2 | RSink>();
+        yield* sink.onSuccess(initial);
+        yield* fx.run(
+          sinkLoopEffect(sink, initial, (s, a) =>
+            pipe(
+              f(s, a),
+              Effect.catchCause((cause) => sink.onFailure(cause).pipe(Effect.as(s))),
+              Effect.map((next) => [next, next] as const),
+              Effect.provideServices(services),
+            ),
+          ),
+        );
+      }),
+    ),
+);

package/src/Fx/combinators/skip.ts

@@ -1,6 +1,8 @@
+import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
 import type { Fx } from "../Fx.js";
 import { slice } from "./slice.js";
+import { unwrap } from "./unwrap.js";
 
 /**
  * Skips the first `n` elements of an Fx.
@@ -18,3 +20,22 @@ export const skip: {
   2,
   <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R> => slice(fx, { skip: n, take: Infinity }),
 );
+
+/**
+ * Skips the first `n` elements where `n` is produced by an Effect.
+ *
+ * @param count - Effect that produces the number of elements to skip.
+ * @returns An `Fx` that emits values after the first `n` elements.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const skipEffect: {
+  <E2, R2>(
+    count: Effect.Effect<number, E2, R2>,
+  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+  <A, E, R, E2, R2>(fx: Fx<A, E, R>, count: Effect.Effect<number, E2, R2>): Fx<A, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, E2, R2>(fx: Fx<A, E, R>, count: Effect.Effect<number, E2, R2>): Fx<A, E | E2, R | R2> =>
+    unwrap(Effect.map(count, (n) => skip(fx, n))),
+);

package/src/Fx/combinators/skipWhile.ts

@@ -0,0 +1,100 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import * as Ref from "effect/Ref";
+import { make as makeFx } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+import { make as makeSink } from "../../Sink/Sink.js";
+
+/**
+ * Skips elements from an Fx while a predicate returns true.
+ * Emits from the first element for which the predicate returns false (including that element) and all following elements.
+ *
+ * @param predicate - The predicate function.
+ * @returns An `Fx` that emits once the predicate first fails.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const skipWhile: {
+  <A>(predicate: (a: A) => boolean): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+  <A, E, R>(fx: Fx<A, E, R>, predicate: (a: A) => boolean): Fx<A, E, R>;
+} = dual(
+  2,
+  <A, E, R>(fx: Fx<A, E, R>, predicate: (a: A) => boolean): Fx<A, E, R> =>
+    makeFx<A, E, R>((sink) =>
+      Effect.gen(function* () {
+        const skippingRef = yield* Ref.make(true);
+        const skipSink = makeSink(sink.onFailure, (a: A) =>
+          Effect.gen(function* () {
+            const skipping = yield* Ref.get(skippingRef);
+            if (skipping) {
+              if (predicate(a)) return;
+              yield* Ref.set(skippingRef, false);
+            }
+            return yield* sink.onSuccess(a);
+          }),
+        );
+        return yield* fx.run(skipSink);
+      }),
+    ),
+);
+
+/**
+ * Skips elements from an Fx while an effectful predicate returns true.
+ * Emits from the first element for which the predicate effect succeeds with false (including that element) and all following elements.
+ *
+ * @param predicate - Effectful predicate function.
+ * @returns An `Fx` that emits once the predicate first fails.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const skipWhileEffect: {
+  <A, E2, R2>(
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2> =>
+    makeFx<A, E | E2, R | R2>((sink) =>
+      Effect.gen(function* () {
+        const skippingRef = yield* Ref.make(true);
+        const skipSink = makeSink(sink.onFailure, (a: A) =>
+          Effect.matchCauseEffect(predicate(a), {
+            onFailure: sink.onFailure,
+            onSuccess: (ok) =>
+              Effect.gen(function* () {
+                const skipping = yield* Ref.get(skippingRef);
+                if (skipping) {
+                  if (ok) return;
+                  yield* Ref.set(skippingRef, false);
+                }
+                return yield* sink.onSuccess(a);
+              }),
+          }),
+        );
+        return yield* fx.run(skipSink);
+      }),
+    ),
+);
+
+/**
+ * Alias of `skipWhile` for Effect parity (`dropWhile` naming).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const dropWhile = skipWhile;
+
+/**
+ * Alias of `skipWhileEffect` for Effect parity (`dropWhileEffect` naming).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const dropWhileEffect = skipWhileEffect;

package/src/Fx/combinators/slice.ts

@@ -1,7 +1,9 @@
+import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
 import * as sinkCore from "../../Sink/combinators.js";
 import { make } from "../constructors/make.js";
 import type { Fx } from "../Fx.js";
+import { unwrap } from "./unwrap.js";
 
 /**
  * Defines the bounds for slicing an Fx stream.
@@ -30,3 +32,24 @@ export const slice: {
   <A, E, R>(fx: Fx<A, E, R>, bounds: Bounds): Fx<A, E, R> =>
     make<A, E, R>((sink) => sinkCore.slice(sink, bounds, (sink) => fx.run(sink))),
 );
+
+/**
+ * Slices an Fx with bounds produced by an Effect.
+ *
+ * @param bounds - Effect that produces slice bounds.
+ * @returns An `Fx` representing the slice.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const sliceEffect: {
+  <E2, R2>(
+    bounds: Effect.Effect<Bounds, E2, R2>,
+  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+  <A, E, R, E2, R2>(fx: Fx<A, E, R>, bounds: Effect.Effect<Bounds, E2, R2>): Fx<A, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E, R>,
+    bounds: Effect.Effect<Bounds, E2, R2>,
+  ): Fx<A, E | E2, R | R2> => unwrap(Effect.map(bounds, (b) => slice(fx, b))),
+);

package/src/Fx/combinators/take.ts

@@ -1,6 +1,8 @@
+import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
 import type { Fx } from "../Fx.js";
 import { slice } from "./slice.js";
+import { unwrap } from "./unwrap.js";
 
 /**
  * Takes the first `n` elements from an Fx and then completes.
@@ -15,3 +17,22 @@ export const take: {
 
   <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R>;
 } = dual(2, <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R> => slice(fx, { skip: 0, take: n }));
+
+/**
+ * Takes the first `n` elements where `n` is produced by an Effect.
+ *
+ * @param count - Effect that produces the number of elements to take.
+ * @returns An `Fx` that emits at most `n` elements.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const takeEffect: {
+  <E2, R2>(
+    count: Effect.Effect<number, E2, R2>,
+  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+  <A, E, R, E2, R2>(fx: Fx<A, E, R>, count: Effect.Effect<number, E2, R2>): Fx<A, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, E2, R2>(fx: Fx<A, E, R>, count: Effect.Effect<number, E2, R2>): Fx<A, E | E2, R | R2> =>
+    unwrap(Effect.map(count, (n) => take(fx, n))),
+);

package/src/Fx/combinators/takeUntil.ts

@@ -1,3 +1,4 @@
+import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
 import * as combinators from "../../Sink/combinators.js";
 import { make as makeSink } from "../../Sink/Sink.js";
@@ -31,6 +32,43 @@ export const takeUntil: {
   );
 });
 
+/**
+ * Takes elements from an Fx until an effectful predicate returns true.
+ * The element that satisfies the predicate is not included in the output.
+ *
+ * @param predicate - Effectful predicate function.
+ * @returns An `Fx` that completes when the predicate matches.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const takeUntilEffect: {
+  <A, E2, R2>(
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2> =>
+    makeFx<A, E | E2, R | R2>((sink) =>
+      combinators.withEarlyExit(sink, (sink) =>
+        fx.run(
+          makeSink(sink.onFailure, (a) =>
+            Effect.matchCauseEffect(predicate(a), {
+              onFailure: sink.onFailure,
+              onSuccess: (matches) => (matches ? sink.earlyExit : sink.onSuccess(a)),
+            }),
+          ),
+        ),
+      ),
+    ),
+);
+
 /**
  * Drops elements from an Fx after a predicate returns true.
  * The element that satisfies the predicate is included in the output.

package/src/Fx/combinators/takeWhile.ts

@@ -0,0 +1,47 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import type { Fx } from "../Fx.js";
+import { takeUntil, takeUntilEffect } from "./takeUntil.js";
+
+/**
+ * Takes elements from an Fx while a predicate returns true.
+ * Stops at the first element for which the predicate returns false; that element is not included.
+ *
+ * @param predicate - The predicate function.
+ * @returns An `Fx` that emits while the predicate holds.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const takeWhile: {
+  <A>(predicate: (a: A) => boolean): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+  <A, E, R>(fx: Fx<A, E, R>, predicate: (a: A) => boolean): Fx<A, E, R>;
+} = dual(
+  2,
+  <A, E, R>(fx: Fx<A, E, R>, predicate: (a: A) => boolean): Fx<A, E, R> =>
+    takeUntil(fx, (a) => !predicate(a)),
+);
+
+/**
+ * Takes elements from an Fx while an effectful predicate returns true.
+ * Stops at the first element for which the predicate effect succeeds with false; that element is not included.
+ *
+ * @param predicate - Effectful predicate function.
+ * @returns An `Fx` that emits while the predicate holds.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const takeWhileEffect: {
+  <A, E2, R2>(
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2> => takeUntilEffect(fx, (a) => Effect.map(predicate(a), (b) => !b)),
+);

package/src/Fx/combinators/zip.ts

@@ -0,0 +1,175 @@
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { dual } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Queue from "effect/Queue";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+import { map } from "./map.js";
+import { tuple } from "./tuple.js";
+
+/**
+ * Zips two Fx streams in strict lockstep: emits a pair `[a, b]` only when both
+ * streams have produced their next value. Emits the i-th pair when both have
+ * produced at least i values.
+ *
+ * **Completion:** The zipped stream completes when the **first** of the two
+ * streams completes (no further pairs are emitted). The other stream is
+ * interrupted.
+ *
+ * **Errors:** The first failure from either stream fails the zipped stream.
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits pairs `[A, B]`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const zip: {
+  <A2, E2, R2>(
+    that: Fx<A2, E2, R2>,
+  ): <A, E, R>(self: Fx<A, E, R>) => Fx<readonly [A, A2], E | E2, R | R2>;
+  <A, E, R, A2, E2, R2>(
+    self: Fx<A, E, R>,
+    that: Fx<A2, E2, R2>,
+  ): Fx<readonly [A, A2], E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, A2, E2, R2>(
+    self: Fx<A, E, R>,
+    that: Fx<A2, E2, R2>,
+  ): Fx<readonly [A, A2], E | E2, R | R2> =>
+    make<readonly [A, A2], E | E2, R | R2>((sink) =>
+      Effect.gen(function* () {
+        const leftQueue = yield* Queue.unbounded<Option.Option<A>>();
+        const rightQueue = yield* Queue.unbounded<Option.Option<A2>>();
+
+        const leftSink = makeSink(sink.onFailure, (a: A) => Queue.offer(leftQueue, Option.some(a)));
+        const rightSink = makeSink(sink.onFailure, (b: A2) =>
+          Queue.offer(rightQueue, Option.some(b)),
+        );
+
+        const runLeft = self
+          .run(leftSink)
+          .pipe(Effect.ensuring(Queue.offer(leftQueue, Option.none())));
+        const runRight = that
+          .run(rightSink)
+          .pipe(Effect.ensuring(Queue.offer(rightQueue, Option.none())));
+
+        const consumer = Effect.gen(function* () {
+          while (true) {
+            const exitA = yield* Effect.exit(Queue.take(leftQueue));
+            if (Exit.isFailure(exitA)) return;
+            if (Option.isNone(exitA.value)) return;
+            const exitB = yield* Effect.exit(Queue.take(rightQueue));
+            if (Exit.isFailure(exitB)) return;
+            if (Option.isNone(exitB.value)) return;
+            yield* sink.onSuccess([exitA.value.value, exitB.value.value] as const);
+          }
+        });
+
+        const leftFiber = yield* Effect.forkChild(runLeft);
+        const rightFiber = yield* Effect.forkChild(runRight);
+        yield* consumer.pipe(
+          Effect.ensuring(Fiber.interrupt(leftFiber)),
+          Effect.ensuring(Fiber.interrupt(rightFiber)),
+        );
+      }),
+    ),
+);
+
+/**
+ * Zips two Fx streams in strict lockstep and combines each pair with a function.
+ * Emits `f(a, b)` when both streams have produced their next value.
+ *
+ * **Completion:** Completes when the **first** of the two streams completes.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @param that - The second Fx stream.
+ * @param f - Function to combine the pair `(a, b)` into a single value.
+ * @returns An Fx that emits combined values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const zipWith: {
+  <A, A2, E2, R2, B>(
+    that: Fx<A2, E2, R2>,
+    f: (a: A, b: A2) => B,
+  ): <E, R>(self: Fx<A, E, R>) => Fx<B, E | E2, R | R2>;
+  <A, E, R, A2, E2, R2, B>(
+    self: Fx<A, E, R>,
+    that: Fx<A2, E2, R2>,
+    f: (a: A, b: A2) => B,
+  ): Fx<B, E | E2, R | R2>;
+} = dual(
+  3,
+  <A, E, R, A2, E2, R2, B>(
+    self: Fx<A, E, R>,
+    that: Fx<A2, E2, R2>,
+    f: (a: A, b: A2) => B,
+  ): Fx<B, E | E2, R | R2> => map(zip(self, that), (pair) => f(pair[0], pair[1])),
+);
+
+/**
+ * Zips two Fx streams by latest values: waits for both to emit at least once,
+ * then emits `[left, right]` whenever **either** stream emits (using the latest
+ * value from the other). No strict pairing; output count is the sum of
+ * emissions from both after the first pair.
+ *
+ * **Completion:** Completes when **both** streams have completed.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits `[AL, AR]` on every update from either stream.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const zipLatest: {
+  <AR, ER, RR>(
+    that: Fx<AR, ER, RR>,
+  ): <AL, EL, RL>(self: Fx<AL, EL, RL>) => Fx<readonly [AL, AR], EL | ER, RL | RR>;
+  <AL, EL, RL, AR, ER, RR>(
+    self: Fx<AL, EL, RL>,
+    that: Fx<AR, ER, RR>,
+  ): Fx<readonly [AL, AR], EL | ER, RL | RR>;
+} = dual(
+  2,
+  <AL, EL, RL, AR, ER, RR>(
+    self: Fx<AL, EL, RL>,
+    that: Fx<AR, ER, RR>,
+  ): Fx<readonly [AL, AR], EL | ER, RL | RR> => tuple(self, that),
+);
+
+/**
+ * Zips two Fx streams by latest values and combines each pair with a function.
+ * Waits for both to emit at least once, then emits `f(left, right)` whenever
+ * either stream emits.
+ *
+ * **Completion:** Completes when **both** streams have completed.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @param that - The second Fx stream.
+ * @param f - Function to combine the latest `(left, right)` into a single value.
+ * @returns An Fx that emits combined values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const zipLatestWith: {
+  <AL, AR, ER, RR, B>(
+    that: Fx<AR, ER, RR>,
+    f: (left: AL, right: AR) => B,
+  ): <EL, RL>(self: Fx<AL, EL, RL>) => Fx<B, EL | ER, RL | RR>;
+  <AL, EL, RL, AR, ER, RR, B>(
+    self: Fx<AL, EL, RL>,
+    that: Fx<AR, ER, RR>,
+    f: (left: AL, right: AR) => B,
+  ): Fx<B, EL | ER, RL | RR>;
+} = dual(
+  3,
+  <AL, EL, RL, AR, ER, RR, B>(
+    self: Fx<AL, EL, RL>,
+    that: Fx<AR, ER, RR>,
+    f: (left: AL, right: AR) => B,
+  ): Fx<B, EL | ER, RL | RR> => map(zipLatest(self, that), (pair) => f(pair[0], pair[1])),
+);

package/src/Fx/constructors/at.ts

@@ -14,10 +14,10 @@ import { make } from "./make.js";
  * @category constructors
  */
 export const at: {
-  (delay: Duration.DurationInput): <A>(value: A) => Fx<A>;
-  <A>(value: A, delay: Duration.DurationInput): Fx<A>;
+  (delay: Duration.Input): <A>(value: A) => Fx<A>;
+  <A>(value: A, delay: Duration.Input): Fx<A>;
 } = dual(
   2,
-  <A>(value: A, delay: Duration.DurationInput): Fx<A> =>
+  <A>(value: A, delay: Duration.Input): Fx<A> =>
     make<A, never, never>((sink) => flatMap(sleep(delay), () => sink.onSuccess(value))),
 );

package/src/Fx/constructors/periodic.ts

@@ -11,5 +11,5 @@ import { fromSchedule } from "./fromSchedule.js";
  * @since 1.0.0
  * @category constructors
  */
-export const periodic = (period: Duration.DurationInput): Fx<void> =>
+export const periodic = (period: Duration.Input): Fx<void> =>
   /*#__PURE__*/ fromSchedule(spaced(period));