effect 4.0.0-beta.2 → 4.0.0-beta.21

package/src/Option.ts

@@ -31,7 +31,7 @@
  * **Gotchas**
  *
  * - `Option.some(null)` is a valid `Some`; use {@link fromNullishOr} to treat `null`/`undefined` as `None`
- * - {@link filterMap} is an alias for {@link flatMap}
+ * - {@link filterMap} uses a `Filter` callback that returns `Result`
  * - {@link getOrThrow} throws a generic `Error`; prefer {@link getOrThrowWith} for custom errors
  * - `None` is a singleton; compare with {@link isNone}, not `===`
  * - When yielded in `Effect.gen`, a `None` becomes a `NoSuchElementError` defect
@@ -77,6 +77,7 @@ import * as Combiner from "./Combiner.ts"
 import type { EffectIterator, Yieldable } from "./Effect.ts"
 import * as Equal from "./Equal.ts"
 import * as Equivalence from "./Equivalence.ts"
+import type * as Filter from "./Filter.ts"
 import type { LazyArg } from "./Function.ts"
 import { constNull, constUndefined, dual, identity } from "./Function.ts"
 import type { TypeLambda } from "./HKT.ts"
@@ -3441,79 +3442,88 @@ export const partitionMap: {
   return result.isFailure(e) ? [some(e.failure), none()] : [none(), some(e.success)]
 })
 
