@fncts/io 0.0.1

package/_src/Schedule/definition.ts

@@ -0,0 +1,60 @@
+import type { Decision } from "./Decision.js";
+import type { Driver as Driver_ } from "./Driver.js";
+
+/**
+ * A `Schedule<Env, In, Out>` 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. This performs the union of the intervals of two schedules.
+ * - Intersection. This performs the intersection of the intervals of two
+ * schedules.
+ * - Sequence. This 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.
+ *
+ * @tsplus type fncts.io.Schedule
+ * @tsplus companion fncts.io.ScheduleOps
+ */
+export abstract class Schedule<Env, In, Out> {
+  readonly _Env!: (_: Env) => void;
+  readonly _In!: (_: In) => void;
+  readonly _Out!: () => Out;
+  readonly _State!: unknown;
+
+  abstract readonly initial: this["_State"];
+  abstract step(
+    now: number,
+    inp: In,
+    state: this["_State"],
+    __tsplusTrace?: string,
+  ): IO<Env, never, readonly [this["_State"], Out, Decision]>;
+}
+
+export declare namespace Schedule {
+  /**
+   * @tsplus type fncts.io.Schedule
+   */
+  export interface WithState<State, Env, In, Out> extends Schedule<Env, In, Out> {
+    readonly _State: State;
+  }
+
+  export type StateOf<X> = [X] extends [Schedule<any, any, any>] ? X["_State"] : never;
+
+  export type Driver<State, Env, In, Out> = Driver_<State, Env, In, Out>;
+}

package/_src/Schedule.ts

@@ -0,0 +1,7 @@
+// codegen:start { preset: barrel, include: ./Schedule/*.ts }
+export * from "./Schedule/api.js";
+export * from "./Schedule/Decision.js";
+export * from "./Schedule/definition.js";
+export * from "./Schedule/Driver.js";
+export * from "./Schedule/Interval.js";
+// codegen:end

package/_src/Scope/Finalizer/definition.ts

@@ -0,0 +1,26 @@
+interface FinalizerN extends HKT {
+  readonly type: Finalizer;
+}
+
+/**
+ * @tsplus type fncts.io.Managed.Finalizer
+ */
+export interface Finalizer
+  extends Newtype<
+    {
+      readonly Finalizer: unique symbol;
+    },
+    (exit: Exit<any, any>) => IO<unknown, never, any>
+  > {}
+
+/**
+ * @tsplus type fncts.io.Managed.FinalizerOps
+ */
+export interface FinalizerOps extends Newtype.Iso<FinalizerN> {}
+
+export const Finalizer: FinalizerOps = Newtype<FinalizerN>();
+
+/**
+ * @tsplus static fncts.io.Managed.FinalizerOps noop
+ */
+export const noop: Finalizer = Finalizer.get(() => IO.unit);

package/_src/Scope/Finalizer.ts

@@ -0,0 +1,3 @@
+// codegen:start { preset: barrel, include: Finalizer/*.ts }
+export * from "./Finalizer/definition.js";
+// codegen:end

package/_src/Scope/ReleaseMap/api/releaseAll.ts

@@ -0,0 +1,28 @@
+import { Exited, ReleaseMap } from "../definition.js";
+
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap releaseAll
+ */
+export function releaseAll_(releaseMap: ReleaseMap, exit: Exit<any, any>, execStrategy: ExecutionStrategy): UIO<any> {
+  return ReleaseMap.reverseGet(releaseMap).modify((s) => {
+    switch (s._tag) {
+      case "Exited":
+        return [IO.unit, s];
+      case "Running":
+        return [
+          IO.foreachExec(
+            Array.from(s.finalizers).reverse(),
+            execStrategy,
+            ([_, f]) => Finalizer.reverseGet(s.update(f))(exit).result,
+          ).flatMap((exits) =>
+            IO.fromExit(
+              (execStrategy._tag === "Sequential" ? Exit.collectAll(exits) : Exit.collectAllC(exits)).getOrElse(
+                Exit.succeed(Conc.empty()),
+              ),
+            ),
+          ),
+          new Exited(s.nextKey, exit, s.update),
+        ];
+    }
+  }).flatten;
+}

package/_src/Scope/ReleaseMap/api.ts

