effect 2.0.0-next.47 → 2.0.0-next.49

package/src/{Bigint.ts → BigInt.ts}

@@ -19,15 +19,15 @@ import * as predicate from "./Predicate"
  * @param input - The value to test.
  *
  * @example
- * import { isBigint } from "effect/Bigint"
+ * import { isBigInt } from "effect/BigInt"
  *
- * assert.deepStrictEqual(isBigint(1n), true)
- * assert.deepStrictEqual(isBigint(1), false)
+ * assert.deepStrictEqual(isBigInt(1n), true)
+ * assert.deepStrictEqual(isBigInt(1), false)
  *
  * @category guards
  * @since 2.0.0
  */
-export const isBigint: (u: unknown) => u is bigint = predicate.isBigint
+export const isBigInt: (u: unknown) => u is bigint = predicate.isBigInt
 
 /**
  * Provides an addition operation on `bigint`s.
@@ -36,7 +36,7 @@ export const isBigint: (u: unknown) => u is bigint = predicate.isBigint
  * @param that - The second operand.
  *
  * @example
- * import { sum } from 'effect/Bigint'
+ * import { sum } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(sum(2n, 3n), 5n)
  *
@@ -55,7 +55,7 @@ export const sum: {
  * @param that - The second operand.
  *
  * @example
- * import { multiply } from 'effect/Bigint'
+ * import { multiply } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(multiply(2n, 3n), 6n)
  *
@@ -74,7 +74,7 @@ export const multiply: {
  * @param that - The second operand.
  *
  * @example
- * import { subtract } from 'effect/Bigint'
+ * import { subtract } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(subtract(2n, 3n), -1n)
  *
@@ -96,7 +96,7 @@ export const subtract: {
  * @param that - The divisor operand.
  *
  * @example
- * import { divide } from 'effect/Bigint'
+ * import { divide } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(divide(6n, 3n), 2n)
  * assert.deepStrictEqual(divide(6n, 4n), 1n)
@@ -116,7 +116,7 @@ export const divide: {
  * @param n - A `bigint` to be incremented.
  *
  * @example
- * import { increment } from 'effect/Bigint'
+ * import { increment } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(increment(2n), 3n)
  *
@@ -131,7 +131,7 @@ export const increment = (n: bigint): bigint => n + 1n
  * @param n - A `bigint` to be decremented.
  *
  * @example
- * import { decrement } from 'effect/Bigint'
+ * import { decrement } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(decrement(3n), 2n)
  *
@@ -159,7 +159,7 @@ export const Order: order.Order<bigint> = order.bigint
  * @param that - The second argument.
  *
  * @example
- * import { lessThan } from 'effect/Bigint'
+ * import { lessThan } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(lessThan(2n, 3n), true)
  * assert.deepStrictEqual(lessThan(3n, 3n), false)
@@ -180,7 +180,7 @@ export const lessThan: {
  * @param that - The second `bigint` to compare with.
  *
  * @example
- * import { lessThanOrEqualTo } from 'effect/Bigint'
+ * import { lessThanOrEqualTo } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(lessThanOrEqualTo(2n, 3n), true)
  * assert.deepStrictEqual(lessThanOrEqualTo(3n, 3n), true)
@@ -201,7 +201,7 @@ export const lessThanOrEqualTo: {
  * @param that - The second argument.
  *
  * @example
- * import { greaterThan } from 'effect/Bigint'
+ * import { greaterThan } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(greaterThan(2n, 3n), false)
  * assert.deepStrictEqual(greaterThan(3n, 3n), false)
@@ -222,7 +222,7 @@ export const greaterThan: {
  * @param that - The second `bigint` to compare with.
  *
  * @example
- * import { greaterThanOrEqualTo } from 'effect/Bigint'
+ * import { greaterThanOrEqualTo } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(greaterThanOrEqualTo(2n, 3n), false)
  * assert.deepStrictEqual(greaterThanOrEqualTo(3n, 3n), true)
@@ -244,7 +244,7 @@ export const greaterThanOrEqualTo: {
  * @param maximum - The `maximum` value to check.
  *
  * @example
- * import { between } from 'effect/Bigint'
+ * import { between } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(between(0n, 5n)(3n), true)
  * assert.deepStrictEqual(between(0n, 5n)(-1n), false)
@@ -270,7 +270,7 @@ export const between: {
  * @param maximum - The upper end of the range.
  *
  * @example
- * import { clamp } from 'effect/Bigint'
+ * import { clamp } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(clamp(0n, 5n)(3n), 3n)
  * assert.deepStrictEqual(clamp(0n, 5n)(-1n), 0n)
@@ -290,7 +290,7 @@ export const clamp: {
  * @param that - The second `bigint`.
  *
  * @example
- * import { min } from 'effect/Bigint'
+ * import { min } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(min(2n, 3n), 2n)
  *
@@ -308,7 +308,7 @@ export const min: {
  * @param that - The second `bigint`.
  *
  * @example
- * import { max } from 'effect/Bigint'
+ * import { max } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(max(2n, 3n), 3n)
  *
@@ -325,7 +325,7 @@ export const max: {
  * @param n - The `bigint` to determine the sign of.
  *
  * @example
- * import { sign } from 'effect/Bigint'
+ * import { sign } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(sign(-5n), -1)
  * assert.deepStrictEqual(sign(0n), 0)
@@ -342,7 +342,7 @@ export const sign = (n: bigint): Ordering => Order(n, 0n)
  * @param n - The `bigint` to determine the absolute value of.
  *
  * @example
- * import { abs } from 'effect/Bigint'
+ * import { abs } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(abs(-5n), 5n)
  * assert.deepStrictEqual(abs(0n), 0n)
@@ -360,7 +360,7 @@ export const abs = (n: bigint): bigint => (n < 0n ? -n : n)
  * @param b - The second `bigint`.
  *
  * @example
- * import { gcd } from 'effect/Bigint'
+ * import { gcd } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(gcd(2n, 3n), 1n)
  * assert.deepStrictEqual(gcd(2n, 4n), 2n)
@@ -388,7 +388,7 @@ export const gcd: {
  * @param b - The second `bigint`.
  *
  * @example
- * import { lcm } from 'effect/Bigint'
+ * import { lcm } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(lcm(2n, 3n), 6n)
  * assert.deepStrictEqual(lcm(2n, 4n), 4n)
@@ -408,7 +408,7 @@ export const lcm: {
  * @param n - The `bigint` to determine the square root of.
  *
  * @example
- * import { unsafeSqrt } from 'effect/Bigint'
+ * import { unsafeSqrt } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(unsafeSqrt(4n), 2n)
  * assert.deepStrictEqual(unsafeSqrt(9n), 3n)
@@ -437,7 +437,7 @@ export const unsafeSqrt = (n: bigint): bigint => {
  * @param n - The `bigint` to determine the square root of.
  *
  * @example
- * import { sqrt } from 'effect/Bigint'
+ * import { sqrt } from 'effect/BigInt'
  * import * as Option from 'effect/Option'
  *
  * assert.deepStrictEqual(sqrt(4n), Option.some(2n))
@@ -457,7 +457,7 @@ export const sqrt = (n: bigint): Option.Option<bigint> =>
  * @param collection - The collection of `bigint`s to sum.
  *
  * @example
- * import { sumAll } from 'effect/Bigint'
+ * import { sumAll } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(sumAll([2n, 3n, 4n]), 9n)
  *
@@ -478,7 +478,7 @@ export const sumAll = (collection: Iterable<bigint>): bigint => {
  * @param collection - The collection of `bigint`s to multiply.
  *
  * @example
- * import { multiplyAll } from 'effect/Bigint'
+ * import { multiplyAll } from 'effect/BigInt'
  *
  * assert.deepStrictEqual(multiplyAll([2n, 3n, 4n]), 24n)
  *

package/src/Channel.ts

@@ -1941,6 +1941,16 @@ export const scoped: <R, E, A>(
  */
 export const succeed: <A>(value: A) => Channel<never, unknown, unknown, unknown, never, never, A> = core.succeed
 
