@typed/fx 2.0.0-beta.3 → 2.0.0-beta.4

package/src/Fx/constructors/make.ts

@@ -75,7 +75,7 @@ export const callback = <A, E = never, R = never>(
         withEarlyExit(
           sink,
           Effect.fn(function* <RSink = never>(sink: Sink.WithEarlyExit<A, E, RSink>) {
-            const services = yield* Effect.services<R | RSink>();
+            const services = yield* Effect.context<R | RSink>();
             const runFork = Effect.runForkWith(services);
             const controller = new AbortController();
             yield* Scope.addFinalizer(
@@ -94,7 +94,7 @@ export const callback = <A, E = never, R = never>(
             };
 
             const effect = run(emit);
-            if (effect) yield* Scope.addFinalizer(scope, Effect.provideServices(effect, services));
+            if (effect) yield* Scope.addFinalizer(scope, Effect.provideContext(effect, services));
             return yield* Effect.never;
           }),
         ),

package/src/Fx/run/observe.ts

@@ -8,7 +8,7 @@ import {
   isEffect,
   matchCauseEffect,
   runForkWith,
-  servicesWith,
+  contextWith,
   sync,
   void as void_,
 } from "effect/Effect";
@@ -45,7 +45,7 @@ export const observe: {
     fx: Fx<A, E, R>,
     f: (value: A) => void | Effect<unknown, E2, R2>,
   ): Effect<unknown, E | E2, R | R2> =>
-    servicesWith((services) =>
+    contextWith((services) =>
       callback<void, E | E2, R | R2>((resume) => {
         const onFailure = (cause: Cause<E | E2>) => sync(() => resume(failCause(cause)));
         const onSuccess = (value: A) => {

package/src/Fx.provide-combinators.test.ts

@@ -1,9 +1,9 @@
 import { assert, describe, it } from "vitest";
 import * as Effect from "effect/Effect";
 import { Fx } from "./index.js";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 
-const Foo = ServiceMap.Service<{ readonly n: number }>("Test/Foo");
+const Foo = Context.Service<{ readonly n: number }>("Test/Foo");
 
 describe("Fx provideService", () => {
   it("provides a single service and Fx can use it", () =>

package/src/Push/Push.ts

@@ -11,7 +11,7 @@ import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import { pipeArguments } from "effect/Pipeable";
 import type * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import * as Fx from "../Fx/index.js";
 import { FxTypeId } from "../Fx/TypeId.js";
 import * as Sink from "../Sink.js";
@@ -68,7 +68,7 @@ export namespace Push {
     Self
   > {
     readonly id: Id;
-    readonly service: ServiceMap.Service<Self, Push<A, E, never, B, E2, never>>;
+    readonly service: Context.Service<Self, Push<A, E, never, B, E2, never>>;
     readonly make: <R = never, R2 = never>(
       sink: Sink.Sink<A, E, R>,
       fx: Fx.Fx<B, E2, R2>,
@@ -201,13 +201,20 @@ export const mapInput: {
     f: (c: C) => Sink.Success<P>,
   ): (
     push: P,
-  ) => Push<Sink.Context<P>, Sink.Error<P>, C, Fx.Fx.Services<P>, Fx.Fx.Error<P>, Fx.Fx.Success<P>>;
+  ) => Push<
+    Sink.Services<P>,
+    Sink.Error<P>,
+    C,
+    Fx.Fx.Services<P>,
+    Fx.Fx.Error<P>,
+    Fx.Fx.Success<P>
+  >;
 
   <P extends Push.Any, C>(
     push: P,
     f: (c: C) => Sink.Sink.Success<P>,
   ): Push<
-    Sink.Sink.Context<P>,
+    Sink.Sink.Services<P>,
     Sink.Sink.Error<P>,
     C,
     Fx.Fx.Services<P>,
@@ -215,7 +222,7 @@ export const mapInput: {
     Fx.Fx.Success<P>
   >;
 } = dual(2, function mapInput<P extends Push.Any, C>(push: P, f: (c: C) => Sink.Success<P>): Push<
-  Sink.Context<P>,
+  Sink.Services<P>,
   Sink.Error<P>,
   C,
   Fx.Fx.Services<P>,
@@ -259,7 +266,14 @@ export const filterInput: {
     f: (a: A) => boolean,
   ): <P extends Push.Any>(
     push: P,
-  ) => Push<Sink.Context<P>, Sink.Error<P>, A, Fx.Fx.Services<P>, Fx.Fx.Error<P>, Fx.Fx.Success<P>>;
+  ) => Push<
+    Sink.Services<P>,
+    Sink.Error<P>,
+    A,
+    Fx.Fx.Services<P>,
+    Fx.Fx.Error<P>,
+    Fx.Fx.Success<P>
+  >;
   <A, E, R, B, E2, R2>(
     push: Push<A, E, R, B, E2, R2>,
     f: (a: A) => boolean,
@@ -308,7 +322,14 @@ export const filterMapInput: {
     f: (c: C) => Option.Option<A>,
   ): <P extends Push.Any>(
     push: P,
-  ) => Push<C, Sink.Error<P>, Sink.Context<P>, Fx.Fx.Success<P>, Fx.Fx.Error<P>, Fx.Fx.Services<P>>;
+  ) => Push<
+    C,
+    Sink.Error<P>,
+    Sink.Services<P>,
+    Fx.Fx.Success<P>,
+    Fx.Fx.Error<P>,
+    Fx.Fx.Services<P>
+  >;
   <A, E, R, B, E2, R2, C>(
     push: Push<A, E, R, B, E2, R2>,
     f: (c: C) => Option.Option<A>,
@@ -1015,7 +1036,7 @@ export const mapAccumEffect: {
 
 export function Service<Self, A, E = never, B = never, E2 = never>() {
   return <const Id extends string>(id: Id): Push.Class<Self, Id, A, E, B, E2> => {
-    const service = ServiceMap.Service<Self, Push<A, E, never, B, E2, never>>(id);
+    const service = Context.Service<Self, Push<A, E, never, B, E2, never>>(id);
 
     // eslint-disable-next-line @typescript-eslint/no-extraneous-class
     return class PushService {
@@ -1028,17 +1049,17 @@ export function Service<Self, A, E = never, B = never, E2 = never>() {
       ): Layer.Layer<Self, never, Exclude<R | R2, Scope.Scope>> =>
         Layer.effect(
           service,
-          Effect.services<R | R2>().pipe(
+          Effect.context<R | R2>().pipe(
             Effect.map((services) =>
               make(
                 Sink.make(
-                  (cause) => Effect.provideServices(sink.onFailure(cause), services),
-                  (value) => Effect.provideServices(sink.onSuccess(value), services),
+                  (cause) => Effect.provideContext(sink.onFailure(cause), services),
+                  (value) => Effect.provideContext(sink.onSuccess(value), services),
                 ),
                 Fx.make(<RSink>(sink: Sink.Sink<B, E2, RSink>) =>
-                  Effect.services<RSink>().pipe(
+                  Effect.context<RSink>().pipe(
                     Effect.flatMap((services2) =>
-                      Effect.provideServices(fx.run(sink), ServiceMap.merge(services, services2)),
+                      Effect.provideContext(fx.run(sink), Context.merge(services, services2)),
                     ),
                   ),
                 ),

package/src/RefSubject/RefSubject.ts

@@ -16,7 +16,7 @@ import { sum } from "effect/Number";
 import * as Option from "effect/Option";
 import { pipeArguments } from "effect/Pipeable";
 import * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import * as Stream from "effect/Stream";
 import { compact as fxCompact } from "../Fx/combinators/compact.js";
 import { continueWith } from "../Fx/combinators/continueWith.js";
@@ -291,7 +291,7 @@ export declare namespace RefSubject {
   export interface Service<Self, Id extends string, A, E> extends RefSubject<A, E, Self> {
     readonly id: Id;
 
-    readonly service: ServiceMap.Service<Self, RefSubject<A, E>>;
+    readonly service: Context.Service<Self, RefSubject<A, E>>;
 
     readonly make: <R = never>(
       value: A | Effect.Effect<A, E, R> | Fx<A, E, R>,
@@ -307,14 +307,12 @@ export declare namespace RefSubject {
     new (): RefSubject.Service<Self, Id, A, E>;
   }
 }
-export const CurrentComputedBehavior = ServiceMap.Reference("@typed/fx/CurrentComputedBehavior", {
+export const CurrentComputedBehavior = Context.Reference("@typed/fx/CurrentComputedBehavior", {
   defaultValue: (): "one" | "multiple" => "multiple",
 });
 
-const checkIsMultiple = (
-  ctx: ServiceMap.ServiceMap<any>,
-): ctx is ServiceMap.ServiceMap<"multiple"> =>
-  ServiceMap.getReferenceUnsafe(ctx, CurrentComputedBehavior) === "multiple";
+const checkIsMultiple = (ctx: Context.Context<any>): ctx is Context.Context<"multiple"> =>
+  Context.getReferenceUnsafe(ctx, CurrentComputedBehavior) === "multiple";
 
 class ComputedImpl<R0, E0, A, E, R, E2, R2, C, E3, R3>
   extends Versioned.VersionedTransform<
@@ -352,7 +350,7 @@ class ComputedImpl<R0, E0, A, E, R, E2, R2, C, E3, R3>
 
     this._computed = Subject.hold(
       unwrap(
-        Effect.map(Effect.services(), (ctx) => {
+        Effect.map(Effect.context(), (ctx) => {
           if (checkIsMultiple(ctx)) {
             return fromYieldable(input).pipe(
               continueWith(() => input),
@@ -426,7 +424,7 @@ class FilteredImpl<R0, E0, A, E, R, E2, R2, C, E3, R3>
 
     this._computed = Subject.hold(
       unwrap(
-        Effect.map(Effect.services(), (ctx) => {
+        Effect.map(Effect.context(), (ctx) => {
           if (checkIsMultiple(ctx)) {
             return fromYieldable(input).pipe(
               continueWith(() => input),
@@ -457,14 +455,14 @@ class FilteredImpl<R0, E0, A, E, R, E2, R2, C, E3, R3>
 class RefSubjectCore<A, E, R, R2> {
   readonly initial: Effect.Effect<A, E, R>;
   readonly subject: Subject.HoldSubjectImpl<A, E>;
-  readonly services: ServiceMap.ServiceMap<R2>;
+  readonly services: Context.Context<R2>;
   readonly scope: Scope.Closeable;
   readonly deferredRef: DeferredRef.DeferredRef<E, A>;
   readonly semaphore: Semaphore.Semaphore;
   constructor(
     initial: Effect.Effect<A, E, R>,
     subject: Subject.HoldSubjectImpl<A, E>,
-    services: ServiceMap.ServiceMap<R2>,
+    services: Context.Context<R2>,
     scope: Scope.Closeable,
     deferredRef: DeferredRef.DeferredRef<E, A>,
     semaphore: Semaphore.Semaphore,
@@ -766,8 +764,8 @@ function makeCore<A, E, R>(
   deferredRef?: DeferredRef.DeferredRef<E, A>,
 ) {
   return Effect.gen(function* () {
-    const services = yield* Effect.services<R | Scope.Scope>();
-    const scope = yield* Scope.fork(ServiceMap.get(services, Scope.Scope));
+    const services = yield* Effect.context<R | Scope.Scope>();
+    const scope = yield* Scope.fork(Context.get(services, Scope.Scope));
     const id = yield* Effect.withFiber((fiber) => Effect.succeed(fiber.id));
     const subject = new Subject.HoldSubjectImpl<A, E>();
     const core = new RefSubjectCore(
@@ -1335,7 +1333,7 @@ const Variance: Fx.Variance<any, any, any> = {
 
 export function Service<Self, A, E = never>() {
   return <const Id extends string>(id: Id): RefSubject.Class<Self, Id, A, E> => {
-    const service = ServiceMap.Service<Self, RefSubject<A, E>>(id);
+    const service = Context.Service<Self, RefSubject<A, E>>(id);
 
     // eslint-disable-next-line @typescript-eslint/no-extraneous-class
     return class RefSubjectService {

package/src/Sink/Sink.ts

@@ -1,11 +1,11 @@
 import type * as Cause from "effect/Cause";
 import type { Effect } from "effect/Effect";
-import { flatMap, map, provide, services } from "effect/Effect";
+import { flatMap, map, provide, context } from "effect/Effect";
 import type { Layer } from "effect/Layer";
 import { effect } from "effect/Layer";
 import type { Ref } from "effect/Ref";
 import type { Scope } from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 
 /**
  * A Sink is a consumer of values. It consists of two effectful callbacks:
@@ -46,11 +46,11 @@ export declare namespace Sink {
    * @since 1.0.0
    * @category type-level
    */
-  export type Context<T> = T extends Sink<infer _A, infer _E, infer _R> ? _R : never;
+  export type Services<T> = T extends Sink<infer _A, infer _E, infer _R> ? _R : never;
 
   export interface Service<Self, Id extends string, A, E> extends Sink<A, E, Self> {
     readonly id: Id;
-    readonly service: ServiceMap.Service<Self, Sink<A, E>>;
+    readonly service: Context.Service<Self, Sink<A, E>>;
     readonly make: <R = never>(
       onFailure: (cause: Cause.Cause<E>) => Effect<unknown, never, R>,
       onSuccess: (value: A) => Effect<unknown, never, R>,
@@ -64,7 +64,7 @@ export declare namespace Sink {
 
 export type Success<T> = Sink.Success<T>;
 export type Error<T> = Sink.Error<T>;
-export type Context<T> = Sink.Context<T>;
+export type Services<T> = Sink.Services<T>;
 
 /**
  * Creates a Sink from success and failure callbacks.
@@ -124,7 +124,7 @@ export declare namespace Sink {
 
 export function Service<Self, A, E = never>() {
   return <const Id extends string>(id: Id): Sink.Class<Self, Id, A, E> => {
-    const service = ServiceMap.Service<Self, Sink<A, E>>(id);
+    const service = Context.Service<Self, Sink<A, E>>(id);
 
     // eslint-disable-next-line @typescript-eslint/no-extraneous-class
     return class SinkService {
@@ -137,7 +137,7 @@ export function Service<Self, A, E = never>() {
       ): Layer<Self, never, Exclude<R | R2, Scope>> =>
         effect(
           service,
-          map(services<R | R2>(), (context) =>
+          map(context<R | R2>(), (context) =>
             make(
               (cause) => provide(onFailure(cause), context),
               (value) => provide(onSuccess(value), context),

package/src/Sink/combinators.ts

@@ -219,7 +219,7 @@ export function withEarlyExit<A, E, R, R2>(
     params: { signal: AbortSignal; scheduler: Scheduler },
   ) => Effect.Effect<unknown, never, R2>,
 ): Effect.Effect<void, never, R | R2> {
-  return Effect.servicesWith((services) =>
+  return Effect.contextWith((services) =>
     Effect.callback<unknown, never, R2>(function (this: Scheduler, resume, signal) {
       let exited = false;
       const earlyExit = Effect.sync<void>(() => {

package/src/Subject/Subject.ts

@@ -8,7 +8,7 @@ import * as MutableRef from "effect/MutableRef";
 import * as Option from "effect/Option";
 import { pipeArguments } from "effect/Pipeable";
 import * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import type * as Fx from "../Fx/index.js";
 import { RingBuffer } from "../Fx/internal/ring-buffer.js";
 import { awaitScopeClose, withExtendedScope } from "../Fx/internal/scope.js";
@@ -37,7 +37,7 @@ export interface Subject<A, E = never, R = never>
 export declare namespace Subject {
   export interface Service<Self, Id extends string, A, E> extends Subject<A, E, Self> {
     readonly id: Id;
-    readonly service: ServiceMap.Service<Self, Subject<A, E>>;
+    readonly service: Context.Service<Self, Subject<A, E>>;
     readonly make: (replay?: number) => Layer.Layer<Self, never, Scope.Scope>;
   }
 
@@ -191,9 +191,8 @@ const DISCARD = { discard: true } as const;
  */
 export class SubjectImpl<A, E> implements Subject<A, E> {
   readonly [FxTypeId]: Fx.Fx.Variance<A, E, Scope.Scope> = VARIANCE;
-  protected sinks: Set<
-    readonly [Sink.Sink<A, E, any>, ServiceMap.ServiceMap<any>, Scope.Closeable]
-  > = new Set();
+  protected sinks: Set<readonly [Sink.Sink<A, E, any>, Context.Context<any>, Scope.Closeable]> =
+    new Set();
 
   constructor() {
     this.onFailure = this.onFailure.bind(this);
@@ -232,7 +231,7 @@ export class SubjectImpl<A, E> implements Subject<A, E> {
   ): Effect.Effect<B, never, R2 | Scope.Scope> {
     return withExtendedScope(
       (innerScope) =>
-        Effect.servicesWith((ctx) => {
+        Effect.contextWith((ctx) => {
           const entry = [sink, ctx, innerScope] as const;
           this.sinks.add(entry);
           const remove = Effect.sync(() => this.sinks.delete(entry));
@@ -272,7 +271,7 @@ export class SubjectImpl<A, E> implements Subject<A, E> {
 
 function runSinkEvent<A, E>(
   sink: Sink.Sink<A, E, any>,
-  ctx: ServiceMap.ServiceMap<any>,
+  ctx: Context.Context<any>,
   a: A,
 ): Effect.Effect<void, never, never> {
   return Effect.provide(Effect.catchCause(sink.onSuccess(a), sink.onFailure), ctx);
@@ -280,7 +279,7 @@ function runSinkEvent<A, E>(
 
 function runSinkCause<A, E>(
   sink: Sink.Sink<A, E, any>,
-  ctx: ServiceMap.ServiceMap<any>,
+  ctx: Context.Context<any>,
   scope: Scope.Closeable,
   cause: Cause.Cause<E>,
 ): Effect.Effect<void, never, never> {
@@ -398,7 +397,7 @@ export function make<A, E = never>(
 
 export function Service<Self, A, E = never>() {
   return <const Id extends string>(id: Id): Subject.Class<Self, Id, A, E> => {
-    const service = ServiceMap.Service<Self, Subject<A, E>>(id);
+    const service = Context.Service<Self, Subject<A, E>>(id);
 
     // eslint-disable-next-line @typescript-eslint/no-extraneous-class
     return class SubjectService {

package/src/Versioned/Versioned.ts

@@ -16,14 +16,14 @@ import { sum } from "effect/Number";
 import * as Option from "effect/Option";
 import { pipeArguments } from "effect/Pipeable";
 import type * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import { filterMap as fxFilterMap } from "../Fx/combinators/filterMap.js";
 import { filterMapEffect as fxFilterMapEffect } from "../Fx/combinators/filterMapEffect.js";
 import { map as fxMap } from "../Fx/combinators/map.js";
 import { mapEffect as fxMapEffect } from "../Fx/combinators/mapEffect.js";
 import {
   provide as fxProvide,
-  provideServices as fxProvideServices,
+  provideContext as fxprovideContext,
 } from "../Fx/combinators/provide.js";
 import { struct as fxStruct, tuple as fxTuple } from "../Fx/combinators/tuple.js";
 import { succeed as fxSucceed } from "../Fx/constructors/succeed.js";
@@ -92,7 +92,7 @@ export namespace Versioned {
     Self
   > {
     readonly id: Id;
-    readonly service: ServiceMap.Service<Self, Versioned<never, E1, A2, E2, never, A3, E3, never>>;
+    readonly service: Context.Service<Self, Versioned<never, E1, A2, E2, never, A3, E3, never>>;
     readonly make: <R1 = never, R2 = never, R3 = never>(
       version: Effect.Effect<number, E1, R1>,
       fx: Fx.Fx<A2, E2, R2>,
@@ -545,9 +545,7 @@ const VARIANCE = {
 
 export function Service<Self, E1 = never, A2 = never, E2 = never, A3 = never, E3 = never>() {
   return <const Id extends string>(id: Id): Versioned.Class<Self, Id, E1, A2, E2, A3, E3> => {
-    const service = ServiceMap.Service<Self, Versioned<never, E1, A2, E2, never, A3, E3, never>>(
-      id,
-    );
+    const service = Context.Service<Self, Versioned<never, E1, A2, E2, never, A3, E3, never>>(id);
 
     // eslint-disable-next-line @typescript-eslint/no-extraneous-class
     return class VersionedService {
@@ -561,11 +559,11 @@ export function Service<Self, E1 = never, A2 = never, E2 = never, A3 = never, E3
       ): Layer.Layer<Self, never, Exclude<R1 | R2 | R3, Scope.Scope>> =>
         Layer.effect(
           service,
-          Effect.services<R1 | R2 | R3>().pipe(
+          Effect.context<R1 | R2 | R3>().pipe(
             Effect.map((context) =>
               make(
                 Effect.provide(version, context),
-                fxProvideServices(fx, context),
+                fxprovideContext(fx, context),
                 Effect.provide(effect.asEffect(), context),
               ),
             ),