effect 3.8.5 → 3.9.1

package/src/Layer.ts

@@ -76,23 +76,34 @@ export declare namespace Layer {
       readonly _RIn: Types.Covariant<RIn>
     }
   }
+  /**
+   * @since 3.9.0
+   * @category type-level
+   */
+  export interface Any {
+    readonly [LayerTypeId]: {
+      readonly _ROut: any
+      readonly _E: any
+      readonly _RIn: any
+    }
+  }
   /**
    * @since 2.0.0
    * @category type-level
    */
-  export type Context<T extends Layer<never, any, any>> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _RIn
+  export type Context<T extends Any> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _RIn
     : never
   /**
    * @since 2.0.0
    * @category type-level
    */
-  export type Error<T extends Layer<never, any, any>> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _E
+  export type Error<T extends Any> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _E
     : never
   /**
    * @since 2.0.0
    * @category type-level
    */
-  export type Success<T extends Layer<never, any, any>> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _ROut
+  export type Success<T extends Any> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _ROut
     : never
 }
 
@@ -1157,8 +1168,24 @@ export const provide: {
    * @category utils
    */
   <RIn, E, ROut>(
-    self: Layer<ROut, E, RIn>
-  ): <RIn2, E2, ROut2>(that: Layer<ROut2, E2, RIn2>) => Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
+    that: Layer<ROut, E, RIn>
+  ): <RIn2, E2, ROut2>(self: Layer<ROut2, E2, RIn2>) => Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
+  /**
+   * Feeds the output services of this builder into the input of the specified
+   * builder, resulting in a new builder with the inputs of this builder as
+   * well as any leftover inputs, and the outputs of the specified builder.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
+  <const Layers extends [Layer.Any, ...Array<Layer.Any>]>(that: Layers): <A, E, R>(
+    self: Layer<A, E, R>
+  ) => Layer<
+    A,
+    E | { [k in keyof Layers]: Layer.Error<Layers[k]> }[number],
+    | { [k in keyof Layers]: Layer.Context<Layers[k]> }[number]
+    | Exclude<R, { [k in keyof Layers]: Layer.Success<Layers[k]> }[number]>
+  >
   /**
    * Feeds the output services of this builder into the input of the specified
    * builder, resulting in a new builder with the inputs of this builder as
@@ -1168,9 +1195,23 @@ export const provide: {
    * @category utils
    */
   <RIn2, E2, ROut2, RIn, E, ROut>(
-    that: Layer<ROut2, E2, RIn2>,
-    self: Layer<ROut, E, RIn>
-  ): Layer<ROut2, E2 | E, RIn | Exclude<RIn2, ROut>>
+    self: Layer<ROut2, E2, RIn2>,
+    that: Layer<ROut, E, RIn>
+  ): Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
+  /**
+   * Feeds the output services of this builder into the input of the specified
+   * builder, resulting in a new builder with the inputs of this builder as
+   * well as any leftover inputs, and the outputs of the specified builder.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
+  <A, E, R, const Layers extends [Layer.Any, ...Array<Layer.Any>]>(self: Layer<A, E, R>, that: Layers): Layer<
+    A,
+    E | { [k in keyof Layers]: Layer.Error<Layers[k]> }[number],
+    | { [k in keyof Layers]: Layer.Context<Layers[k]> }[number]
+    | Exclude<R, { [k in keyof Layers]: Layer.Success<Layers[k]> }[number]>
+  >
 } = internal.provide
 
 /**

package/src/ManagedRuntime.ts

@@ -5,9 +5,32 @@ import type * as Effect from "./Effect.js"
 import type * as Exit from "./Exit.js"
 import type * as Fiber from "./Fiber.js"
 import * as internal from "./internal/managedRuntime.js"
+import * as circular from "./internal/managedRuntime/circular.js"
 import type * as Layer from "./Layer.js"
-import type { Pipeable } from "./Pipeable.js"
 import type * as Runtime from "./Runtime.js"
+import type * as Unify from "./Unify.js"
+
+/**
+ * @since 3.9.0
+ * @category symbol
+ */
+export const TypeId: unique symbol = circular.TypeId as TypeId
+
+/**
+ * @since 3.9.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * Checks if the provided argument is a `ManagedRuntime`.
+ *
+ * @param input - The value to be checked if it is a `ManagedRuntime`.
+
+ * @since 3.9.0
+ * @category guards
+ */
+export const isManagedRuntime: (input: unknown) => input is ManagedRuntime<unknown, unknown> = internal.isManagedRuntime
 
 /**
  * @since 3.4.0
@@ -29,7 +52,8 @@ export declare namespace ManagedRuntime {
  * @since 2.0.0
  * @category models
  */
