effect 2.4.0 → 2.4.2

package/src/Context.ts

@@ -27,15 +27,15 @@ export type TagTypeId = typeof TagTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Tag<in out Identifier, in out Service> extends Pipeable, Inspectable {
+export interface Tag<in out Id, in out Value> extends Pipeable, Inspectable {
   readonly _tag: "Tag"
   readonly _op: "Tag"
   readonly [TagTypeId]: {
-    readonly _Service: Types.Invariant<Service>
-    readonly _Identifier: Types.Invariant<Identifier>
+    readonly _Service: Types.Invariant<Value>
+    readonly _Identifier: Types.Invariant<Id>
   }
-  of(self: Service): Service
-  context(self: Service): Context<Identifier>
+  of(self: Value): Value
+  context(self: Value): Context<Id>
   readonly stack?: string | undefined
   readonly key: string
   [Unify.typeSymbol]?: unknown
@@ -48,18 +48,17 @@ export interface Tag<in out Identifier, in out Service> extends Pipeable, Inspec
  * @category models
  */
 export interface TagClassShape<Id, Shape> {
-  readonly [TagTypeId]: {
-    readonly Id: Id
-    readonly Shape: Shape
-  }
+  readonly [TagTypeId]: TagTypeId
+  readonly Type: Shape
+  readonly Id: Id
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface TagClass<Self, Id, Shape> extends Tag<Self, Shape> {
-  new(_: never): TagClassShape<Id, Shape>
+export interface TagClass<Self, Id, Type> extends Tag<Self, Type> {
+  new(_: never): TagClassShape<Id, Type>
 }
 
 /**

package/src/Duration.ts

@@ -46,13 +46,21 @@ export type DurationValue =
  * @category models
  */
 export type Unit =
+  | "nano"
   | "nanos"
+  | "micro"
   | "micros"
+  | "milli"
   | "millis"
+  | "second"
   | "seconds"
+  | "minute"
   | "minutes"
+  | "hour"
   | "hours"
+  | "day"
   | "days"
+  | "week"
   | "weeks"
 
 /**
@@ -66,7 +74,7 @@ export type DurationInput =
   | [seconds: number, nanos: number]
   | `${number} ${Unit}`
 
-const DURATION_REGEX = /^(-?\d+(?:\.\d+)?)\s+(nanos|micros|millis|seconds|minutes|hours|days|weeks)$/
+const DURATION_REGEX = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/
 
 /**
  * @since 2.0.0
@@ -89,20 +97,28 @@ export const decode = (input: DurationInput): Duration => {
       const [_, valueStr, unit] = match
       const value = Number(valueStr)
       switch (unit) {
+        case "nano":
         case "nanos":
           return nanos(BigInt(valueStr))
+        case "micro":
         case "micros":
           return micros(BigInt(valueStr))
+        case "milli":
         case "millis":
           return millis(value)
+        case "second":
         case "seconds":
           return seconds(value)
+        case "minute":
         case "minutes":
           return minutes(value)
+        case "hour":
         case "hours":
           return hours(value)
+        case "day":
         case "days":
           return days(value)
+        case "week":
         case "weeks":
           return weeks(value)
       }

package/src/Effect.ts

@@ -24,6 +24,7 @@ import type * as HashMap from "./HashMap.js"
 import type * as HashSet from "./HashSet.js"
 import type { TypeLambda } from "./HKT.js"
 import * as _console from "./internal/console.js"
+import { TagProto } from "./internal/context.js"
 import * as effect from "./internal/core-effect.js"
 import * as core from "./internal/core.js"
 import * as defaultServices from "./internal/defaultServices.js"
@@ -42,7 +43,7 @@ import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import type * as Random from "./Random.js"
 import type * as Ref from "./Ref.js"
-import type * as Request from "./Request.js"
+import * as Request from "./Request.js"
 import type { RequestBlock } from "./RequestBlock.js"
 import type { RequestResolver } from "./RequestResolver.js"
 import type * as Runtime from "./Runtime.js"
@@ -53,7 +54,7 @@ import * as Scheduler from "./Scheduler.js"
 import type * as Scope from "./Scope.js"
 import type * as Supervisor from "./Supervisor.js"
 import type * as Tracer from "./Tracer.js"
-import type { Concurrency, Covariant, MergeRecord, NoInfer } from "./Types.js"
+import type { Concurrency, Covariant, MergeRecord, NoInfer, NotFunction } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 // -------------------------------------------------------------------------------------
@@ -137,7 +138,7 @@ export interface Blocked<out A, out E> extends Effect<A, E> {
  * @category models
  */
 declare module "./Context.js" {
-  interface Tag<Identifier, Service> extends Effect<Service, never, Identifier> {}
+  interface Tag<Id, Value> extends Effect<Value, never, Id> {}
   interface TagUnifyIgnore {
     Effect?: true
     Either?: true
@@ -3103,11 +3104,10 @@ export const serviceFunctionEffect: <T extends Effect<any, any, any>, Args exten
 export const serviceFunctions: <S, SE, SR>(
   getService: Effect<S, SE, SR>
 ) => {
-  [k in { [k in keyof S]: S[k] extends (...args: Array<any>) => Effect<any, any, any> ? k : never }[keyof S]]:
-    S[k] extends (...args: infer Args) => Effect<infer A, infer E, infer R> ?
-      (...args: Args) => Effect<A, SE | E, SR | R> :
-      never
-} = effect.serviceFunctions
+  [k in keyof S as S[k] extends (...args: Array<any>) => Effect<any, any, any> ? k : never]: S[k] extends
+    (...args: infer Args) => Effect<infer A, infer E, infer R> ? (...args: Args) => Effect<A, SE | E, SR | R>
+    : never
+} = effect.serviceFunctions as any
 
 /**
  * @since 2.0.0
@@ -3124,20 +3124,19 @@ export const serviceConstants: <S, SE, SR>(
  * @since 2.0.0
  * @category context
  */
-export const serviceMembers: <SR, SE, S>(
+export const serviceMembers: <S, SE, SR>(
   getService: Effect<S, SE, SR>
 ) => {
   functions: {
-    [k in { [k in keyof S]: S[k] extends (...args: Array<any>) => Effect<any, any, any> ? k : never }[keyof S]]:
-      S[k] extends (...args: infer Args) => Effect<infer A, infer E, infer R> ?
-        (...args: Args) => Effect<A, SE | E, SR | R>
-        : never
+    [k in keyof S as S[k] extends (...args: Array<any>) => Effect<any, any, any> ? k : never]: S[k] extends
+      (...args: infer Args) => Effect<infer A, infer E, infer R> ? (...args: Args) => Effect<A, SE | E, SR | R>
+      : never
   }
   constants: {
     [k in { [k in keyof S]: k }[keyof S]]: S[k] extends Effect<infer A, infer E, infer R> ? Effect<A, SE | E, SR | R>
       : Effect<S[k], SE, SR>
   }
-} = effect.serviceMembers
+} = effect.serviceMembers as any
 
 /**
  * @since 2.0.0
@@ -3558,7 +3557,7 @@ export const andThen: {
     : [X] extends [Promise<infer A1>] ? Effect<A1, E | Cause.UnknownException, R>
     : Effect<X, E, R>
   <X>(
-    f: X
+    f: NotFunction<X>
   ): <A, E, R>(
     self: Effect<A, E, R>
   ) => [X] extends [Effect<infer A1, infer E1, infer R1>] ? Effect<A1, E | E1, R | R1>
@@ -3572,7 +3571,7 @@ export const andThen: {
     : Effect<X, E, R>
   <A, E, R, X>(
     self: Effect<A, E, R>,
-    f: X
+    f: NotFunction<X>
   ): [X] extends [Effect<infer A1, infer E1, infer R1>] ? Effect<A1, E | E1, R | R1>
     : [X] extends [Promise<infer A1>] ? Effect<A1, E | Cause.UnknownException, R>
     : Effect<X, E, R>
@@ -3687,7 +3686,7 @@ export const tap: {
     : [X] extends [Promise<infer _A1>] ? Effect<A, E | Cause.UnknownException, R>
     : Effect<A, E, R>
   <X>(
-    f: X
+    f: NotFunction<X>
   ): <A, E, R>(
     self: Effect<A, E, R>
   ) => [X] extends [Effect<infer _A1, infer E1, infer R1>] ? Effect<A, E | E1, R | R1>
@@ -3701,7 +3700,7 @@ export const tap: {
     : Effect<A, E, R>
   <A, E, R, X>(
     self: Effect<A, E, R>,
-    f: X
+    f: NotFunction<X>
   ): [X] extends [Effect<infer _A1, infer E1, infer R1>] ? Effect<A, E | E1, R | R1>
     : [X] extends [Promise<infer _A1>] ? Effect<A, E | Cause.UnknownException, R>
     : Effect<A, E, R>
@@ -4775,6 +4774,22 @@ export const zip: {
 } = fiberRuntime.zipOptions
 
 /**
+ * Sequentially run this effect with the specified effect, _discarding_ the result
+ * of the second effect (`that`) in the chain.
+ *
+ * `{ concurrent: true }` can be passed to the options to make it a concurrent execution
+ * of both effects instead of sequential.
+ *
+ * @example
+ *
+ * import { Effect } from 'effect';
+ *
+ * const effect = Effect.succeed("a message").pipe(
+ *   Effect.zipLeft(Effect.succeed(42)),
+ * )
+ *
+ * assert.deepStrictEqual(Effect.runSync(effect), "a message");
+ *
  * @since 2.0.0
  * @category zipping
  */
@@ -4795,6 +4810,22 @@ export const zipLeft: {
 } = fiberRuntime.zipLeftOptions
 
 /**
+ * Sequentially run this effect with the specified effect, _returning_ the result
+ * of the second effect (`that`) in the chain.
+ *
+ * `{ concurrent: true }` can be passed to the options to make it a concurrent execution
+ * of both effects instead of sequential.
+ *
+ * @example
+ *
+ * import { Effect } from 'effect';
+ *
+ * const effect = Effect.succeed("a message").pipe(
+ *   Effect.zipRight(Effect.succeed(42)),
+ * )
+ *
+ * assert.deepStrictEqual(Effect.runSync(effect), 42);
+ *
  * @since 2.0.0
  * @category zipping
  */
@@ -4882,18 +4913,27 @@ export const step: <A, E, R>(self: Effect<A, E, R>) => Effect<Exit.Exit<A, E> |
  * @category requests & batching
  */
 export const request: {
+  <A extends Request.Request<any, any>, Ds extends RequestResolver<A> | Effect<RequestResolver<A>, any, any>>(
+    dataSource: Ds
+  ): (
+    self: A
+  ) => Effect<
+    Request.Request.Success<A>,
+    Request.Request.Error<A>,
+    [Ds] extends [Effect<any, any, any>] ? Effect.Context<Ds> : never
+  >
   <
-    A extends Request.Request<any, any>,
-    Ds extends RequestResolver<A> | Effect<RequestResolver<A>, any, any>
+    Ds extends RequestResolver<A> | Effect<RequestResolver<A>, any, any>,
+    A extends Request.Request<any, any>
   >(
-    request: A,
+    self: A,
     dataSource: Ds
   ): Effect<
     Request.Request.Success<A>,
     Request.Request.Error<A>,
     [Ds] extends [Effect<any, any, any>] ? Effect.Context<Ds> : never
   >
-} = query.fromRequest as any
+} = dual((args) => Request.isRequest(args[0]), query.fromRequest)
 
 /**
  * @since 2.0.0
@@ -5198,3 +5238,65 @@ export const fromNullable: <A>(value: A) => Effect<NonNullable<A>, Cause.NoSuchE
 export const optionFromOptional: <A, E, R>(
   self: Effect<A, E, R>
 ) => Effect<Option.Option<A>, Exclude<E, Cause.NoSuchElementException>, R> = effect.optionFromOptional
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Tag: <const Id extends string>(id: Id) => <Self, Type>() =>
+  & Context.TagClass<Self, Id, Type>
+  & (Type extends Record<PropertyKey, any> ? {
+      [
+        k in keyof Type as Type[k] extends ((...args: [...infer Args]) => infer Ret) ?
+          ((...args: Readonly<Args>) => Ret) extends Type[k] ? k : never
+          : k
+      ]: Type[k] extends (...args: [...infer Args]) => Effect<infer A, infer E, infer R> ?
+        (...args: Readonly<Args>) => Effect<A, E, Self | R>
+        : Type[k] extends (...args: [...infer Args]) => infer A ? (...args: Readonly<Args>) => Effect<A, never, Self>
+        : Type[k] extends Effect<infer A, infer E, infer R> ? Effect<A, E, Self | R>
+        : Effect<Type[k], never, Self>
+    } :
+    {})
+  & {
+    use: <X>(
+      body: (_: Type) => X
+    ) => X extends Effect<infer A, infer E, infer R> ? Effect<A, E, R | Self> : Effect<X, never, Self>
+  } = (id) => () => {
+    const limit = Error.stackTraceLimit
+    Error.stackTraceLimit = 2
+    const creationError = new Error()
+    Error.stackTraceLimit = limit
+    function TagClass() {}
+    Object.setPrototypeOf(TagClass, TagProto)
+    TagClass.key = id
+    Object.defineProperty(TagClass, "stack", {
+      get() {
+        return creationError.stack
+      }
+    })
+    const cache = new Map()
+    const done = new Proxy(TagClass, {
+      get(_target: any, prop: any, _receiver) {
+        if (prop === "use") {
+          // @ts-expect-error
+          return (body) => core.andThen(TagClass, body)
+        }
+        if (prop in TagClass) {
+          // @ts-expect-error
+          return TagClass[prop]
+        }
+        if (cache.has(prop)) {
+          return cache.get(prop)
+        }
+        // @ts-expect-error
+        const fn = (...args: Array<any>) => core.andThen(TagClass, (s: any) => s[prop](...args))
+        // @ts-expect-error
+        const cn = core.andThen(TagClass, (s) => s[prop])
+        Object.assign(fn, cn)
+        Object.setPrototypeOf(fn, Object.getPrototypeOf(cn))
+        cache.set(prop, fn)
+        return fn
+      }
+    })
+    return done
+  }

package/src/Either.ts

@@ -12,7 +12,7 @@ import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import { isFunction } from "./Predicate.js"
-import type { Covariant, MergeRecord, NoInfer } from "./Types.js"
+import type { Covariant, MergeRecord, NoInfer, NotFunction } from "./Types.js"
 import type * as Unify from "./Unify.js"
 import * as Gen from "./Utils.js"
 
@@ -90,6 +90,22 @@ export interface EitherTypeLambda extends TypeLambda {
   readonly type: Either<this["Target"], this["Out1"]>
 }
 
+/**
+ * @since 2.0.0
+ */
+export declare namespace Either {
+  /**
+   * @since 2.0.0
+   * @category type-level
+   */
+  export type Left<T extends Either<any, any>> = [T] extends [Either<infer _A, infer _E>] ? _E : never
+  /**
+   * @since 2.0.0
+   * @category type-level
+   */
+  export type Right<T extends Either<any, any>> = [T] extends [Either<infer _A, infer _E>] ? _A : never
+}
+
 /**
  * Constructs a new `Either` holding a `Right` value. This usually represents a successful value due to the right bias
  * of this structure.
@@ -571,11 +587,11 @@ export const andThen: {
   <R, R2, L2>(f: (right: R) => Either<R2, L2>): <L>(self: Either<R, L>) => Either<R2, L | L2>
   <R2, L2>(f: Either<R2, L2>): <L, R1>(self: Either<R1, L>) => Either<R2, L | L2>
   <R, R2>(f: (right: R) => R2): <L>(self: Either<R, L>) => Either<R2, L>
-  <R2>(right: R2): <R1, L>(self: Either<R1, L>) => Either<R2, L>
+  <R2>(right: NotFunction<R2>): <R1, L>(self: Either<R1, L>) => Either<R2, L>
   <R, L, R2, L2>(self: Either<R, L>, f: (right: R) => Either<R2, L2>): Either<R2, L | L2>
   <R, L, R2, L2>(self: Either<R, L>, f: Either<R2, L2>): Either<R2, L | L2>
   <R, L, R2>(self: Either<R, L>, f: (right: R) => R2): Either<R2, L>
-  <R, L, R2>(self: Either<R, L>, f: R2): Either<R2, L>
+  <R, L, R2>(self: Either<R, L>, f: NotFunction<R2>): Either<R2, L>
 } = dual(
   2,
   <R, L, R2, L2>(self: Either<R, L>, f: (right: R) => Either<R2, L2> | Either<R2, L2>): Either<R2, L | L2> =>

package/src/FiberMap.ts

@@ -4,6 +4,9 @@
 import * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
 import type { NoSuchElementException } from "./Cause.js"
+import * as Cause from "./Cause.js"
+import * as Deferred from "./Deferred.js"
+import * as Exit from "./Exit.js"
 import * as Fiber from "./Fiber.js"
 import * as FiberId from "./FiberId.js"
 import { dual } from "./Function.js"
@@ -30,11 +33,12 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @categories models
  */
-export interface FiberMap<K, A = unknown, E = unknown>
+export interface FiberMap<in out K, out A = unknown, out E = unknown>
   extends Pipeable, Inspectable.Inspectable, Iterable<[K, Fiber.RuntimeFiber<A, E>]>
 {
   readonly [TypeId]: TypeId
   readonly backing: MutableHashMap.MutableHashMap<K, Fiber.RuntimeFiber<A, E>>
+  readonly deferred: Deferred.Deferred<never, unknown>
 }
 
 /**
@@ -65,9 +69,13 @@ const Proto = {
   }
 }
 
-const unsafeMake = <K, A = unknown, E = unknown>(): FiberMap<K, A, E> => {
+const unsafeMake = <K, A = unknown, E = unknown>(
+  backing: MutableHashMap.MutableHashMap<K, Fiber.RuntimeFiber<A, E>>,
+  deferred: Deferred.Deferred<never, E>
+): FiberMap<K, A, E> => {
   const self = Object.create(Proto)
-  self.backing = MutableHashMap.empty()
+  self.backing = backing
+  self.deferred = deferred
   return self
 }
 
@@ -97,7 +105,14 @@ const unsafeMake = <K, A = unknown, E = unknown>(): FiberMap<K, A, E> => {
  * @categories constructors
  */
 export const make = <K, A = unknown, E = unknown>(): Effect.Effect<FiberMap<K, A, E>, never, Scope.Scope> =>
-  Effect.acquireRelease(Effect.sync(() => unsafeMake<K, A, E>()), clear)
+  Effect.acquireRelease(
+    Effect.map(Deferred.make<never, E>(), (deferred) =>
+      unsafeMake<K, A, E>(
+        MutableHashMap.empty(),
+        deferred
+      )),
+    clear
+  )
 
 /**
  * Create an Effect run function that is backed by a FiberMap.
@@ -159,11 +174,14 @@ export const unsafeSet: {
     previous.value.unsafeInterruptAsFork(interruptAs ?? FiberId.none)
   }
   MutableHashMap.set(self.backing, key, fiber)
-  fiber.addObserver((_) => {
+  fiber.addObserver((exit) => {
     const current = MutableHashMap.get(self.backing, key)
     if (Option.isSome(current) && fiber === current.value) {
       MutableHashMap.remove(self.backing, key)
     }
+    if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
+      Deferred.unsafeDone(self.deferred, exit as any)
+    }
   })
 })
 
@@ -372,5 +390,25 @@ export const runtime: <K, A, E>(
  * @since 2.0.0
  * @categories combinators
  */
-export const size = <K, E, A>(self: FiberMap<K, E, A>): Effect.Effect<number> =>
+export const size = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<number> =>
   Effect.sync(() => MutableHashMap.size(self.backing))
+
+/**
+ * Join all fibers in the FiberMap. If any of the Fiber's in the map terminate with a failure,
+ * the returned Effect will terminate with the first failure that occurred.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ * @example
+ * import { Effect, FiberMap } from "effect";
+ *
+ * Effect.gen(function* (_) {
+ *   const map = yield* _(FiberMap.make());
+ *   yield* _(FiberMap.set(map, "a", Effect.runFork(Effect.fail("error"))));
+ *
+ *   // parent fiber will fail with "error"
+ *   yield* _(FiberMap.join(map));
+ * });
+ */
+export const join = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<never, E> =>
+  Deferred.await(self.deferred as Deferred.Deferred<never, E>)

package/src/FiberSet.ts

@@ -3,6 +3,9 @@
  */
 import * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
+import * as Cause from "./Cause.js"
+import * as Deferred from "./Deferred.js"
+import * as Exit from "./Exit.js"
 import * as Fiber from "./Fiber.js"
 import { dual } from "./Function.js"
 import * as Inspectable from "./Inspectable.js"
@@ -31,6 +34,7 @@ export interface FiberSet<out A = unknown, out E = unknown>
 {
   readonly [TypeId]: TypeId
   readonly backing: Set<Fiber.RuntimeFiber<A, E>>
+  readonly deferred: Deferred.Deferred<never, unknown>
 }
 
 /**
@@ -61,9 +65,13 @@ const Proto = {
   }
 }
 
-const unsafeMake = <A, E>(): FiberSet<A, E> => {
+const unsafeMake = <A, E>(
+  backing: Set<Fiber.RuntimeFiber<A, E>>,
+  deferred: Deferred.Deferred<never, unknown>
+): FiberSet<A, E> => {
   const self = Object.create(Proto)
-  self.backing = new Set()
+  self.backing = backing
+  self.deferred = deferred
   return self
 }
 
@@ -93,7 +101,10 @@ const unsafeMake = <A, E>(): FiberSet<A, E> => {
  * @categories constructors
  */
 export const make = <A = unknown, E = unknown>(): Effect.Effect<FiberSet<A, E>, never, Scope.Scope> =>
-  Effect.acquireRelease(Effect.sync(() => unsafeMake<A, E>()), clear)
+  Effect.acquireRelease(
+    Effect.map(Deferred.make<never, unknown>(), (deferred) => unsafeMake(new Set(), deferred)),
+    clear
+  )
 
 /**
  * Create an Effect run function that is backed by a FiberSet.
@@ -136,8 +147,11 @@ export const unsafeAdd: {
     return
   }
   self.backing.add(fiber)
-  fiber.addObserver((_) => {
+  fiber.addObserver((exit) => {
     self.backing.delete(fiber)
+    if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
+      Deferred.unsafeDone(self.deferred, exit as any)
+    }
   })
 })
 
@@ -264,3 +278,23 @@ export const runtime: <A, E>(
  * @categories combinators
  */
 export const size = <A, E>(self: FiberSet<A, E>): Effect.Effect<number> => Effect.sync(() => self.backing.size)
+
+/**
+ * Join all fibers in the FiberSet. If any of the Fiber's in the set terminate with a failure,
+ * the returned Effect will terminate with the first failure that occurred.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ * @example
+ * import { Effect, FiberSet } from "effect";
+ *
+ * Effect.gen(function* (_) {
+ *   const set = yield* _(FiberSet.make());
+ *   yield* _(FiberSet.add(set, Effect.runFork(Effect.fail("error"))));
+ *
+ *   // parent fiber will fail with "error"
+ *   yield* _(FiberSet.join(set));
+ * });
+ */
+export const join = <A, E>(self: FiberSet<A, E>): Effect.Effect<never, E> =>
+  Deferred.await(self.deferred as Deferred.Deferred<never, E>)