effect 2.0.0-next.55 → 2.0.0-next.57

package/src/ConfigProvider.ts

@@ -46,7 +46,7 @@ export interface ConfigProvider extends ConfigProvider.Proto, Pipeable {
   /**
    * Loads the specified configuration, or fails with a config error.
    */
-  readonly load: <A>(config: Config.Config<A>) => Effect.Effect<never, ConfigError.ConfigError, A>
+  load<A>(config: Config.Config<A>): Effect.Effect<never, ConfigError.ConfigError, A>
   /**
    * Flattens this config provider into a simplified config provider that knows
    * only how to deal with flat (key/value) properties.
@@ -77,14 +77,14 @@ export declare namespace ConfigProvider {
   export interface Flat {
     readonly [FlatConfigProviderTypeId]: FlatConfigProviderTypeId
     readonly patch: PathPatch.PathPatch
-    readonly load: <A>(
+    load<A>(
       path: ReadonlyArray<string>,
       config: Config.Config.Primitive<A>,
       split?: boolean
-    ) => Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
-    readonly enumerateChildren: (
+    ): Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+    enumerateChildren(
       path: ReadonlyArray<string>
-    ) => Effect.Effect<never, ConfigError.ConfigError, HashSet.HashSet<string>>
+    ): Effect.Effect<never, ConfigError.ConfigError, HashSet.HashSet<string>>
   }
 
   /**

package/src/ConfigProviderPathPatch.ts

@@ -36,7 +36,7 @@ export interface AndThen {
  */
 export interface MapName {
   readonly _tag: "MapName"
-  readonly f: (string: string) => string
+  f(string: string): string
 }
 
 /**

package/src/Console.ts

@@ -25,27 +25,27 @@ export type TypeId = typeof TypeId
  */
 export interface Console {
   readonly [TypeId]: TypeId
-  readonly assert: (condition: boolean, ...args: ReadonlyArray<any>) => Effect<never, never, void>
+  assert(condition: boolean, ...args: ReadonlyArray<any>): Effect<never, never, void>
   readonly clear: Effect<never, never, void>
-  readonly count: (label?: string) => Effect<never, never, void>
-  readonly countReset: (label?: string) => Effect<never, never, void>
-  readonly debug: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly dir: (item: any, options?: any) => Effect<never, never, void>
-  readonly dirxml: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly error: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly group: (options?: {
+  count(label?: string): Effect<never, never, void>
+  countReset(label?: string): Effect<never, never, void>
+  debug(...args: ReadonlyArray<any>): Effect<never, never, void>
+  dir(item: any, options?: any): Effect<never, never, void>
+  dirxml(...args: ReadonlyArray<any>): Effect<never, never, void>
+  error(...args: ReadonlyArray<any>): Effect<never, never, void>
+  group(options?: {
     readonly label?: string | undefined
     readonly collapsed?: boolean | undefined
-  }) => Effect<never, never, void>
+  }): Effect<never, never, void>
   readonly groupEnd: Effect<never, never, void>
-  readonly info: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly log: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly table: (tabularData: any, properties?: ReadonlyArray<string>) => Effect<never, never, void>
-  readonly time: (label?: string) => Effect<never, never, void>
-  readonly timeEnd: (label?: string) => Effect<never, never, void>
-  readonly timeLog: (label?: string, ...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly trace: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly warn: (...args: ReadonlyArray<any>) => Effect<never, never, void>
+  info(...args: ReadonlyArray<any>): Effect<never, never, void>
+  log(...args: ReadonlyArray<any>): Effect<never, never, void>
+  table(tabularData: any, properties?: ReadonlyArray<string>): Effect<never, never, void>
+  time(label?: string): Effect<never, never, void>
+  timeEnd(label?: string): Effect<never, never, void>
+  timeLog(label?: string, ...args: ReadonlyArray<any>): Effect<never, never, void>
+  trace(...args: ReadonlyArray<any>): Effect<never, never, void>
+  warn(...args: ReadonlyArray<any>): Effect<never, never, void>
   readonly unsafe: UnsafeConsole
 }
 
@@ -54,27 +54,27 @@ export interface Console {
  * @category model
  */
 export interface UnsafeConsole {
-  readonly assert: (condition: boolean, ...args: ReadonlyArray<any>) => void
-  readonly clear: () => void
-  readonly count: (label?: string) => void
-  readonly countReset: (label?: string) => void
-  readonly debug: (...args: ReadonlyArray<any>) => void
-  readonly dir: (item: any, options?: any) => void
-  readonly dirxml: (...args: ReadonlyArray<any>) => void
-  readonly error: (...args: ReadonlyArray<any>) => void
-  readonly group: (options?: {
+  assert(condition: boolean, ...args: ReadonlyArray<any>): void
+  clear(): void
+  count(label?: string): void
+  countReset(label?: string): void
+  debug(...args: ReadonlyArray<any>): void
+  dir(item: any, options?: any): void
+  dirxml(...args: ReadonlyArray<any>): void
+  error(...args: ReadonlyArray<any>): void
+  group(options?: {
     readonly label?: string | undefined
     readonly collapsed?: boolean | undefined
-  }) => void
-  readonly groupEnd: () => void
-  readonly info: (...args: ReadonlyArray<any>) => void
-  readonly log: (...args: ReadonlyArray<any>) => void
-  readonly table: (tabularData: any, properties?: ReadonlyArray<string>) => void
-  readonly time: (label?: string) => void
-  readonly timeEnd: (label?: string) => void
-  readonly timeLog: (label?: string, ...args: ReadonlyArray<any>) => void
-  readonly trace: (...args: ReadonlyArray<any>) => void
-  readonly warn: (...args: ReadonlyArray<any>) => void
+  }): void
+  groupEnd(): void
+  info(...args: ReadonlyArray<any>): void
+  log(...args: ReadonlyArray<any>): void
+  table(tabularData: any, properties?: ReadonlyArray<string>): void
+  time(label?: string): void
+  timeEnd(label?: string): void
+  timeLog(label?: string, ...args: ReadonlyArray<any>): void
+  trace(...args: ReadonlyArray<any>): void
+  warn(...args: ReadonlyArray<any>): void
 }
 
 /**

package/src/Context.ts

@@ -12,6 +12,7 @@ import type { Inspectable } from "./Inspectable.js"
 import * as internal from "./internal/context.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 const TagTypeId: unique symbol = internal.TagTypeId
@@ -26,15 +27,15 @@ export type TagTypeId = typeof TagTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Tag<Identifier, Service> extends Pipeable, Inspectable {
+export interface Tag<in out Identifier, in out Service> extends Pipeable, Inspectable {
   readonly _tag: "Tag"
   readonly _op: "Tag"
   readonly [TagTypeId]: {
-    readonly _S: (_: Service) => Service
-    readonly _I: (_: Identifier) => Identifier
+    readonly _Service: Types.Invariant<Service>
+    readonly _Identifier: Types.Invariant<Identifier>
   }
-  readonly of: (self: Service) => Service
-  readonly context: (self: Service) => Context<Identifier>
+  of(self: Service): Service
+  context(self: Service): Context<Identifier>
   readonly stack?: string | undefined
   readonly identifier?: unknown
   [Unify.typeSymbol]?: unknown
@@ -111,9 +112,9 @@ export type ValidTagsById<R> = R extends infer S ? Tag<S, any> : never
  * @since 2.0.0
  * @category models
  */
-export interface Context<Services> extends Equal, Pipeable, Inspectable {
+export interface Context<in Services> extends Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
-    readonly _S: (_: Services) => unknown
+    readonly _Services: Types.Contravariant<Services>
   }
   readonly unsafeMap: Map<Tag<any, any>, any>
 }

package/src/Data.ts

@@ -1,13 +1,11 @@
 /**
  * @since 2.0.0
  */
-import type * as Channel from "./Channel.js"
-import * as Effect from "./Effect.js"
-import * as Effectable from "./Effectable.js"
+import type * as Cause from "./Cause.js"
 import type * as Equal from "./Equal.js"
+import * as core from "./internal/core.js"
 import * as internal from "./internal/data.js"
-import { type Pipeable } from "./Pipeable.js"
-import type * as Sink from "./Sink.js"
+import { StructuralPrototype } from "./internal/effectable.js"
 import type * as Types from "./Types.js"
 
 /**
@@ -69,7 +67,7 @@ export const struct: <A extends Record<string, any>>(a: A) => Data<{ readonly [P
  * @since 2.0.0
  */
 export const unsafeStruct = <A extends Record<string, any>>(as: A): Data<{ readonly [P in keyof A]: A[P] }> =>
-  Object.setPrototypeOf(as, internal.StructProto)
+  Object.setPrototypeOf(as, StructuralPrototype)
 
 /**
  * @example
@@ -126,7 +124,7 @@ export const unsafeArray = <As extends ReadonlyArray<any>>(as: As): Data<Readonl
   Object.setPrototypeOf(as, internal.ArrayProto)
 
 const _case = <A extends Case>(): Case.Constructor<A> => (args) =>
-  (args === undefined ? Object.create(internal.StructProto) : struct(args)) as any
+  (args === undefined ? Object.create(StructuralPrototype) : struct(args)) as any
 
 export {
   /**
@@ -183,7 +181,7 @@ export const tagged = <A extends Case & { readonly _tag: string }>(
   tag: A["_tag"]
 ): Case.Constructor<A, "_tag"> =>
 (args) => {
-  const value = args === undefined ? Object.create(internal.StructProto) : struct(args)
+  const value = args === undefined ? Object.create(StructuralPrototype) : struct(args)
   value._tag = tag
   return value
 }
@@ -209,7 +207,7 @@ export const tagged = <A extends Case & { readonly _tag: string }>(
  * @since 2.0.0
  * @category constructors
  */
-export const Class: new<A extends Record<string, any>>(
+export const Class: new<A extends Record<string, any> = {}>(
   args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
     : { readonly [P in keyof A as P extends keyof Equal.Equal ? never : P]: A[P] }
 ) => Data<Readonly<A>> = internal.Structural as any
@@ -239,7 +237,7 @@ export const Class: new<A extends Record<string, any>>(
  */
 export const TaggedClass = <Tag extends string>(
   tag: Tag
-): new<A extends Record<string, any>>(
+): new<A extends Record<string, any> = {}>(
   args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
     : { readonly [P in keyof A as P extends "_tag" | keyof Equal.Equal ? never : P]: A[P] }
 ) => Data<Readonly<A> & { readonly _tag: Tag }> => {
@@ -442,63 +440,34 @@ export const taggedEnum: {
     }
   }) as any
 
-/**
- * @since 2.0.0
- * @category models
- */
-export interface YieldableError extends Case, Pipeable, Readonly<Error> {
-  readonly [Effectable.EffectTypeId]: Effect.Effect.VarianceStruct<never, this, never>
-  readonly [Effectable.StreamTypeId]: Effect.Effect.VarianceStruct<never, this, never>
-  readonly [Effectable.SinkTypeId]: Sink.Sink.VarianceStruct<never, this, unknown, never, never>
-  readonly [Effectable.ChannelTypeId]: Channel.Channel.VarianceStruct<
-    never,
-    unknown,
-    unknown,
-    unknown,
-    this,
-    never,
-    never
-  >
-}
-
-const YieldableErrorProto = {
-  ...Effectable.StructuralCommitPrototype,
-  commit() {
-    return Effect.fail(this)
-  },
-  toString(this: globalThis.Error) {
-    return `${this.name}: ${this.message}`
-  }
-}
-
 /**
  * Provides a constructor for a Case Class.
  *
  * @since 2.0.0
  * @category constructors
  */
-export const Error: new<A extends Record<string, any>>(
+export const Error: new<A extends Record<string, any> = {}>(
   args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
     : { readonly [P in keyof A as P extends keyof Equal.Equal ? never : P]: A[P] }
-) => YieldableError & Readonly<A> = (function() {
-  class Base extends globalThis.Error {
+) => Cause.YieldableError & Readonly<A> = (function() {
+  return class Base extends core.YieldableError {
     constructor(args: any) {
       super()
-      Object.assign(this, args)
+      if (args) {
+        Object.assign(this, args)
+      }
     }
-  }
-  Object.assign(Base.prototype, YieldableErrorProto)
-  return Base as any
+  } as any
 })()
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const TaggedError = <Tag extends string>(tag: Tag): new<A extends Record<string, any>>(
+export const TaggedError = <Tag extends string>(tag: Tag): new<A extends Record<string, any> = {}>(
   args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
     : { readonly [P in keyof A as P extends "_tag" | keyof Equal.Equal ? never : P]: A[P] }
-) => YieldableError & { readonly _tag: Tag } & Readonly<A> => {
+) => Cause.YieldableError & { readonly _tag: Tag } & Readonly<A> => {
   class Base extends Error<{}> {
     readonly _tag = tag
   }

package/src/Deferred.ts

@@ -11,6 +11,7 @@ import * as internal from "./internal/deferred.js"
 import type * as MutableRef from "./MutableRef.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -36,7 +37,7 @@ export type DeferredTypeId = typeof DeferredTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Deferred<E, A> extends Deferred.Variance<E, A>, Pipeable {
+export interface Deferred<in out E, in out A> extends Deferred.Variance<E, A>, Pipeable {
   /** @internal */
   readonly state: MutableRef.MutableRef<internal.State<E, A>>
   /** @internal */
@@ -51,10 +52,10 @@ export declare namespace Deferred {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<E, A> {
+  export interface Variance<in out E, in out A> {
     readonly [DeferredTypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _E: Types.Invariant<E>
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/Differ.ts

@@ -14,6 +14,7 @@ import * as ContextPatch from "./internal/differ/contextPatch.js"
 import * as HashMapPatch from "./internal/differ/hashMapPatch.js"
 import * as HashSetPatch from "./internal/differ/hashSetPatch.js"
 import * as OrPatch from "./internal/differ/orPatch.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -46,15 +47,15 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface Differ<Value, Patch> {
+export interface Differ<in out Value, in out Patch> {
   readonly [TypeId]: {
-    readonly _V: (_: Value) => Value
-    readonly _P: (_: Patch) => Patch
+    readonly _V: Types.Invariant<Value>
+    readonly _P: Types.Invariant<Patch>
   }
   readonly empty: Patch
-  readonly diff: (oldValue: Value, newValue: Value) => Patch
-  readonly combine: (first: Patch, second: Patch) => Patch
-  readonly patch: (patch: Patch, oldValue: Value) => Value
+  diff(oldValue: Value, newValue: Value): Patch
+  combine(first: Patch, second: Patch): Patch
+  patch(patch: Patch, oldValue: Value): Value
 }
 
 const ChunkPatchTypeId: unique symbol = ChunkPatch.ChunkPatchTypeId as Differ.Chunk.TypeId
@@ -84,10 +85,10 @@ export declare namespace Differ {
      * @since 2.0.0
      * @category models
      */
-    export interface Patch<Input, Output> extends Equal {
+    export interface Patch<in Input, out Output> extends Equal {
       readonly [ContextPatchTypeId]: {
-        readonly _Input: (_: Input) => void
-        readonly _Output: (_: never) => Output
+        readonly _Input: Types.Contravariant<Input>
+        readonly _Output: Types.Covariant<Output>
       }
     }
   }
@@ -107,10 +108,10 @@ export declare namespace Differ {
      * @since 2.0.0
      * @category models
      */
-    export interface Patch<Value, Patch> extends Equal {
+    export interface Patch<in out Value, in out Patch> extends Equal {
       readonly [ChunkPatchTypeId]: {
-        readonly _Value: (_: Value) => Value
-        readonly _Patch: (_: Patch) => Patch
+        readonly _Value: Types.Invariant<Value>
+        readonly _Patch: Types.Invariant<Patch>
       }
     }
   }
@@ -130,11 +131,11 @@ export declare namespace Differ {
      * @since 2.0.0
      * @category models
      */
-    export interface Patch<Key, Value, Patch> extends Equal {
+    export interface Patch<in out Key, in out Value, in out Patch> extends Equal {
       readonly [HashMapPatchTypeId]: {
-        readonly _Key: (_: Key) => Key
-        readonly _Value: (_: Value) => Value
-        readonly _Patch: (_: Patch) => Patch
+        readonly _Key: Types.Invariant<Key>
+        readonly _Value: Types.Invariant<Value>
+        readonly _Patch: Types.Invariant<Patch>
       }
     }
   }
@@ -154,9 +155,9 @@ export declare namespace Differ {
      * @since 2.0.0
      * @category models
      */
-    export interface Patch<Value> extends Equal {
+    export interface Patch<in out Value> extends Equal {
       readonly [HashSetPatchTypeId]: {
-        readonly _Value: (_: Value) => Value
+        readonly _Value: Types.Invariant<Value>
       }
     }
   }
@@ -176,12 +177,12 @@ export declare namespace Differ {
      * @since 2.0.0
      * @category models
      */
-    export interface Patch<Value, Value2, Patch, Patch2> extends Equal {
+    export interface Patch<in out Value, in out Value2, in out Patch, in out Patch2> extends Equal {
       readonly [OrPatchTypeId]: {
-        readonly _Value: (_: Value) => Value
-        readonly _Value2: (_: Value2) => Value2
-        readonly _Patch: (_: Patch) => Patch
-        readonly _Patch2: (_: Patch2) => Patch2
+        readonly _Value: Types.Invariant<Value>
+        readonly _Value2: Types.Invariant<Value2>
+        readonly _Patch: Types.Invariant<Patch>
+        readonly _Patch2: Types.Invariant<Patch2>
       }
     }
   }

package/src/Duration.ts

@@ -6,7 +6,7 @@ import type * as equivalence from "./Equivalence.js"
 import { dual } from "./Function.js"
 import * as Hash from "./Hash.js"
 import type { Inspectable } from "./Inspectable.js"
-import { NodeInspectSymbol, toString } from "./Inspectable.js"
+import { NodeInspectSymbol } from "./Inspectable.js"
 import * as Option from "./Option.js"
 import * as order from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
@@ -63,6 +63,7 @@ export type DurationInput =
   | Duration
   | number // millis
   | bigint // nanos
+  | [number, number] // [seconds, nanos]
   | `${number} ${Unit}`
 
 const DURATION_REGEX = /^(-?\d+(?:\.\d+)?)\s+(nanos|micros|millis|seconds|minutes|hours|days|weeks)$/
@@ -77,6 +78,10 @@ export const decode = (input: DurationInput): Duration => {
     return millis(input)
   } else if (isBigInt(input)) {
     return nanos(input)
+  } else if (Array.isArray(input)) {
+    if (input.length === 2 && isNumber(input[0]) && isNumber(input[1])) {
+      return nanos(BigInt(input[0]) * bigint1e9 + BigInt(input[1]))
+    }
   } else {
     DURATION_REGEX.lastIndex = 0 // Reset the lastIndex before each use
     const match = DURATION_REGEX.exec(input)
@@ -118,7 +123,7 @@ const DurationProto: Omit<Duration, "value"> = {
     return isDuration(that) && equals(this, that)
   },
   toString(this: Duration) {
-    return toString(this.toJSON())
+    return `Duration(${format(this)})`
   },
   toJSON(this: Duration) {
     switch (this.value._tag) {
@@ -583,3 +588,55 @@ export const equals: {
   (that: DurationInput): (self: DurationInput) => boolean
   (self: DurationInput, that: DurationInput): boolean
 } = dual(2, (self: DurationInput, that: DurationInput): boolean => Equivalence(decode(self), decode(that)))
+
+/**
+ * Converts a `Duration` to a human readable string.
+ * @since 2.0.0
+ *
+ * @example
+ * import * as Duration from "effect/Duration"
+ *
+ * Duration.format(Duration.millis(1000)) // "1s"
+ * Duration.format(Duration.millis(1001)) // "1s 1ms"
+ */
+export const format = (self: DurationInput): string => {
+  const duration = decode(self)
+  const parts = []
+
+  if (duration.value._tag === "Infinity") {
+    return "Infinity"
+  }
+
+  const nanos = unsafeToNanos(duration)
+
+  if (nanos % 1000000n) {
+    parts.push(`${nanos % 1000000n}ns`)
+  }
+
+  const ms = nanos / 1000000n
+  if (ms % 1000n !== 0n) {
+    parts.push(`${ms % 1000n}ms`)
+  }
+
+  const sec = ms / 1000n
+  if (sec % 60n !== 0n) {
+    parts.push(`${sec % 60n}s`)
+  }
+
+  const min = sec / 60n
+  if (min % 60n !== 0n) {
+    parts.push(`${min % 60n}m`)
+  }
+
+  const hr = min / 60n
+  if (hr % 24n !== 0n) {
+    parts.push(`${hr % 24n}h`)
+  }
+
+  const days = hr / 24n
+  if (days !== 0n) {
+    parts.push(`${days}d`)
+  }
+
+  return parts.reverse().join(" ")
+}