+/**
+ * Lazily constructs a channel from the given side effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const suspend: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
+  evaluate: LazyArg<Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>>
+) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> = core.suspend
+
 /**
  * Constructs a channel that succeeds immediately with the specified lazy value.
  *
@@ -2060,10 +2070,11 @@ export const withSpan: {
   (
     name: string,
     options?: {
-      readonly attributes?: Record<string, Tracer.AttributeValue>
+      readonly attributes?: Record<string, unknown>
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
+      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
   ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
@@ -2073,10 +2084,11 @@ export const withSpan: {
     self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
     name: string,
     options?: {
-      readonly attributes?: Record<string, Tracer.AttributeValue>
+      readonly attributes?: Record<string, unknown>
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
+      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
   ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>

package/src/Chunk.ts

@@ -823,7 +823,7 @@ export const last = <A>(self: Chunk<A>): Option<A> => get(self, self.length - 1)
 export const unsafeLast = <A>(self: Chunk<A>): A => unsafeGet(self, self.length - 1)
 
 /**
- * Returns an effect whose success is mapped by the specified f function.
+ * Returns a chunk with the elements mapped by the specified f function.
  *
  * @since 2.0.0
  * @category mapping
@@ -836,6 +836,17 @@ export const map: {
     of(f(self.backing.a, 0)) :
     unsafeFromArray(pipe(toReadonlyArray(self), RA.map((a, i) => f(a, i)))))
 
+/**
+ * Returns a non empty chunk with the elements mapped by the specified f function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const mapNonEmpty: {
+  <A, B>(f: (a: A, i: number) => B): (self: NonEmptyChunk<A>) => NonEmptyChunk<B>
+  <A, B>(self: NonEmptyChunk<A>, f: (a: A, i: number) => B): NonEmptyChunk<B>
+} = map as any
+
 /**
  * Statefully maps over the chunk, producing new elements of type `B`.
  *

package/src/Data.ts

@@ -5,7 +5,6 @@ import type * as Channel from "./Channel"
 import * as Effect from "./Effect"
 import * as Effectable from "./Effectable"
 import type * as Equal from "./Equal"
-import type * as Inspectable from "./Inspectable"
 import * as internal from "./internal/Data"
 import { type Pipeable } from "./Pipeable"
 import type * as Sink from "./Sink"
@@ -165,11 +164,21 @@ export const Structural: new<A>(
  * @since 2.0.0
  * @category models
  */
