effect 4.0.0-beta.0 → 4.0.0-beta.10

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/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).
@@ -156,6 +147,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
 

package/src/Reducer.ts

@@ -1,17 +1,107 @@
 /**
+ * A module for reducing collections of values into a single result.
+ *
+ * A `Reducer<A>` extends {@link Combiner.Combiner} by adding an
+ * `initialValue` (identity element) and a `combineAll` method that folds an
+ * entire collection. Think `Array.prototype.reduce`, but packaged as a
+ * reusable, composable value.
+ *
+ * ## Mental model
+ *
+ * - **Reducer** – a {@link Combiner.Combiner} plus an `initialValue` and a
+ *   `combineAll` method.
+ * - **initialValue** – the neutral/identity element. Combining any value with
+ *   `initialValue` should return the original value unchanged (e.g. `0` for
+ *   addition, `""` for string concatenation).
+ * - **combineAll** – folds an `Iterable<A>` starting from `initialValue`.
+ *   When omitted from {@link make}, a default left-to-right fold is used.
+ * - **Purity** – all reducers produced by this module are pure; they never
+ *   mutate their arguments.
+ * - **Composability** – reducers can be lifted into `Option`, `Struct`,
+ *   `Tuple`, `Record`, and other container types via helpers in those modules.
+ * - **Subtype of Combiner** – every `Reducer` is also a valid
+ *   `Combiner`, so you can pass a `Reducer` anywhere a `Combiner` is
+ *   expected.
+ *
+ * ## Common tasks
+ *
+ * - Create a reducer from a combine function and initial value → {@link make}
+ * - Swap argument order → {@link flip}
+ * - Combine two values without an initial value → use {@link Combiner.Combiner}
+ *   instead
+ *
+ * ## Gotchas
+ *
+ * - `combineAll` on an empty iterable returns `initialValue`, not an error.
+ * - The default `combineAll` folds left-to-right. If your `combine` is not
+ *   associative, order matters. Pass a custom `combineAll` to {@link make} if
+ *   you need different traversal or short-circuiting.
+ * - A `Reducer` is also a valid `Combiner` — but a `Combiner` is *not* a
+ *   `Reducer` (it lacks `initialValue`).
+ *
+ * ## Quickstart
+ *
+ * **Example** (summing a list of numbers)
+ *
+ * ```ts
+ * import { Reducer } from "effect"
+ *
+ * const Sum = Reducer.make<number>((a, b) => a + b, 0)
+ *
+ * console.log(Sum.combine(3, 4))
+ * // Output: 7
+ *
+ * console.log(Sum.combineAll([1, 2, 3, 4]))
+ * // Output: 10
+ *
+ * console.log(Sum.combineAll([]))
+ * // Output: 0
+ * ```
+ *
+ * ## See also
+ *
+ * - {@link make} – the primary constructor
+ * - {@link Reducer} – the core interface
+ * - {@link Combiner.Combiner} – the parent interface (no `initialValue`)
+ *
  * @since 4.0.0
  */
 
 import type * as Combiner from "./Combiner.ts"
 
 /**
- * A `Reducer` is a `Combiner` with an `initialValue` and a way to
- * combine a whole collection. Think `Array.prototype.reduce`, but reusable.
+ * Represents a strategy for reducing a collection of values of type `A` into
+ * a single result.
+ *
+ * Extends {@link Combiner.Combiner} with:
+ * - `initialValue` – the identity/neutral element for `combine`.
+ * - `combineAll` – folds an entire `Iterable<A>` from `initialValue`.
+ *
+ * When to use:
+ * - You need to fold/reduce a collection into a single value.
+ * - You want a reusable reducing strategy that can be passed to library
+ *   functions like `Struct.makeReducer`, `Option.makeReducer`, or
+ *   `Record.makeReducerUnion`.
+ * - You need both the combining logic *and* a known starting value.
+ *
+ * Many modules ship pre-built reducers:
+ * - `Number.ReducerSum`, `Number.ReducerMultiply`
+ * - `String.ReducerConcat`
+ * - `Boolean.ReducerAnd`, `Boolean.ReducerOr`
  *
- * Common initial values:
- * - numbers with addition: `0`
- * - strings with concatenation: `""`
- * - arrays with concatenation: `[]`
+ * **Example** (string concatenation reducer)
+ *
+ * ```ts
+ * import { Reducer } from "effect"
+ *
+ * const Concat = Reducer.make<string>((a, b) => a + b, "")
+ *
+ * console.log(Concat.combineAll(["hello", " ", "world"]))
+ * // Output: "hello world"
+ * ```
+ *
+ * @see {@link make} – create a `Reducer` from a function and initial value
+ * @see {@link Combiner.Combiner} – parent interface without `initialValue`
  *
  * @category model
  * @since 4.0.0
@@ -27,7 +117,44 @@ export interface Reducer<A> extends Combiner.Combiner<A> {
 /**
  * Creates a `Reducer` from a `combine` function and an `initialValue`.
  *
- * If `combineAll` is omitted, a default implementation reduces left-to-right.
+ * When to use:
+ * - You have a custom reducing operation not covered by a pre-built reducer.
+ * - You want to provide an optimized `combineAll` (e.g. short-circuiting on
+ *   a known absorbing element like `0` for multiplication).
+ *
+ * Behavior:
+ * - If `combineAll` is omitted, a default left-to-right fold starting from
+ *   `initialValue` is used.
+ * - If `combineAll` is provided, it completely replaces the default fold.
+ * - Pure – the returned reducer does not mutate its arguments.
+ *
+ * **Example** (multiplication with short-circuit)
+ *
+ * ```ts
+ * import { Reducer } from "effect"
+ *
+ * const Product = Reducer.make<number>(
+ *   (a, b) => a * b,
+ *   1,
+ *   (collection) => {
+ *     let acc = 1
+ *     for (const n of collection) {
+ *       if (n === 0) return 0
+ *       acc *= n
+ *     }
+ *     return acc
+ *   }
+ * )
+ *
+ * console.log(Product.combineAll([2, 3, 4]))
+ * // Output: 24
+ *
+ * console.log(Product.combineAll([2, 0, 4]))
+ * // Output: 0
+ * ```
+ *
+ * @see {@link Reducer} – the interface this creates
+ * @see {@link flip} – reverse the argument order
  *
  * @since 4.0.0
  */
