effect 4.0.0-beta.4 → 4.0.0-beta.6

package/src/Equal.ts

@@ -269,7 +269,7 @@ function compareRecords(
 
 /** @internal */
 export function makeCompareMap<K, V>(keyEquivalence: Equivalence<K>, valueEquivalence: Equivalence<V>) {
-  return function compareMaps(self: ReadonlyMap<K, V>, that: ReadonlyMap<K, V>): boolean {
+  return function compareMaps(self: Iterable<[K, V]>, that: Iterable<[K, V]>): boolean {
     for (const [selfKey, selfValue] of self) {
       let found = false
       for (const [thatKey, thatValue] of that) {
@@ -291,7 +291,7 @@ const compareMaps = makeCompareMap(compareBoth, compareBoth)
 
 /** @internal */
 export function makeCompareSet<A>(equivalence: Equivalence<A>) {
-  return function compareSets(self: ReadonlySet<A>, that: ReadonlySet<A>): boolean {
+  return function compareSets(self: Iterable<A>, that: Iterable<A>): boolean {
     for (const selfValue of self) {
       let found = false
       for (const thatValue of that) {

package/src/FileSystem.ts

@@ -733,8 +733,7 @@ export const make = (
         Effect.as(true),
         Effect.catchTag(
           "PlatformError",
-          (e) =>
-            e.reason._tag === "SystemError" && e.reason.kind === "NotFound" ? Effect.succeed(false) : Effect.fail(e)
+          (e) => e.reason._tag === "NotFound" ? Effect.succeed(false) : Effect.fail(e)
         )
       ),
     readFileString: (path, encoding) =>
@@ -757,16 +756,16 @@ export const make = (
       const bytesToRead = options?.bytesToRead !== undefined ? Size(options.bytesToRead) : undefined
       let totalBytesRead = BigInt(0)
       const chunkSize = Size(options?.chunkSize ?? 64 * 1024)
+      const readChunk = file.readAlloc(chunkSize)
       return Stream.fromPull(Effect.succeed(
         Effect.flatMap(
           Effect.suspend((): Pull.Pull<Uint8Array | undefined, PlatformError> => {
             if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
               return Cause.done()
             }
-            const toRead = bytesToRead !== undefined && (bytesToRead - totalBytesRead) < chunkSize
-              ? bytesToRead - totalBytesRead
-              : chunkSize
-            return file.readAlloc(toRead)
+            return bytesToRead !== undefined && (bytesToRead - totalBytesRead) < chunkSize
+              ? file.readAlloc(bytesToRead - totalBytesRead)
+              : readChunk
           }),
           (buf) => {
             if (!buf) return Cause.done()
@@ -802,7 +801,7 @@ const notFound = (method: string, path: string) =>
   systemError({
     module: "FileSystem",
     method,
-    kind: "NotFound",
+    _tag: "NotFound",
     description: "No such file or directory",
     pathOrDescriptor: path
   })
@@ -829,9 +828,9 @@ const notFound = (method: string, path: string) =>
  *     }
  *     return Effect.fail(
  *       PlatformError.systemError({
+ *         _tag: "NotFound",
  *         module: "FileSystem",
  *         method: "readFileString",
- *         kind: "NotFound",
  *         description: "File not found",
  *         pathOrDescriptor: path
  *       })

package/src/Filter.ts

@@ -7,7 +7,7 @@ import { dual } from "./Function.ts"
 import * as Option from "./Option.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Result from "./Result.ts"
-import type { EqualsWith, ExcludeTag, ExtractTag, Tags } from "./Types.ts"
+import type { EqualsWith, ExcludeTag, ExtractReason, ExtractTag, ReasonTags, Tags } from "./Types.ts"
 
 /**
  * Represents a filter function that can transform inputs to outputs or filter them out.
@@ -456,6 +456,53 @@ const taggedImpl =
   <Input>(input: Input): Result.Result<ExtractTag<Input, Tag>, ExcludeTag<Input, Tag>> =>
     Predicate.isTagged(input, tag) ? Result.succeed(input as any) : Result.fail(input as ExcludeTag<Input, Tag>)
 
+/**
+ * Creates a filter that extracts a reason from a tagged error.
+ *
+ * @since 4.0.0
+ * @category Constructors
+ */
+export const reason: {
+  /**
+   * Creates a filter that extracts a reason from a tagged error.
+   *
+   * @since 4.0.0
+   * @category Constructors
+   */
+  <Input>(): <const Tag extends Tags<Input>, const ReasonTag extends ReasonTags<ExtractTag<Input, Tag>>>(
+    tag: Tag,
+    reasonTag: ReasonTag
+  ) => Filter<Input, ExtractReason<ExtractTag<Input, Tag>, ReasonTag>, Input>
+  /**
+   * Creates a filter that extracts a reason from a tagged error.
+   *
+   * @since 4.0.0
+   * @category Constructors
+   */
+  <Input, const Tag extends Tags<Input>, const ReasonTag extends ReasonTags<ExtractTag<Input, Tag>>>(tag: Tag, reasonTag: ReasonTag): Filter<Input, ExtractReason<ExtractTag<Input, Tag>, ReasonTag>, Input>
+  /**
+   * Creates a filter that extracts a reason from a tagged error.
+   *
+   * @since 4.0.0
+   * @category Constructors
+   */
+  <const Tag extends string, const ReasonTag extends string>(tag: Tag, reasonTag: ReasonTag): <Input>(input: Input) => Result.Result<ExtractReason<ExtractTag<Input, Tag>, ReasonTag>, Input>
+} = function() {
+  return arguments.length === 0 ? reasonImpl : reasonImpl(arguments[0] as any, arguments[1] as any)
+} as any
+
+const reasonImpl =
+  <const Tag extends string, const ReasonTag extends string>(tag: Tag, reasonTag: ReasonTag) =>
+  <Input>(input: Input): Result.Result<ExtractTag<Input, Tag>, ExcludeTag<Input, Tag>> => {
+    if (
+      Predicate.isTagged(input, tag) && Predicate.hasProperty(input, "reason") &&
+      Predicate.isTagged(input.reason, reasonTag)
+    ) {
+      return Result.succeed(input.reason as any)
+    }
+    return Result.fail(input as any)
+  }
+
 /**
  * Creates a filter that only passes values equal to the specified value using structural equality.
  *

package/src/Formatter.ts

@@ -101,7 +101,7 @@ export function format(input: unknown, options?: {
 
     if (typeof v === "bigint") return String(v) + "n"
 
-    if (Predicate.isObject(v)) {
+    if (typeof v === "object" || typeof v === "function") {
       if (seen.has(v)) return CIRCULAR
       seen.add(v)
 

package/src/Graph.ts

@@ -1200,11 +1200,14 @@ export const reverse = <N, E, T extends Kind = "directed">(
 ): void => {
   // Reverse all edges by swapping source and target
   for (const [index, edgeData] of mutable.edges) {
-    mutable.edges.set(index, {
-      source: edgeData.target,
-      target: edgeData.source,
-      data: edgeData.data
-    })
+    mutable.edges.set(
+      index,
+      new Edge({
+        source: edgeData.target,
+        target: edgeData.source,
+        data: edgeData.data
+      })
+    )
   }
 
   // Clear and rebuild adjacency lists with reversed directions

package/src/Latch.ts

@@ -0,0 +1,112 @@
+/**
+ * @since 3.8.0
+ */
+import type * as Effect from "./Effect.ts"
+import * as internal from "./internal/effect.ts"
+
+/**
+ * @category models
+ * @since 3.8.0
+ * @example
+ * ```ts
+ * import { Effect, Latch } from "effect"
+ *
+ * // Create and use a latch for coordination between fibers
+ * const program = Effect.gen(function*() {
+ *   const latch = yield* Latch.make()
+ *
+ *   // Wait for the latch to be opened
+ *   yield* latch.await
+ *
+ *   return "Latch was opened!"
+ * })
+ * ```
+ */
+export interface Latch {
+  /** open the latch, releasing all fibers waiting on it */
+  readonly open: Effect.Effect<boolean>
+  /** open the latch, releasing all fibers waiting on it */
+  readonly openUnsafe: () => boolean
+  /** release all fibers waiting on the latch, without opening it */
+  readonly release: Effect.Effect<boolean>
+  /** wait for the latch to be opened */
+  readonly await: Effect.Effect<void>
+  /** close the latch */
+  readonly close: Effect.Effect<boolean>
+  /** close the latch */
+  readonly closeUnsafe: () => boolean
+  /** only run the given effect when the latch is open */
+  readonly whenOpen: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+}
+
+/**
+ * Creates a new Latch unsafely.
+ *
+ * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `Effect.makeLatchUnsafe`
+ *
+ * @example
+ * ```ts
+ * import { Effect, Latch } from "effect"
+ *
+ * const latch = Latch.makeUnsafe(false)
+ *
+ * const waiter = Effect.gen(function*() {
+ *   yield* Effect.log("Waiting for latch to open...")
+ *   yield* latch.await
+ *   yield* Effect.log("Latch opened! Continuing...")
+ * })
+ *
+ * const opener = Effect.gen(function*() {
+ *   yield* Effect.sleep("2 seconds")
+ *   yield* Effect.log("Opening latch...")
+ *   yield* latch.open
+ * })
+ *
+ * const program = Effect.all([waiter, opener])
+ * ```
+ *
+ * @category constructors
+ * @since 3.8.0
+ */
+export const makeUnsafe: (open?: boolean | undefined) => Latch = internal.makeLatchUnsafe
+
+/**
+ * Creates a new Latch.
+ *
+ * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `Effect.makeLatch`
+ *
+ * @example
+ * ```ts
+ * import { Effect, Latch } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const latch = yield* Latch.make(false)
+ *
+ *   const waiter = Effect.gen(function*() {
+ *     yield* Effect.log("Waiting for latch to open...")
+ *     yield* latch.await
+ *     yield* Effect.log("Latch opened! Continuing...")
+ *   })
+ *
+ *   const opener = Effect.gen(function*() {
+ *     yield* Effect.sleep("2 seconds")
+ *     yield* Effect.log("Opening latch...")
+ *     yield* latch.open
+ *   })
+ *
+ *   yield* Effect.all([waiter, opener])
+ * })
+ * ```
+ *
+ * @category constructors
+ * @since 3.8.0
+ */
+export const make: (open?: boolean | undefined) => Effect.Effect<Latch> = internal.makeLatch

package/src/Pipeable.ts

@@ -554,8 +554,39 @@ export const pipeArguments = <A>(self: A, args: IArguments): unknown => {
 /**
  * @since 4.0.0
  */
-export const Class: new() => Pipeable = class {
+export const Prototype: Pipeable = {
   pipe() {
     return pipeArguments(this, arguments)
   }
 }
+
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const Class: new() => Pipeable = (function() {
+  function PipeableBase() {}
+  PipeableBase.prototype = Prototype
+  return PipeableBase as any
+})()
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface PipeableConstructor {
+  new(...args: ReadonlyArray<any>): Pipeable
+}
+
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const Mixin = <TBase extends new(...args: ReadonlyArray<any>) => any>(
+  klass: TBase
+): TBase & PipeableConstructor =>
+  (class extends klass {
+    pipe() {
+      return pipeArguments(this, arguments)
+    }
+  })

package/src/PlatformError.ts

@@ -27,7 +27,7 @@ export class BadArgument extends Data.TaggedError("BadArgument")<{
  * @since 4.0.0
  * @category Model
  */
-export type SystemErrorKind =
+export type SystemErrorTag =
   | "AlreadyExists"
   | "BadResource"
   | "Busy"
@@ -44,8 +44,8 @@ export type SystemErrorKind =
  * @since 4.0.0
  * @category models
  */
-export class SystemError extends Data.TaggedError("SystemError")<{
-  kind: SystemErrorKind
+export class SystemError extends Data.Error<{
+  _tag: SystemErrorTag
   module: string
   method: string
   description?: string | undefined
@@ -57,7 +57,7 @@ export class SystemError extends Data.TaggedError("SystemError")<{
    * @since 4.0.0
    */
   override get message(): string {
-    return `${this.kind}: ${this.module}.${this.method}${
+    return `${this._tag}: ${this.module}.${this.method}${
       this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""
     }${this.description ? `: ${this.description}` : ""}`
   }
@@ -93,7 +93,7 @@ export class PlatformError extends Data.TaggedError("PlatformError")<{
  * @category constructors
  */
 export const systemError = (options: {
-  readonly kind: SystemErrorKind
+  readonly _tag: SystemErrorTag
   readonly module: string
   readonly method: string
   readonly description?: string | undefined

package/src/Pool.ts

@@ -9,11 +9,13 @@ import type * as Exit from "./Exit.ts"
 import * as Fiber from "./Fiber.ts"
 import { dual, identity } from "./Function.ts"
 import * as Iterable from "./Iterable.ts"
+import * as Latch from "./Latch.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Queue from "./Queue.ts"
 import { UnhandledLogLevel } from "./References.ts"
 import * as Scope from "./Scope.ts"
+import * as Semaphore from "./Semaphore.ts"
 import * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = "~effect/Pool"
@@ -52,11 +54,11 @@ export interface Config<A, E> {
 export interface State<A, E> {
   readonly scope: Scope.Scope
   isShuttingDown: boolean
-  readonly semaphore: Effect.Semaphore
-  readonly resizeSemaphore: Effect.Semaphore
+  readonly semaphore: Semaphore.Semaphore
+  readonly resizeSemaphore: Semaphore.Semaphore
   readonly items: Set<PoolItem<A, E>>
   readonly available: Set<PoolItem<A, E>>
-  readonly availableLatch: Effect.Latch
+  readonly availableLatch: Latch.Latch
   readonly invalidated: Set<PoolItem<A, E>>
   waiters: number
 }
@@ -212,11 +214,11 @@ export const makeWithStrategy = <A, E, R>(options: {
     const state: State<A, E> = {
       scope,
       isShuttingDown: false,
-      semaphore: Effect.makeSemaphoreUnsafe(concurrency * options.max),
-      resizeSemaphore: Effect.makeSemaphoreUnsafe(1),
+      semaphore: Semaphore.makeUnsafe(concurrency * options.max),
+      resizeSemaphore: Semaphore.makeUnsafe(1),
       items: new Set(),
       available: new Set(),
-      availableLatch: Effect.makeLatchUnsafe(false),
+      availableLatch: Latch.makeUnsafe(false),
       invalidated: new Set(),
       waiters: 0
     }
@@ -244,7 +246,7 @@ const shutdown = Effect.fnUntraced(function*<A, E>(self: Pool<A, E>) {
   if (self.state.isShuttingDown) return
   self.state.isShuttingDown = true
   const size = self.state.items.size
-  const semaphore = Effect.makeSemaphoreUnsafe(size)
+  const semaphore = Semaphore.makeUnsafe(size)
   for (const item of self.state.items) {
     if (item.refCount > 0) {
       item.finalizer = Effect.tap(item.finalizer, semaphore.release(1))

package/src/PubSub.ts

@@ -34,6 +34,7 @@ import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import type { LazyArg } from "./Function.ts"
 import { dual, identity } from "./Function.ts"
+import * as Latch from "./Latch.ts"
 import * as MutableList from "./MutableList.ts"
 import * as MutableRef from "./MutableRef.ts"
 import { nextPow2 } from "./Number.ts"
@@ -81,7 +82,7 @@ export interface PubSub<in out A> extends Pipeable {
   readonly pubsub: PubSub.Atomic<A>
   readonly subscribers: PubSub.Subscribers<A>
   readonly scope: Scope.Closeable
-  readonly shutdownHook: Effect.Latch
+  readonly shutdownHook: Latch.Latch
   readonly shutdownFlag: MutableRef.MutableRef<boolean>
   readonly strategy: PubSub.Strategy<A>
 }
@@ -242,7 +243,7 @@ export interface Subscription<out A> extends Pipeable {
   readonly subscribers: PubSub.Subscribers<any>
   readonly subscription: PubSub.BackingSubscription<A>
   readonly pollers: MutableList.MutableList<Deferred.Deferred<any>>
-  readonly shutdownHook: Effect.Latch
+  readonly shutdownHook: Latch.Latch
   readonly shutdownFlag: MutableRef.MutableRef<boolean>
   readonly strategy: PubSub.Strategy<any>
   readonly replayWindow: PubSub.ReplayWindow<A>
@@ -282,7 +283,7 @@ export const make = <A>(
       options.atomicPubSub(),
       new Map(),
       Scope.makeUnsafe(),
-      Effect.makeLatchUnsafe(false),
+      Latch.makeUnsafe(false),
       MutableRef.make(false),
       options.strategy()
     )
@@ -1701,7 +1702,7 @@ const makeSubscriptionUnsafe = <A>(
     subscribers,
     pubsub.subscribe(),
     MutableList.make<Deferred.Deferred<A>>(),
-    Effect.makeLatchUnsafe(false),
+    Latch.makeUnsafe(false),
     MutableRef.make(false),
     strategy,
     pubsub.replayWindow()
@@ -2446,7 +2447,7 @@ class SubscriptionImpl<in out A> implements Subscription<A> {
   readonly subscribers: PubSub.Subscribers<A>
   readonly subscription: PubSub.BackingSubscription<A>
   readonly pollers: MutableList.MutableList<Deferred.Deferred<A>>
-  readonly shutdownHook: Effect.Latch
+  readonly shutdownHook: Latch.Latch
   readonly shutdownFlag: MutableRef.MutableRef<boolean>
   readonly strategy: PubSub.Strategy<A>
   readonly replayWindow: PubSub.ReplayWindow<A>
@@ -2456,7 +2457,7 @@ class SubscriptionImpl<in out A> implements Subscription<A> {
     subscribers: PubSub.Subscribers<A>,
     subscription: PubSub.BackingSubscription<A>,
     pollers: MutableList.MutableList<Deferred.Deferred<A>>,
-    shutdownHook: Effect.Latch,
+    shutdownHook: Latch.Latch,
     shutdownFlag: MutableRef.MutableRef<boolean>,
     strategy: PubSub.Strategy<A>,
     replayWindow: PubSub.ReplayWindow<A>
@@ -2484,7 +2485,7 @@ class PubSubImpl<in out A> implements PubSub<A> {
   readonly pubsub: PubSub.Atomic<A>
   readonly subscribers: PubSub.Subscribers<A>
   readonly scope: Scope.Closeable
-  readonly shutdownHook: Effect.Latch
+  readonly shutdownHook: Latch.Latch
   readonly shutdownFlag: MutableRef.MutableRef<boolean>
   readonly strategy: PubSub.Strategy<A>
 
@@ -2492,7 +2493,7 @@ class PubSubImpl<in out A> implements PubSub<A> {
     pubsub: PubSub.Atomic<A>,
     subscribers: PubSub.Subscribers<A>,
     scope: Scope.Closeable,
-    shutdownHook: Effect.Latch,
+    shutdownHook: Latch.Latch,
     shutdownFlag: MutableRef.MutableRef<boolean>,
     strategy: PubSub.Strategy<A>
   ) {
@@ -2513,7 +2514,7 @@ const makePubSubUnsafe = <A>(
   pubsub: PubSub.Atomic<A>,
   subscribers: PubSub.Subscribers<A>,
   scope: Scope.Closeable,
-  shutdownHook: Effect.Latch,
+  shutdownHook: Latch.Latch,
   shutdownFlag: MutableRef.MutableRef<boolean>,
   strategy: PubSub.Strategy<A>
 ): PubSub<A> => new PubSubImpl(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy)

package/src/Request.ts

@@ -88,7 +88,7 @@ export interface Variance<out A, out E, out R> {
  * @category models
  */
 export interface Constructor<R extends Request<any, any, any>, T extends keyof R = never> {
-  (args: Omit<R, T | keyof (Variance<any, any, any>)>): R
+  (args: Types.VoidIfEmpty<Types.Simplify<Omit<R, T | keyof (Variance<any, any, any>)>>>): R
 }
 
 /**
@@ -285,7 +285,8 @@ export const tagged = <R extends Request<any, any, any> & { _tag: string }>(
   tag: R["_tag"]
 ): Constructor<R, "_tag"> =>
 (args) => {
-  const request = Object.assign(Object.create(RequestPrototype), args)
+  const request = Object.create(RequestPrototype)
+  if (args) Object.assign(request, args)
   request._tag = tag
   return request
 }

package/src/RequestResolver.ts

@@ -841,26 +841,6 @@ export const around: {
 /**
  * A request resolver that never executes requests.
  *
- * @example
- * ```ts
- * import { Effect, Request, RequestResolver } from "effect"
- *
- * // A resolver that will never complete
- * const neverResolver = RequestResolver.never
- *
- * // For testing timeout behavior with any request type
- * interface TestRequest extends Request.Request<string> {
- *   readonly _tag: "TestRequest"
- * }
- * const TestRequest = Request.tagged<TestRequest>("TestRequest")
- *
- * // This will never resolve
- * const neverEffect = Effect.request(TestRequest({}), Effect.succeed(neverResolver) as any)
- *
- * // Useful for testing timeout behavior
- * const timeoutTest = Effect.timeout(neverEffect, "1 second")
- * ```
- *
  * @since 2.0.0
  * @category constructors
  */