-// TODO(4.0): remove?
 /**
- * Alias of {@link flatMap}. Applies a function returning `Option` to the value
- * inside a `Some`, flattening the result.
+ * Transforms and filters an `Option` using a `Filter` callback.
+ *
+ * The callback returns a `Result`: `Result.succeed` keeps and transforms the
+ * value, while `Result.fail` discards it.
  *
  * **Example** (Filtering and transforming)
  *
  * ```ts
  * import { Option } from "effect"
+ * import * as Result from "effect/Result"
  *
  * console.log(Option.filterMap(
  *   Option.some(2),
- *   (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none())
+ *   (n) => (n % 2 === 0 ? Result.succeed(`Even: ${n}`) : Result.failVoid)
  * ))
  * // Output: { _id: 'Option', _tag: 'Some', value: 'Even: 2' }
  * ```
  *
- * @see {@link flatMap} (canonical)
  * @see {@link filter} for predicate-based filtering
  *
  * @category Filtering
  * @since 2.0.0
  */
 export const filterMap: {
-  // TODO(4.0): remove?
   /**
-   * Alias of {@link flatMap}. Applies a function returning `Option` to the value
-   * inside a `Some`, flattening the result.
+   * Transforms and filters an `Option` using a `Filter` callback.
+   *
+   * The callback returns a `Result`: `Result.succeed` keeps and transforms the
+   * value, while `Result.fail` discards it.
    *
    * **Example** (Filtering and transforming)
    *
    * ```ts
    * import { Option } from "effect"
+   * import * as Result from "effect/Result"
    *
    * console.log(Option.filterMap(
    *   Option.some(2),
-   *   (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none())
+   *   (n) => (n % 2 === 0 ? Result.succeed(`Even: ${n}`) : Result.failVoid)
    * ))
    * // Output: { _id: 'Option', _tag: 'Some', value: 'Even: 2' }
    * ```
    *
-   * @see {@link flatMap} (canonical)
    * @see {@link filter} for predicate-based filtering
    *
    * @category Filtering
    * @since 2.0.0
    */
-  <A, B>(f: (a: A) => Option<B>): (self: Option<A>) => Option<B>
-  // TODO(4.0): remove?
+  <A, B, X>(f: Filter.Filter<A, B, X>): (self: Option<A>) => Option<B>
   /**
-   * Alias of {@link flatMap}. Applies a function returning `Option` to the value
-   * inside a `Some`, flattening the result.
+   * Transforms and filters an `Option` using a `Filter` callback.
+   *
+   * The callback returns a `Result`: `Result.succeed` keeps and transforms the
+   * value, while `Result.fail` discards it.
    *
    * **Example** (Filtering and transforming)
    *
    * ```ts
    * import { Option } from "effect"
+   * import * as Result from "effect/Result"
    *
    * console.log(Option.filterMap(
    *   Option.some(2),
-   *   (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none())
+   *   (n) => (n % 2 === 0 ? Result.succeed(`Even: ${n}`) : Result.failVoid)
    * ))
    * // Output: { _id: 'Option', _tag: 'Some', value: 'Even: 2' }
    * ```
    *
-   * @see {@link flatMap} (canonical)
    * @see {@link filter} for predicate-based filtering
    *
    * @category Filtering
    * @since 2.0.0
    */
-  <A, B>(self: Option<A>, f: (a: A) => Option<B>): Option<B>
-} = flatMap
+  <A, B, X>(self: Option<A>, f: Filter.Filter<A, B, X>): Option<B>
+} = dual(2, <A, B, X>(self: Option<A>, f: Filter.Filter<A, B, X>): Option<B> => {
+  if (isNone(self)) {
+    return none()
+  }
+  const next = f(self.value)
+  return result.isSuccess(next) ? some(next.success) : none()
+})
 
 /**
  * Filters an `Option` using a predicate. Returns `None` if the predicate is
@@ -3723,7 +3733,7 @@ export const filter: {
 } = dual(
   2,
   <A>(self: Option<A>, predicate: Predicate<A>): Option<A> =>
-    filterMap(self, (b) => (predicate(b) ? option.some(b) : option.none))
+    isNone(self) ? none() : predicate(self.value) ? some(self.value) : none()
 )
 
 /**

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
 }
@@ -170,7 +172,7 @@ export const makeWithTTL = <A, E, R>(options: {
   readonly max: number
   readonly concurrency?: number | undefined
   readonly targetUtilization?: number | undefined
-  readonly timeToLive: Duration.DurationInput
+  readonly timeToLive: Duration.Input
   readonly timeToLiveStrategy?: "creation" | "usage" | undefined
 }): Effect.Effect<Pool<A, E>, never, R | Scope.Scope> =>
   Effect.flatMap(
@@ -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))
@@ -471,10 +473,10 @@ const strategyNoop = <A, E>(): Strategy<A, E> => ({
   reclaim: (_) => Effect.undefined
 })
 
-const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.DurationInput) {
+const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input) {
   const clock = yield* Clock
   const queue = yield* Queue.unbounded<PoolItem<A, E>>()
-  const ttlMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(ttl))
+  const ttlMillis = Duration.toMillis(Duration.fromInputUnsafe(ttl))
   const creationTimes = new WeakMap<PoolItem<A, E>, number>()
   return identity<Strategy<A, E>>({
     run: (pool) => {
@@ -504,7 +506,7 @@ const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Dura
   })
 })
 
-const strategyUsageTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.DurationInput) {
+const strategyUsageTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input) {
   const queue = yield* Queue.unbounded<PoolItem<A, E>>()
   return identity<Strategy<A, E>>({
     run: (pool) => {

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/Pull.ts

@@ -95,7 +95,7 @@ export const catchDone: {
   effect: Effect<A, E, R>,
   f: (leftover: Cause.Done.Extract<E>) => Effect<A2, E2, R2>
 ): Effect<A | A2, ExcludeDone<E> | E2, R | R2> =>
-  internalEffect.catchCauseIf(effect, filterDoneLeftover as any, (l: any) => f(l)) as any)
+  internalEffect.catchCauseFilter(effect, filterDoneLeftover as any, (l: any) => f(l)) as any)
 
 /**
  * Checks if a Cause contains any done errors.

package/src/Queue.ts

@@ -1113,7 +1113,6 @@ export const collect = <A, E>(self: Dequeue<A, E | Done>): Effect<Array<A>, Pull
           while: constTrue,
           body: constant(takeAll(self)),
           step(items: Arr.NonEmptyArray<A>) {
-            out.push(...items)
             for (let i = 0; i < items.length; i++) {
               out.push(items[i])
             }

package/src/Random.ts

@@ -23,8 +23,9 @@
  */
 import * as Effect from "./Effect.ts"
 import { dual } from "./Function.ts"
+import * as random from "./internal/random.ts"
 import * as Predicate from "./Predicate.ts"
-import * as ServiceMap from "./ServiceMap.ts"
+import type * as ServiceMap from "./ServiceMap.ts"
 
 /**
  * Represents a service for generating random numbers.
@@ -49,23 +50,13 @@ import * as ServiceMap from "./ServiceMap.ts"
  * @since 4.0.0
  * @category Random Number Generators
  */