-export interface ManagedRuntime<in R, out ER> extends Pipeable {
+export interface ManagedRuntime<in R, out ER> extends Effect.Effect<Runtime.Runtime<R>, ER> {
+  readonly [TypeId]: TypeId
   readonly memoMap: Layer.MemoMap
   readonly runtimeEffect: Effect.Effect<Runtime.Runtime<R>, ER>
   readonly runtime: () => Promise<Runtime.Runtime<R>>
@@ -103,6 +127,26 @@ export interface ManagedRuntime<in R, out ER> extends Pipeable {
    * Dispose of the resources associated with the runtime.
    */
   readonly disposeEffect: Effect.Effect<void, never, never>
+
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: ManagedRuntimeUnify<this>
+  readonly [Unify.ignoreSymbol]?: ManagedRuntimeUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface ManagedRuntimeUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
+  ManagedRuntime?: () => Extract<A[Unify.typeSymbol], ManagedRuntime<any, any>>
+}
+
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface ManagedRuntimeUnifyIgnore extends Effect.EffectUnifyIgnore {
+  Effect?: true
 }
 
 /**

package/src/Pool.ts

@@ -7,6 +7,7 @@ import * as internal from "./internal/pool.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as Scope from "./Scope.js"
 import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
 
 /**
  * @since 2.0.0
@@ -28,7 +29,7 @@ export type PoolTypeId = typeof PoolTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Pool<in out A, out E = never> extends Pool.Variance<A, E>, Pipeable {
+export interface Pool<in out A, out E = never> extends Pool.Variance<A, E>, Effect.Effect<A, E, Scope.Scope>, Pipeable {
   /**
    * Retrieves an item from the pool in a scoped effect. Note that if
    * acquisition fails, then the returned effect will fail for that same reason.
@@ -42,6 +43,30 @@ export interface Pool<in out A, out E = never> extends Pool.Variance<A, E>, Pipe
    * than eagerly.
    */
   invalidate(item: A): Effect.Effect<void>
+
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: PoolUnify<this>
+  readonly [Unify.ignoreSymbol]?: PoolUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface PoolUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
+  Pool?: () => Extract<A[Unify.typeSymbol], Pool<any, any>> extends Pool<infer A0, infer _E0> | infer _ ?
+    A0 extends any ? Extract<A[Unify.typeSymbol], Pool<A0, any>> extends Pool<A0, infer E1> ? Pool<A0, E1>
+      : never
+    : never :
+    never
+}
+
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface PoolUnifyIgnore extends Effect.EffectUnifyIgnore {
+  Effect?: true
 }
 
 /**

package/src/Predicate.ts

@@ -855,6 +855,22 @@ export const isPromiseLike = (
   input: unknown
 ): input is PromiseLike<unknown> => hasProperty(input, "then") && isFunction(input.then)
 
+/**
+ * Tests if a value is a `RegExp`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { Predicate } from "effect"
+ *
+ * assert.deepStrictEqual(Predicate.isRegExp(/a/), true)
+ * assert.deepStrictEqual(Predicate.isRegExp("a"), false)
+ *
+ * @category guards
+ * @since 3.9.0
+ */
+export const isRegExp = (input: unknown): input is RegExp => input instanceof RegExp
+
 /**
  * @since 2.0.0
  */

package/src/Queue.ts

@@ -64,7 +64,7 @@ export type BackingQueueTypeId = typeof BackingQueueTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Queue<in out A> extends Enqueue<A>, Dequeue<A>, Pipeable {
+export interface Queue<in out A> extends Enqueue<A>, Dequeue<A> {
   /** @internal */
   readonly queue: BackingQueue<A>
   /** @internal */
@@ -134,7 +134,7 @@ export interface Enqueue<in A> extends Queue.EnqueueVariance<A>, BaseQueue, Pipe
  * @since 2.0.0
  * @category models
  */
-export interface Dequeue<out A> extends Effect.Effect<A>, Queue.DequeueVariance<A>, BaseQueue, Pipeable {
+export interface Dequeue<out A> extends Effect.Effect<A>, Queue.DequeueVariance<A>, BaseQueue {
   /**
    * Takes the oldest value in the queue. If the queue is empty, this will return
    * a computation that resumes when an item has been added to the queue.

package/src/RegExp.ts

@@ -3,6 +3,23 @@
  *
  * @since 2.0.0
  */
+import * as predicate from "./Predicate.js"
+
+/**
+ * Tests if a value is a `RegExp`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { RegExp } from "effect"
+ *
+ * assert.deepStrictEqual(RegExp.isRegExp(/a/), true)
+ * assert.deepStrictEqual(RegExp.isRegExp("a"), false)
+ *
+ * @category guards
+ * @since 3.9.0
+ */
+export const isRegExp: (input: unknown) => input is RegExp = predicate.isRegExp
 
 /**
  * Escapes special characters in a regular expression pattern.

package/src/Resource.ts

@@ -8,6 +8,7 @@ import type * as Schedule from "./Schedule.js"
 import type * as Scope from "./Scope.js"
 import type * as ScopedRef from "./ScopedRef.js"
 import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
 
 /**
  * @since 2.0.0
@@ -28,11 +29,31 @@ export type ResourceTypeId = typeof ResourceTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Resource<in out A, in out E = never> extends Resource.Variance<A, E> {
+export interface Resource<in out A, in out E = never> extends Effect.Effect<A, E>, Resource.Variance<A, E> {
   /** @internal */
   readonly scopedRef: ScopedRef.ScopedRef<Exit.Exit<A, E>>
   /** @internal */
   readonly acquire: Effect.Effect<A, E, Scope.Scope>
+
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: ResourceUnify<this>
+  readonly [Unify.ignoreSymbol]?: ResourceUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface ResourceUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
+  Resource?: () => Extract<A[Unify.typeSymbol], Resource<any, any>>
+}
+
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface ResourceUnifyIgnore extends Effect.EffectUnifyIgnore {
+  Effect?: true
 }
 
 /**

package/src/ScopedRef.ts

@@ -8,6 +8,7 @@ import type { Pipeable } from "./Pipeable.js"
 import type * as Scope from "./Scope.js"
 import type * as Synchronized from "./SynchronizedRef.js"
 import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
 
 /**
  * @since 2.0.0
@@ -31,9 +32,29 @@ export type ScopedRefTypeId = typeof ScopedRefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface ScopedRef<in out A> extends ScopedRef.Variance<A>, Pipeable {
+export interface ScopedRef<in out A> extends Effect.Effect<A>, ScopedRef.Variance<A>, Pipeable {
   /** @internal */
   readonly ref: Synchronized.SynchronizedRef<readonly [Scope.Scope.Closeable, A]>
+
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: ScopedRefUnify<this>
+  readonly [Unify.ignoreSymbol]?: ScopedRefUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface ScopedRefUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
+  ScopedRef?: () => Extract<A[Unify.typeSymbol], ScopedRef<any>>
+}
+
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface ScopedRefUnifyIgnore extends Effect.EffectUnifyIgnore {
+  Effect?: true
 }
 
 /**

package/src/Tuple.ts

@@ -7,6 +7,7 @@ import * as Equivalence from "./Equivalence.js"
 import { dual } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import * as order from "./Order.js"
+import type { TupleOf } from "./Types.js"
 
 /**
  * @category type lambdas
@@ -61,6 +62,71 @@ export const getFirst = <L, R>(self: readonly [L, R]): L => self[0]
  */
 export const getSecond = <L, R>(self: readonly [L, R]): R => self[1]
 
+/**
+ * Transforms each element of tuple using the given function, treating tuple homomorphically
+ *
+ * @param self - A tuple.
+ * @param f - The function to transform elements of the tuple.
+ *
+ * @example
+ * import { pipe, Tuple } from "effect"
+ *
+ * const result = pipe(
+ *   ["a", 1, false] as const,
+ *   Tuple.map((el) => el.toString().toUpperCase())
+ * )
+ * assert.deepStrictEqual(result, ['A', '1', 'FALSE'])
+ *
+ * @category mapping
+ * @since 3.9.0
+ */
+export const map: {
+  /**
+   * Transforms each element of tuple using the given function, treating tuple homomorphically
+   *
+   * @param self - A tuple.
+   * @param f - The function to transform elements of the tuple.
+   *
+   * @example
+   * import { pipe, Tuple } from "effect"
+   *
+   * const result = pipe(
+   *   ["a", 1, false] as const,
+   *   Tuple.map((el) => el.toString().toUpperCase())
+   * )
+   * assert.deepStrictEqual(result, ['A', '1', 'FALSE'])
+   *
+   * @category mapping
+   * @since 3.9.0
+   */
+  <T extends ReadonlyArray<any> | [], B>(fn: (element: T[number]) => B): (self: T) => TupleOf<T["length"], B>
+  /**
+   * Transforms each element of tuple using the given function, treating tuple homomorphically
+   *
+   * @param self - A tuple.
+   * @param f - The function to transform elements of the tuple.
+   *
+   * @example
+   * import { pipe, Tuple } from "effect"
+   *
+   * const result = pipe(
+   *   ["a", 1, false] as const,
+   *   Tuple.map((el) => el.toString().toUpperCase())
+   * )
+   * assert.deepStrictEqual(result, ['A', '1', 'FALSE'])
+   *
+   * @category mapping
+   * @since 3.9.0
+   */
+  <B, T extends ReadonlyArray<any> | []>(self: T, fn: (element: T[number]) => B): TupleOf<T["length"], B>
+} = dual(
+  2,
+  <N extends number, A, B>(
+    self: TupleOf<N, A>,
+    fn: (element: A) => B
+  ): TupleOf<N, B> => self.map((element) => fn(element)) as TupleOf<N, B>
+)
+
 /**
  * Transforms both elements of a tuple using the given functions.
  *

package/src/Types.ts

@@ -254,6 +254,18 @@ export type NoInfer<A> = [A][A extends any ? 0 : never]
  */
 export type Invariant<A> = (_: A) => A
 
+/**
+ * @since 3.9.0
+ * @category models
+ */
+export declare namespace Invariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  export type Type<A> = A extends Invariant<infer U> ? U : never
+}
+
 /**
  * Covariant helper.
  *
@@ -262,6 +274,18 @@ export type Invariant<A> = (_: A) => A
  */
 export type Covariant<A> = (_: never) => A
 
+/**
+ * @since 3.9.0
+ * @category models
+ */
+export declare namespace Covariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  export type Type<A> = A extends Covariant<infer U> ? U : never
+}
+
 /**
  * Contravariant helper.
  *
@@ -270,6 +294,18 @@ export type Covariant<A> = (_: never) => A
  */
 export type Contravariant<A> = (_: A) => void
 
+/**
+ * @since 3.9.0
+ * @category models
+ */
+export declare namespace Contravariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  export type Type<A> = A extends Contravariant<infer U> ? U : never
+}
+
 /**
  * @since 2.0.0
  */