-export type TaggedEnum<A extends Record<string, Record<string, any>>> = {
-  readonly [Tag in keyof A]: Data<
-    Readonly<Types.Simplify<A[Tag] & { _tag: Tag }>>
-  >
-}[keyof A]
+export type TaggedEnum<
+  A extends Record<string, Record<string, any>> & UntaggedChildren<A>
+> = keyof A extends infer Tag
+  ? Tag extends keyof A ? Data<{ readonly [K in `_tag` | keyof A[Tag]]: K extends `_tag` ? Tag : A[Tag][K] }>
+  : never
+  : never
+
+type ChildrenAreTagged<A> = keyof A extends infer K ? K extends keyof A ? "_tag" extends keyof A[K] ? true
+    : false
+  : never
+  : never
+
+type UntaggedChildren<A> = true extends ChildrenAreTagged<A>
+  ? "It looks like you're trying to create a tagged enum, but one or more of its members already has a `_tag` property."
+  : unknown
 
 /**
  * @since 2.0.0
@@ -303,7 +312,7 @@ export const taggedEnum: {
  * @since 2.0.0
  * @category models
  */
-export interface YieldableError extends Case, Pipeable, Inspectable.Inspectable {
+export interface YieldableError extends Case, Pipeable, 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>
@@ -318,21 +327,23 @@ export interface YieldableError extends Case, Pipeable, Inspectable.Inspectable
   >
 }
 
-const YieldableErrorProto = Object.setPrototypeOf(
-  {
-    ...Effectable.StructuralCommitPrototype,
-    toString() {
-      return `${this.name}: ${this.message}`
-    },
-    get message() {
-      return JSON.stringify(this)
-    },
-    commit() {
-      return Effect.fail(this)
-    }
+const YieldableErrorMessage = Symbol.for("effect/Data/YieldableError/message")
+const YieldableErrorProto = {
+  ...Effectable.StructuralCommitPrototype,
+  __proto__: globalThis.Error.prototype,
+  commit() {
+    return Effect.fail(this)
   },
-  globalThis.Error.prototype
-)
+  toString(this: globalThis.Error) {
+    return `${this.name}: ${this.message}`
+  },
+  get message() {
+    return (this as any)[YieldableErrorMessage] ?? JSON.stringify(this)
+  },
+  set message(value: string) {
+    ;(this as any)[YieldableErrorMessage] = value
+  }
+}
 
 /**
  * Provides a constructor for a Case Class.
@@ -363,5 +374,6 @@ export const TaggedError = <Tag extends string>(tag: Tag): new<A extends Record<
   class Base extends Error<{}> {
     readonly _tag = tag
   }
+  Base.prototype.name = tag
   return Base as any
 }

package/src/Duration.ts

@@ -11,7 +11,7 @@ import * as Option from "./Option"
 import * as order from "./Order"
 import type { Pipeable } from "./Pipeable"
 import { pipeArguments } from "./Pipeable"
-import { isBigint, isNumber } from "./Predicate"
+import { isBigInt, isNumber } from "./Predicate"
 
 const TypeId: unique symbol = Symbol.for("effect/Duration")
 
@@ -75,7 +75,7 @@ export const decode = (input: DurationInput): Duration => {
     return input
   } else if (isNumber(input)) {
     return millis(input)
-  } else if (isBigint(input)) {
+  } else if (isBigInt(input)) {
     return nanos(input)
   } else {
     DURATION_REGEX.lastIndex = 0 // Reset the lastIndex before each use