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

package/src/Data.ts

@@ -13,6 +13,7 @@
  */
 import type * as Cause from "./Cause.ts"
 import * as core from "./internal/core.ts"
+import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import type * as Types from "./Types.ts"
 import type { Unify } from "./Unify.ts"
@@ -43,9 +44,12 @@ import type { Unify } from "./Unify.ts"
 export const Class: new<A extends Record<string, any> = {}>(
   args: Types.Equals<A, {}> extends true ? void
     : { readonly [P in keyof A]: A[P] }
-) => Readonly<A> = function(this: any, props: any) {
-  if (props) {
-    Object.assign(this, props)
+) => Readonly<A> & Pipeable.Pipeable = class extends Pipeable.Class {
+  constructor(props: any) {
+    super()
+    if (props) {
+      Object.assign(this, props)
+    }
   }
 } as any
 
@@ -79,12 +83,9 @@ export const TaggedClass = <Tag extends string>(
 ): new<A extends Record<string, any> = {}>(
   args: Types.Equals<A, {}> extends true ? void
     : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }
-) => Readonly<A> & { readonly _tag: Tag } =>
-  function(this: any, props: any) {
-    this._tag = tag
-    if (props) {
-      Object.assign(this, props)
-    }
+) => Readonly<A> & { readonly _tag: Tag } & Pipeable.Pipeable =>
+  class extends Class {
+    readonly _tag = tag
   } as any
 
 /**

package/src/Effect.ts

@@ -12777,252 +12777,6 @@ export const interruptibleMask: <A, E, R>(
   ) => Effect<A, E, R>
 ) => Effect<A, E, R> = internal.interruptibleMask
 
-// -----------------------------------------------------------------------------
-// Semaphore
-// -----------------------------------------------------------------------------
-
-/**
- * @category Semaphore
- * @since 2.0.0
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * // Create and use a semaphore for controlling concurrent access
- * const program = Effect.gen(function*() {
- *   const semaphore = yield* Effect.makeSemaphore(2)
- *
- *   return yield* semaphore.withPermits(1)(
- *     Effect.succeed("Resource accessed")
- *   )
- * })
- * ```
- */
-export interface Semaphore {
-  /**
-   * Adjusts the number of permits available in the semaphore.
-   */
-  resize(permits: number): Effect<void>
-
-  /**
-   * Runs an effect with the given number of permits and releases the permits
-   * when the effect completes.
-   *
-   * **Details**
-   *
-   * This function acquires the specified number of permits before executing
-   * the provided effect. Once the effect finishes, the permits are released.
-   * If insufficient permits are available, the function will wait until they
-   * are released by other tasks.
-   */
-  withPermits(permits: number): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
-
-  /**
-   * Runs an effect with the given number of permits and releases the permits
-   * when the effect completes.
-   *
-   * **Details**
-   *
-   * This function acquires the specified number of permits before executing
-   * the provided effect. Once the effect finishes, the permits are released.
-   * If insufficient permits are available, the function will wait until they
-   * are released by other tasks.
-   */
-  withPermit<A, E, R>(self: Effect<A, E, R>): Effect<A, E, R>
-
-  /**
-   * Runs an effect only if the specified number of permits are immediately
-   * available.
-   *
-   * **Details**
-   *
-   * This function attempts to acquire the specified number of permits. If they
-   * are available, it runs the effect and releases the permits after the effect
-   * completes. If permits are not available, the effect does not execute, and
-   * the result is `Option.none`.
-   */
-  withPermitsIfAvailable(permits: number): <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A>, E, R>
-
-  /**
-   * Acquires the specified number of permits and returns the resulting
-   * available permits, suspending the task if they are not yet available.
-   * Concurrent pending `take` calls are processed in a first-in, first-out manner.
-   */
-  take(permits: number): Effect<number>
-
-  /**
-   * Releases the specified number of permits and returns the resulting
-   * available permits.
-   */
-  release(permits: number): Effect<number>
-
-  /**
-   * Releases all permits held by this semaphore and returns the resulting available permits.
-   */
-  releaseAll: Effect<number>
-}
-
-/**
- * Unsafely creates a new Semaphore.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * const semaphore = Effect.makeSemaphoreUnsafe(3)
- *
- * const task = (id: number) =>
- *   semaphore.withPermits(1)(
- *     Effect.gen(function*() {
- *       yield* Effect.log(`Task ${id} started`)
- *       yield* Effect.sleep("1 second")
- *       yield* Effect.log(`Task ${id} completed`)
- *     })
- *   )
- *
- * // Only 3 tasks can run concurrently
- * const program = Effect.all([
- *   task(1),
- *   task(2),
- *   task(3),
- *   task(4),
- *   task(5)
- * ], { concurrency: "unbounded" })
- * ```
- *
- * @since 2.0.0
- * @category Semaphore
- */
-export const makeSemaphoreUnsafe: (permits: number) => Semaphore = internal.makeSemaphoreUnsafe
-
-/**
- * Creates a new Semaphore.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * const program = Effect.gen(function*() {
- *   const semaphore = yield* Effect.makeSemaphore(2)
- *
- *   const task = (id: number) =>
- *     semaphore.withPermits(1)(
- *       Effect.gen(function*() {
- *         yield* Effect.log(`Task ${id} acquired permit`)
- *         yield* Effect.sleep("1 second")
- *         yield* Effect.log(`Task ${id} releasing permit`)
- *       })
- *     )
- *
- *   // Run 4 tasks, but only 2 can run concurrently
- *   yield* Effect.all([task(1), task(2), task(3), task(4)])
- * })
- * ```
- *
- * @since 2.0.0
- * @category Semaphore
- */
-export const makeSemaphore: (permits: number) => Effect<Semaphore> = internal.makeSemaphore
-
-// -----------------------------------------------------------------------------
-// Latch
-// -----------------------------------------------------------------------------
-
-/**
- * @category Latch
- * @since 3.8.0
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * // Create and use a latch for coordination between fibers
- * const program = Effect.gen(function*() {
- *   const latch = yield* Effect.makeLatch()
- *
- *   // 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<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<boolean>
-  /** wait for the latch to be opened */
-  readonly await: Effect<void>
-  /** close the latch */
-  readonly close: 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<A, E, R>) => Effect<A, E, R>
-}
-
-/**
- * Creates a new Latch.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * const latch = Effect.makeLatchUnsafe(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 Latch
- * @since 3.8.0
- */
-export const makeLatchUnsafe: (open?: boolean | undefined) => Latch = internal.makeLatchUnsafe
-
-/**
- * Creates a new Latch.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * const program = Effect.gen(function*() {
- *   const latch = yield* Effect.makeLatch(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 Latch
- * @since 3.8.0
- */
-export const makeLatch: (open?: boolean | undefined) => Effect<Latch> = internal.makeLatch
-
 // -----------------------------------------------------------------------------
 // Repetition & Recursion
 // -----------------------------------------------------------------------------