@@ -279,3 +315,8 @@ export type MatchRecord<S, onTrue, onFalse> = {} extends S ? onTrue : onFalse
  * @since 2.0.0
  */
 export type NotFunction<T> = T extends Function ? never : T
+
+/**
+ * @since 3.9.0
+ */
+export type NoExcessProperties<T, U> = T & { readonly [K in Exclude<keyof U, keyof T>]: never }

package/src/Unify.ts

@@ -34,26 +34,21 @@ export declare const ignoreSymbol: unique symbol
  */
 export type ignoreSymbol = typeof ignoreSymbol
 
-type MaybeReturn<F> = F extends () => any ? ReturnType<F> : F
+type MaybeReturn<F> = F extends () => infer R ? R : NonNullable<F>
 
-type Values<X extends [any, any]> = X extends any
-  ? { [k in keyof X[0]]-?: k extends X[1] ? never : MaybeReturn<X[0][k]> }[keyof X[0]]
+type Values<X extends [any, any]> = X extends [infer A, infer Ignore]
+  ? Exclude<keyof A, Ignore> extends infer k ? k extends keyof A ? MaybeReturn<A[k]> : never : never
   : never
 
-type Ignore<X> = X extends {
-  [ignoreSymbol]?: any
-} ? keyof NonNullable<X[ignoreSymbol]>
+type Ignore<X> = X extends { [ignoreSymbol]?: infer Obj } ? keyof NonNullable<Obj>
   : never
 
 type ExtractTypes<