@@ -0,0 +1,86 @@
+import { Exited, ReleaseMap, Running } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap addIfOpen
+ */
+export function addIfOpen_(releaseMap: ReleaseMap, finalizer: Finalizer): UIO<Maybe<number>> {
+  return ReleaseMap.reverseGet(releaseMap).modify((s) => {
+    switch (s._tag) {
+      case "Exited":
+        return [
+          Finalizer.reverseGet(finalizer)(s.exit).map(() => Nothing()),
+          new Exited(s.nextKey + 1, s.exit, s.update),
+        ];
+      case "Running":
+        return [
+          IO.succeedNow(Just(s.nextKey)),
+          new Running(s.nextKey + 1, s.finalizers.set(s.nextKey, finalizer), s.update),
+        ];
+    }
+  }).flatten;
+}
+
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap release
+ */
+export function release_(releaseMap: ReleaseMap, key: number, exit: Exit<any, any>): IO<unknown, never, any> {
+  return ReleaseMap.reverseGet(releaseMap).modify((s) => {
+    switch (s._tag) {
+      case "Exited": {
+        return [IO.unit, s];
+      }
+      case "Running": {
+        return [
+          s.finalizers.get(key).match(
+            () => IO.unit,
+            (f) => Finalizer.reverseGet(s.update(f))(exit),
+          ),
+          new Running(s.nextKey, s.finalizers.remove(key), s.update),
+        ];
+      }
+    }
+  }).flatten;
+}
+
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap add
+ */
+export function add_(releaseMap: ReleaseMap, finalizer: Finalizer): UIO<Finalizer> {
+  return releaseMap.addIfOpen(finalizer).map((key) =>
+    key.match(
+      (): Finalizer => Finalizer.get(() => IO.unit),
+      (k): Finalizer => Finalizer.get((e) => releaseMap.release(k, e)),
+    ),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap replace
+ */
+export function replace_(releaseMap: ReleaseMap, key: number, finalizer: Finalizer): UIO<Maybe<Finalizer>> {
+  return ReleaseMap.reverseGet(releaseMap).modify((s) => {
+    switch (s._tag) {
+      case "Exited":
+        return [Finalizer.reverseGet(finalizer)(s.exit).map(() => Nothing()), new Exited(s.nextKey, s.exit, s.update)];
+      case "Running":
+        return [
+          IO.succeedNow(s.finalizers.get(key)),
+          new Running(s.nextKey, s.finalizers.set(key, finalizer), s.update),
+        ];
+    }
+  }).flatten;
+}
+
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap updateAll
+ */
+export function updateAll_(releaseMap: ReleaseMap, f: (_: Finalizer) => Finalizer): UIO<void> {
+  return ReleaseMap.reverseGet(releaseMap).update((s) => {
+    switch (s._tag) {
+      case "Exited":
+        return new Exited(s.nextKey, s.exit, (fin) => s.update(f(fin)));
+      case "Running":
+        return new Running(s.nextKey, s.finalizers, (fin) => s.update(f(fin)));
+    }
+  });
+}

package/_src/Scope/ReleaseMap/constructors.ts

@@ -0,0 +1,17 @@
+import type { State } from "./definition.js";
+
+import { identity } from "@fncts/base/data/function";
+
+import { ReleaseMap, Running } from "./definition.js";
+
+/**
+ * @tsplus static fncts.io.Scope.ReleaseMapOps unsafeMake
+ */
+export function unsafeMake(): ReleaseMap {
+  return ReleaseMap.get(Ref.unsafeMake<State>(new Running(0, HashMap.makeDefault(), identity)));
+}
+
+/**
+ * @tsplus static fncts.io.Scope.ReleaseMapOps make
+ */
+export const make: UIO<ReleaseMap> = IO.succeed(ReleaseMap.unsafeMake());

package/_src/Scope/ReleaseMap/definition.ts

@@ -0,0 +1,37 @@
+export class Exited {
+  readonly _tag = "Exited";
+  constructor(readonly nextKey: number, readonly exit: Exit<any, any>, readonly update: (_: Finalizer) => Finalizer) {}
+}
+
+export class Running {
+  readonly _tag = "Running";
+  constructor(
+    readonly nextKey: number,
+    readonly finalizers: HashMap<number, Finalizer>,
+    readonly update: (_: Finalizer) => Finalizer,
+  ) {}
+}
+
+export type State = Exited | Running;
+
+interface ReleaseMapN extends HKT {
+  readonly type: ReleaseMap;
+}
+
+/**
+ * @tsplus type fncts.io.Scope.ReleaseMap
+ */
+export interface ReleaseMap
+  extends Newtype<
+    {
+      readonly ReleaseMap: unique symbol;
+    },
+    Ref<State>
+  > {}
+
+/**
+ * @tsplus type fncts.io.Scope.ReleaseMapOps
+ */
+export interface ReleaseMapOps extends Newtype.Iso<ReleaseMapN> {}
+
+export const ReleaseMap: ReleaseMapOps = Newtype<ReleaseMapN>();

package/_src/Scope/ReleaseMap.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: ReleaseMap/*.ts }
+export * from "./ReleaseMap/api.js";
+export * from "./ReleaseMap/constructors.js";
+export * from "./ReleaseMap/definition.js";
+// codegen:end

package/_src/Scope/api.ts

@@ -0,0 +1,117 @@
+import { Closeable } from "./definition.js";
+import { ReleaseMap } from "./ReleaseMap.js";
+
+/**
+ * @tsplus fluent fncts.io.Scope addFinalizer
+ */
+export function addFinalizer_(self: Scope, finalizer: Lazy<UIO<any>>): UIO<void> {
+  return self.addFinalizerExit(Finalizer.get(() => finalizer()));
+}
+
+/**
+ * @tsplus static fncts.io.ScopeOps addFinalizer
+ */
+export function addFinalizer(finalizer: Lazy<UIO<void>>): IO<Has<Scope>, never, void> {
+  return IO.serviceWithIO((scope) => scope.addFinalizer(finalizer), Scope.Tag);
+}
+
+/**
+ * @tsplus static fncts.io.ScopeOps concurrent
+ * @tsplus static fncts.io.Scope.CloseableOps concurrent
+ */
+export const concurrent: UIO<Scope.Closeable> = makeWith(ExecutionStrategy.concurrent);
+
+/**
+ * @tsplus fluent fncts.io.Scope extend
+ */
+export function extend_<R, E, A>(self: Scope, io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A> {
+  return IO.defer(io).contramapEnvironment((r) => r.union(Environment.empty.add(self, Scope.Tag)));
+}
+
+/**
+ * @tsplus static fncts.io.ScopeOps global
+ */
+export const global: Scope.Closeable = new (class extends Closeable {
+  addFinalizerExit(_finalizer: Finalizer): UIO<void> {
+    return IO.unit;
+  }
+  close(_exit: Lazy<Exit<any, any>>): UIO<void> {
+    return IO.unit;
+  }
+  get fork(): UIO<Scope.Closeable> {
+    return Scope.make;
+  }
+})();
+
+/**
+ * @tsplus static fncts.io.ScopeOps make
+ * @tsplus static fncts.io.Scope.CloseableOps make
+ */
+export const make: UIO<Scope.Closeable> = makeWith(ExecutionStrategy.sequential);
+
+/**
+ * @tsplus static fncts.io.ScopeOps makeWith
+ * @tsplus static fncts.io.Scope.CloseableOps makeWith
+ */
+export function makeWith(executionStrategy: Lazy<ExecutionStrategy>): UIO<Scope.Closeable> {
+  return ReleaseMap.make.map(
+    (releaseMap) =>
+      new (class extends Closeable {
+        addFinalizerExit(finalizer: Finalizer): UIO<void> {
+          return releaseMap.add(finalizer).asUnit;
+        }
+        close(exit: Lazy<Exit<any, any>>): UIO<void> {
+          return IO.defer(releaseMap.releaseAll(exit(), executionStrategy()).asUnit);
+        }
+        get fork() {
+          return IO.uninterruptible(
+            IO.gen(function* (_) {
+              const scope     = yield* _(Scope.make);
+              const finalizer = yield* _(releaseMap.add(Finalizer.get((exit) => scope.close(exit))));
+              yield* _(scope.addFinalizerExit(finalizer));
+              return scope;
+            }),
+          );
+        }
+      })(),
+  );
+}
+
+/**
+ * @tsplus static fncts.io.ScopeOps unsafeMake
+ */
+export function unsafeMake() {
+  return unsafeMakeWith(ExecutionStrategy.sequential);
+}
+
+/**
+ * @tsplus static fncts.io.ScopeOps unsafeMakeWith
+ */
+export function unsafeMakeWith(executionStrategy: ExecutionStrategy): Scope.Closeable {
+  const releaseMap = ReleaseMap.unsafeMake();
+  return new (class extends Closeable {
+    addFinalizerExit(finalizer: Finalizer): UIO<void> {
+      return releaseMap.add(finalizer).asUnit;
+    }
+    close(exit: Lazy<Exit<any, any>>): UIO<void> {
+      return IO.defer(releaseMap.releaseAll(exit(), executionStrategy).asUnit);
+    }
+    get fork() {
+      return IO.uninterruptible(
+        IO.gen(function* (_) {
+          const scope     = yield* _(Scope.make);
+          const finalizer = yield* _(releaseMap.add(Finalizer.get((exit) => scope.close(exit))));
+          yield* _(scope.addFinalizerExit(finalizer));
+          return scope;
+        }),
+      );
+    }
+  })();
+}
+
+/**
+ * @tsplus fluent fncts.io.Scope.Closeable use
+ */
+export function use_<R, E, A>(self: Scope.Closeable, io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A> {
+  return self.extend(io).onExit((exit) => self.close(exit));
+}

package/_src/Scope/definition.ts

@@ -0,0 +1,31 @@
+export const ScopeTypeId = Symbol.for("fncts.base.control.Scope");
+export type ScopeTypeId = typeof ScopeTypeId;
+
+/**
+ * @tsplus type fncts.io.Scope
+ * @tsplus companion fncts.io.ScopeOps
+ */
+export abstract class Scope {
+  readonly _typeId: ScopeTypeId = ScopeTypeId;
+  abstract addFinalizerExit(finalizer: Finalizer): UIO<void>;
+  abstract fork: UIO<Scope.Closeable>;
+}
+
+/**
+ * @tsplus type fncts.io.Scope.Closeable
+ * @tsplus companion fncts.io.Scope.CloseableOps
+ */
+export abstract class Closeable extends Scope {
+  abstract close(exit: Lazy<Exit<any, any>>): UIO<void>;
+}
+
+type Closeable_ = Closeable;
+
+export declare namespace Scope {
+  type Closeable = Closeable_;
+}
+
+/**
+ * @tsplus static fncts.io.ScopeOps Tag
+ */
+export const ScopeTag = Tag<Scope>();

package/_src/Scope.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./Scope/*.ts, exclude: ./Scope/*(ReleaseMap|Finalizer).ts }
+export * from "./Scope/api.js";
+export * from "./Scope/definition.js";
+// codegen:end

package/_src/ScopedRef/api.ts

@@ -0,0 +1,50 @@
+/**
+ * @tsplus static fncts.io.ScopedRefOps fromAcquire
+ */
+export function fromAcquire<R, E, A>(
+  acquire: IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R & Has<Scope>, E, ScopedRef<A>> {
+  return IO.uninterruptibleMask(({ restore }) =>
+    IO.gen(function* (_) {
+      const newScope = yield* _(Scope.make);
+      const a        = yield* _(
+        restore(acquire(IO.$.provideSomeService(newScope, Scope.Tag))).tapCause((cause) =>
+          newScope.close(Exit.fail(cause)),
+        ),
+      );
+      const ref       = yield* _(Ref.Synchronized.make([newScope, a] as const));
+      const scopedRef = new Synch(ref);
+      yield* _(IO.addFinalizer(scopedRef.close));
+      return scopedRef;
+    }),
+  );
+}
+
+class Synch<A> extends ScopedRef<A> {
+  constructor(readonly ref: Ref.Synchronized<readonly [Scope.Closeable, A]>) {
+    super();
+  }
+
+  close: UIO<void> = this.ref.get.flatMap(([scope, _]) => scope.close(Exit.unit));
+
+  set<R, E>(acquire: IO<R & Has<Scope>, E, A>, __tsplusTrace?: string): IO<R, E, void> {
+    return this.ref.modifyIO(([oldScope, a]) =>
+      IO.uninterruptibleMask(({ restore }) =>
+        IO.gen(function* (_) {
+          const newScope = yield* _(Scope.make);
+          const exit     = yield* _(restore(acquire(IO.$.provideSomeService(newScope, Scope.Tag))).result);
+          return yield* _(
+            exit.match(
+              (cause): UIO<readonly [FIO<E, void>, readonly [Scope.Closeable, A]]> =>
+                newScope.close(Exit.unit).ignore.as([IO.failCauseNow(cause), [oldScope, a]] as const),
+              (a) => oldScope.close(Exit.unit).ignore.as([IO.unit, [newScope, a]] as const),
+            ),
+          );
+        }),
+      ),
+    ).flatten;
+  }
+
+  get: UIO<A> = this.ref.get.map(([_, a]) => a);
+}

package/_src/ScopedRef/definition.ts

@@ -0,0 +1,13 @@
+export const ScopedRefTypeId = Symbol.for("fncts.base.control.ScopedRef");
+export type ScopedRefTypeId = typeof ScopedRefTypeId;
+
+/**
+ * @tsplus type fncts.io.ScopedRef
+ * @tsplus companion fncts.io.ScopedRefOps
+ */
+export abstract class ScopedRef<A> {
+  readonly _typeId: ScopedRefTypeId = ScopedRefTypeId;
+
+  abstract set<R, E>(acquire: IO<R & Has<Scope>, E, A>, __tsplusTrace?: string): IO<R, E, void>;
+  abstract get: UIO<A>;
+}

package/_src/ScopedRef.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./ScopedRef/*.ts }
+export * from "./ScopedRef/api.js";
+export * from "./ScopedRef/definition.js";
+// codegen:end

package/_src/Sink/api.ts

@@ -0,0 +1,88 @@
+function collectLoop<Err, A>(state: Conc<A>): Channel<unknown, Err, Conc<A>, unknown, Err, Conc<never>, Conc<A>> {
+  return Channel.readWithCause(
+    (inp: Conc<A>) => collectLoop(state.concat(inp)),
+    Channel.failCauseNow,
+    () => Channel.endNow(state),
+  );
+}
+
+/**
+ * A sink that collects all of its inputs into a chunk.
+ *
+ * @tsplus static fncts.io.SinkOps collectAll
+ */
+export function collectAll<Err, A>(): Sink<unknown, Err, A, never, Conc<A>> {
+  return new Sink(collectLoop<Err, A>(Conc.empty()));
+}
+
+const drainLoop: Channel<unknown, never, Conc<unknown>, unknown, never, Conc<never>, void> = Channel.readWithCause(
+  () => drainLoop,
+  Channel.failCauseNow,
+  () => Channel.unit,
+);
+
+/**
+ * A sink that ignores all of its inputs.
+ *
+ * @tsplus static fncts.io.SinkOps drain
+ */
+export const drain: Sink<unknown, never, unknown, never, void> = new Sink(drainLoop);
+
+/**
+ * @tsplus static fncts.io.SinkOps dropWhile
+ */
+export function dropWhile<Err, In>(predicate: Predicate<In>): Sink<unknown, never, In, In, any> {
+  const loop: Channel<unknown, never, Conc<In>, any, never, Conc<In>, any> = Channel.readWith(
+    (inp: Conc<In>) => {
+      const leftover = inp.dropWhile(predicate);
+      const more     = leftover.isEmpty;
+      if (more) {
+        return loop;
+      } else {
+        return Channel.writeNow(leftover).apSecond(Channel.id<never, Conc<In>, any>());
+      }
+    },
+    Channel.failNow,
+    () => Channel.unit,
+  );
+  return new Sink(loop);
+}
+
+/**
+ * A sink that executes the provided effectful function for every element fed to it.
+ *
+ * @tsplus static fncts.io.SinkOps foreach
+ */
+export function foreach<R, Err, In>(f: (inp: In) => IO<R, Err, any>): Sink<R, Err, In, In, void> {
+  return Sink.foreachWhile((inp) => f(inp).as(true));
+}
+
+function foreachWhileLoop<R, Err, In>(
+  f: (_: In) => IO<R, Err, boolean>,
+  chunk: Conc<In>,
+  idx: number,
+  len: number,
+  cont: Channel<R, Err, Conc<In>, unknown, Err, Conc<In>, void>,
+): Channel<R, Err, Conc<In>, unknown, Err, Conc<In>, void> {
+  if (idx === len) {
+    return cont;
+  }
+  return Channel.fromIO(f(chunk.unsafeGet(idx)))
+    .flatMap((b) => (b ? foreachWhileLoop(f, chunk, idx + 1, len, cont) : Channel.writeNow(chunk.drop(idx))))
+    .catchAll((e) => Channel.writeNow(chunk.drop(idx)).apSecond(Channel.failNow(e)));
+}
+
+/**
+ * A sink that executes the provided effectful function for every element fed to it
+ * until `f` evaluates to `false`.
+ *
+ * @tsplus static fncts.io.SinkOps foreachWhile
+ */
+export function foreachWhile<R, Err, In>(f: (_: In) => IO<R, Err, boolean>): Sink<R, Err, In, In, void> {
+  const process: Channel<R, Err, Conc<In>, unknown, Err, Conc<In>, void> = Channel.readWithCause(
+    (inp: Conc<In>) => foreachWhileLoop(f, inp, 0, inp.length, process),
+    Channel.failCauseNow,
+    () => Channel.unit,
+  );
+  return new Sink(process);
+}

package/_src/Sink/definition.ts

@@ -0,0 +1,12 @@
+/**
+ * Sink is a data type that represent a channel that reads elements
+ * of type `In`, handles input errors of type `InErr`, emits errors
+ * of type `OutErr`, emits outputs of type `L` and ends with a value
+ * of type `Z`.
+ *
+ * @tsplus type fncts.io.Sink
+ * @tsplus companion fncts.io.SinkOps
+ */
+export class Sink<R, E, In, L, Z> {
+  constructor(readonly channel: Channel<R, never, Conc<In>, unknown, E, Conc<L>, Z>) {}
+}

package/_src/Sink.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./Sink/*.ts }
+export * from "./Sink/api.js";
+export * from "./Sink/definition.js";
+// codegen:end

package/_src/State/api.ts

@@ -0,0 +1,49 @@
+import type { State } from "./definition.js";
+
+import { concrete } from "./definition.js";
+import { StateInternal } from "./internal.js";
+
+/**
+ * @tsplus getter fncts.io.State get
+ */
+export function get_<S>(self: State<S>, __tsplusTrace?: string): UIO<S> {
+  concrete(self);
+  return self.get;
+}
+
+/**
+ * @tsplus static fncts.io.StateOps initial
+ */
+export function initial<S>(s: S, tag: Tag<State<S>>): Layer<unknown, never, Has<State<S>>> {
+  return Layer.scoped(
+    FiberRef.make(s).map(
+      (ref) =>
+        new (class extends StateInternal<S> {
+          get: UIO<S> = ref.get;
+          set(s: S, __tsplusTrace?: string): UIO<void> {
+            return ref.set(s);
+          }
+          update(f: (s: S) => S, __tsplusTrace?: string): UIO<void> {
+            return ref.update(f);
+          }
+        })(),
+    ),
+    tag,
+  );
+}
+
+/**
+ * @tsplus fluent fncts.io.State set
+ */
+export function set_<S>(self: State<S>, value: S, __tsplusTrace?: string): UIO<void> {
+  concrete(self);
+  return self.set(value);
+}
+
+/**
+ * @tsplus fluent fncts.io.State update
+ */
+export function update_<S>(self: State<S>, f: (s: S) => S, __tsplusTrace?: string): UIO<void> {
+  concrete(self);
+  return self.update(f);
+}

package/_src/State/definition.ts

@@ -0,0 +1,19 @@
+import type { StateInternal } from "./internal.js";
+
+import { StateTypeId } from "./internal.js";
+
+/**
+ * @tsplus type fncts.io.State
+ * @tsplus companion fncts.io.StateOps
+ */
+export abstract class State<S> {
+  readonly _A!: () => S;
+  readonly _typeId: StateTypeId = StateTypeId;
+}
+
+/**
+ * @tsplus macro remove
+ */
+export function concrete<A>(_: State<A>): asserts _ is StateInternal<A> {
+  //
+}