-export const Random = ServiceMap.Reference<{
+export const Random: ServiceMap.Reference<{
   nextIntUnsafe(): number
   nextDoubleUnsafe(): number
-}>("effect/Random", {
-  defaultValue: () => ({
-    nextIntUnsafe() {
-      return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) +
-        Number.MIN_SAFE_INTEGER
-    },
-    nextDoubleUnsafe() {
-      return Math.random()
-    }
-  })
-})
+}> = random.Random
 
 const randomWith = <A>(f: (random: typeof Random["Service"]) => A): Effect.Effect<A> =>
-  Effect.withFiber((fiber) => Effect.succeed(f(ServiceMap.get(fiber.services, Random))))
+  Effect.withFiber((fiber) => Effect.succeed(f(fiber.getRef(Random))))
 
 /**
  * Generates a random number between 0 (inclusive) and 1 (inclusive).
@@ -85,6 +76,24 @@ const randomWith = <A>(f: (random: typeof Random["Service"]) => A): Effect.Effec
  */
 export const next: Effect.Effect<number> = randomWith((r) => r.nextDoubleUnsafe())
 
+/**
+ * Generates a random boolean value.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const value = yield* Random.nextBoolean
+ *   console.log("Random boolean:", value)
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category Random Number Generators
+ */
+export const nextBoolean: Effect.Effect<boolean> = randomWith((r) => r.nextDoubleUnsafe() > 0.5)
+
 /**
  * Generates a random integer between `Number.MIN_SAFE_INTEGER` (inclusive)
  * and `Number.MAX_SAFE_INTEGER` (inclusive).
@@ -156,6 +165,34 @@ export const nextIntBetween = (min: number, max: number, options?: {
   })
 }
 
+/**
+ * Uses the pseudo-random number generator to shuffle the specified iterable.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const values = yield* Random.shuffle([1, 2, 3, 4, 5])
+ *   console.log(values)
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category Random Number Generators
+ */
+export const shuffle = <A>(elements: Iterable<A>): Effect.Effect<Array<A>> =>
+  randomWith((r) => {
+    const buffer = Array.from(elements)
+    for (let i = buffer.length - 1; i >= 1; i = i - 1) {
+      const index = Math.min(i, Math.floor(r.nextDoubleUnsafe() * (i + 1)))
+      const value = buffer[i]!
+      buffer[i] = buffer[index]!
+      buffer[index] = value
+    }
+    return buffer
+  })
+
 /**
  * Generates a random UUID (v4) string.
  *

package/src/RcMap.ts

@@ -292,7 +292,7 @@ export const make: {
   <K, A, E, R>(
     options: {
       readonly lookup: (key: K) => Effect.Effect<A, E, R>
-      readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+      readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
       readonly capacity?: undefined
     }
   ): Effect.Effect<RcMap<K, A, E>, never, Scope.Scope | R>
@@ -335,13 +335,13 @@ export const make: {
   <K, A, E, R>(
     options: {
       readonly lookup: (key: K) => Effect.Effect<A, E, R>
-      readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+      readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
       readonly capacity: number
     }
   ): Effect.Effect<RcMap<K, A, E | Cause.ExceededCapacityError>, never, Scope.Scope | R>
 } = <K, A, E, R>(options: {
   readonly lookup: (key: K) => Effect.Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+  readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
   readonly capacity?: number | undefined
 }) =>
   Effect.withFiber<RcMap<K, A, E>, never, R | Scope.Scope>((fiber) => {
@@ -352,8 +352,8 @@ export const make: {
       services,
       scope,
       idleTimeToLive: typeof options.idleTimeToLive === "function"
-        ? flow(options.idleTimeToLive, Duration.fromDurationInputUnsafe)
-        : constant(Duration.fromDurationInputUnsafe(options.idleTimeToLive ?? Duration.zero)),
+        ? flow(options.idleTimeToLive, Duration.fromInputUnsafe)
+        : constant(Duration.fromInputUnsafe(options.idleTimeToLive ?? Duration.zero)),
       capacity: Math.max(options.capacity ?? Number.POSITIVE_INFINITY, 0)
     })
     return Effect.as(

package/src/RcRef.ts

@@ -120,7 +120,7 @@ export const make: <A, E, R>(
      * When the reference count reaches zero, the resource will be released
      * after this duration.
      */
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ) => Effect.Effect<RcRef<A, E>, never, R | Scope> = internal.make