@@ -51,6 +178,38 @@ export function make<A>(
 }
 
 /**
+ * Reverses the argument order of a reducer's `combine` method.
+ *
+ * When to use:
+ * - You need the "right" value to act as the accumulator side.
+ * - You want to reverse the natural direction of a non-commutative reducer
+ *   (e.g. string concatenation becomes prepend).
+ *
+ * Behavior:
+ * - Returns a new `Reducer` where `combine(self, that)` calls the original
+ *   reducer as `combine(that, self)`.
+ * - The `initialValue` is preserved from the original reducer.
+ * - The `combineAll` is re-derived from the flipped `combine` (using the
+ *   default left-to-right fold), not carried over from the original.
+ * - Does not mutate the input reducer.
+ *
+ * **Example** (reversing string concatenation)
+ *
+ * ```ts
+ * import { Reducer, String } from "effect"
+ *
+ * const Prepend = Reducer.flip(String.ReducerConcat)
+ *
+ * console.log(Prepend.combine("a", "b"))
+ * // Output: "ba"
+ *
+ * console.log(Prepend.combineAll(["a", "b", "c"]))
+ * // Output: "cba"
+ * ```
+ *
+ * @see {@link make}
+ * @see {@link Combiner.flip} – the same operation on a plain `Combiner`
+ *
  * @since 4.0.0
  */
 export function flip<A>(reducer: Reducer<A>): Reducer<A> {

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
 }