-  X extends {
-    [typeSymbol]?: any
-    [unifySymbol]?: any
-  }
-> = X extends any ? [
-    NonNullable<X[unifySymbol]>,
-    Ignore<X>
-  ]
+  X
+> = X extends {
+  [typeSymbol]?: infer _Type
+  [unifySymbol]?: infer _Unify
+} ? [NonNullable<_Unify>, Ignore<X>]
   : never
 
 type FilterIn<A> = A extends any ? typeSymbol extends keyof A ? A : never : never

package/src/internal/context.ts

@@ -25,7 +25,6 @@ export const STMTypeId: STM.STMTypeId = Symbol.for(
 /** @internal */
 export const TagProto: any = {
   ...EffectPrototype,
-  _tag: "Tag",
   _op: "Tag",
   [STMTypeId]: effectVariance,
   [TagTypeId]: {

package/src/internal/core-effect.ts

@@ -1055,17 +1055,17 @@ const loopDiscard = <S, X, E, R>(
 
 /* @internal */
 export const mapAccum: {
-  <S, A, B, E, R>(
+  <S, A, B, E, R, I extends Iterable<A> = Iterable<A>>(
     zero: S,
     f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
-  ): (elements: Iterable<A>) => Effect.Effect<[S, Array<B>], E, R>
-  <A, S, B, E, R>(
-    elements: Iterable<A>,
+  ): (elements: I) => Effect.Effect<[S, Arr.ReadonlyArray.With<I, B>], E, R>
+  <A, S, B, E, R, I extends Iterable<A> = Iterable<A>>(
+    elements: I,
     zero: S,
     f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
-  ): Effect.Effect<[S, Array<B>], E, R>
-} = dual(3, <A, S, B, E, R>(
-  elements: Iterable<A>,
+  ): Effect.Effect<[S, Arr.ReadonlyArray.With<I, B>], E, R>
+} = dual(3, <A, S, B, E, R, I extends Iterable<A> = Iterable<A>>(
+  elements: I,
   zero: S,
   f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
 ): Effect.Effect<[S, Array<B>], E, R> =>

package/src/internal/effect/circular.ts

@@ -112,10 +112,16 @@ export const unsafeMakeSemaphore = (permits: number): Semaphore => new Semaphore
 /** @internal */
 export const makeSemaphore = (permits: number) => core.sync(() => unsafeMakeSemaphore(permits))
 
-class Latch implements Effect.Latch {
+class Latch extends Effectable.Class<void> implements Effect.Latch {
   waiters: Array<(_: Effect.Effect<void>) => void> = []
   scheduled = false
-  constructor(private isOpen: boolean) {}
+  constructor(private isOpen: boolean) {
+    super()
+  }
+
+  commit() {
+    return this.await
+  }
 
   private unsafeSchedule(fiber: Fiber.RuntimeFiber<void>) {
     if (this.scheduled || this.waiters.length === 0) {