effect 3.1.1 → 3.1.2

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.1.1";
+let moduleVersion = "3.1.2";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/Array.ts

@@ -66,7 +66,7 @@ export const allocate = <A = never>(n: number): Array<A | undefined> => new Arra
  * **Note**. `n` is normalized to an integer >= 1.
  *
  * @example
- * import { makeBy } from 'effect/Array'
+ * import { makeBy } from "effect/Array"
  *
  * assert.deepStrictEqual(makeBy(5, n => n * 2), [0, 2, 4, 6, 8])
  *
@@ -86,7 +86,7 @@ export const makeBy = <A>(n: number, f: (i: number) => A): NonEmptyArray<A> => {
  * Return a `NonEmptyArray` containing a range of integers, including both endpoints.
  *
  * @example
- * import { range } from 'effect/Array'
+ * import { range } from "effect/Array"
  *
  * assert.deepStrictEqual(range(1, 3), [1, 2, 3])
  *
@@ -102,7 +102,7 @@ export const range = (start: number, end: number): NonEmptyArray<number> =>
  * **Note**. `n` is normalized to an integer >= 1.
  *
  * @example
- * import { replicate } from 'effect/Array'
+ * import { replicate } from "effect/Array"
  *
  * assert.deepStrictEqual(replicate("a", 3), ["a", "a", "a"])
  *
@@ -242,7 +242,7 @@ export const prepend: {
  * If either array is non-empty, the result is also a non-empty array.
  *
  * @example
- * import * as Array from "effect/Array"
+ * import { Array } from "effect"
  *
  * assert.deepStrictEqual(
  *   Array.prependAll([1, 2], ["a", "b"]),
@@ -1656,11 +1656,10 @@ export const partitionMap: {
  * Retrieves the `Some` values from an `Iterable` of `Option`s, collecting them into an array.
  *
  * @example
- * import { getSomes } from "effect/Array"
- * import { some, none } from "effect/Option"
+ * import { Array, Option } from "effect"
  *
  * assert.deepStrictEqual(
- *   getSomes([some(1), none(), some(2)]),
+ *   Array.getSomes([Option.some(1), Option.none(), Option.some(2)]),
  *   [1, 2]
  * )
  *
@@ -1673,11 +1672,10 @@ export const getSomes: <A>(self: Iterable<Option<A>>) => Array<A> = filterMap(id
  * Retrieves the `Left` values from an `Iterable` of `Either`s, collecting them into an array.
  *
  * @example
- * import { getLefts } from "effect/Array"
- * import { right, left } from "effect/Either"
+ * import { Array, Either } from "effect"
  *
  * assert.deepStrictEqual(
- *   getLefts([right(1), left("err"), right(2)]),
+ *   Array.getLefts([Either.right(1), Either.left("err"), Either.right(2)]),
  *   ["err"]
  * )
  *
@@ -1699,11 +1697,10 @@ export const getLefts = <R, L>(self: Iterable<Either<R, L>>): Array<L> => {
  * Retrieves the `Right` values from an `Iterable` of `Either`s, collecting them into an array.
  *
  * @example
- * import { getRights } from "effect/Array"
- * import { right, left } from "effect/Either"
+ * import { Array, Either } from "effect"
  *
  * assert.deepStrictEqual(
- *   getRights([right(1), left("err"), right(2)]),
+ *   Array.getRights([Either.right(1), Either.left("err"), Either.right(2)]),
  *   [1, 2]
  * )
  *

package/src/BigDecimal.ts

@@ -374,12 +374,11 @@ export const roundTerminal = (n: bigint): bigint => {
  * @param that - The divisor operand.
  *
  * @example
- * import { divide, unsafeFromString } from "effect/BigDecimal"
- * import { some, none } from "effect/Option"
+ * import { BigDecimal, Option } from "effect"
  *
- * assert.deepStrictEqual(divide(unsafeFromString("6"), unsafeFromString("3")), some(unsafeFromString("2")))
- * assert.deepStrictEqual(divide(unsafeFromString("6"), unsafeFromString("4")), some(unsafeFromString("1.5")))
- * assert.deepStrictEqual(divide(unsafeFromString("6"), unsafeFromString("0")), none())
+ * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("3")), Option.some(BigDecimal.unsafeFromString("2")))
+ * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("4")), Option.some(BigDecimal.unsafeFromString("1.5")))
+ * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("0")), Option.none())
  *
  * @since 2.0.0
  * @category math
@@ -556,7 +555,7 @@ export const greaterThanOrEqualTo: {
  * @param maximum - The `maximum` value to check.
  *
  * @example
- * import * as BigDecimal from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  *
  * const between = BigDecimal.between({
  *   minimum: BigDecimal.unsafeFromString("1"),
@@ -593,7 +592,7 @@ export const between: {
  * @param maximum - The upper end of the range.
  *
  * @example
- * import * as BigDecimal from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  *
  * const clamp = BigDecimal.clamp({
  *   minimum: BigDecimal.unsafeFromString("1"),
@@ -715,12 +714,11 @@ export const negate = (n: BigDecimal): BigDecimal => make(-n.value, n.scale)
  * @param divisor - The divisor.
  *
  * @example
- * import { remainder, unsafeFromString } from "effect/BigDecimal"
- * import { some } from "effect/Option"
+ * import { BigDecimal, Option } from "effect"
  *
- * assert.deepStrictEqual(remainder(unsafeFromString("2"), unsafeFromString("2")), some(unsafeFromString("0")))
- * assert.deepStrictEqual(remainder(unsafeFromString("3"), unsafeFromString("2")), some(unsafeFromString("1")))
- * assert.deepStrictEqual(remainder(unsafeFromString("-4"), unsafeFromString("2")), some(unsafeFromString("0")))
+ * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("2"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("0")))
+ * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("3"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("1")))
+ * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("-4"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("0")))
  *
  * @since 2.0.0
  * @category math
@@ -832,12 +830,11 @@ export const fromNumber = (n: number): BigDecimal => {
  * @param s - The `string` to parse.
  *
  * @example
- * import { fromString, make } from "effect/BigDecimal"
- * import { some, none } from "effect/Option"
+ * import { BigDecimal, Option } from "effect"
  *
- * assert.deepStrictEqual(fromString("123"), some(make(123n, 0)))
- * assert.deepStrictEqual(fromString("123.456"), some(make(123456n, 3)))
- * assert.deepStrictEqual(fromString("123.abc"), none())
+ * assert.deepStrictEqual(BigDecimal.fromString("123"), Option.some(BigDecimal.make(123n, 0)))
+ * assert.deepStrictEqual(BigDecimal.fromString("123.456"), Option.some(BigDecimal.make(123456n, 3)))
+ * assert.deepStrictEqual(BigDecimal.fromString("123.abc"), Option.none())
  *
  * @since 2.0.0
  * @category constructors

package/src/BigInt.ts

@@ -40,7 +40,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)
  *
@@ -59,7 +59,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)
  *
@@ -78,7 +78,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)
  *
@@ -102,11 +102,10 @@ export const subtract: {
  * @param that - The divisor operand.
  *
  * @example
- * import { divide } from 'effect/BigInt'
- * import { some, none } from 'effect/Option'
+ * import { BigInt, Option } from "effect"
  *
- * assert.deepStrictEqual(divide(6n, 3n), some(2n))
- * assert.deepStrictEqual(divide(6n, 0n), none())
+ * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+ * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
  *
  * @category math
  * @since 2.0.0
@@ -131,7 +130,7 @@ export const divide: {
  * @param that - The divisor operand.
  *
  * @example
- * import { unsafeDivide } from 'effect/BigInt'
+ * import { unsafeDivide } from "effect/BigInt"
  *
  * assert.deepStrictEqual(unsafeDivide(6n, 3n), 2n)
  * assert.deepStrictEqual(unsafeDivide(6n, 4n), 1n)
@@ -150,7 +149,7 @@ export const unsafeDivide: {
  * @param n - A `bigint` to be incremented.
  *
  * @example
- * import { increment } from 'effect/BigInt'
+ * import { increment } from "effect/BigInt"
  *
  * assert.deepStrictEqual(increment(2n), 3n)
  *
@@ -165,7 +164,7 @@ export const increment = (n: bigint): bigint => n + bigint1
  * @param n - A `bigint` to be decremented.
  *
  * @example
- * import { decrement } from 'effect/BigInt'
+ * import { decrement } from "effect/BigInt"
  *
  * assert.deepStrictEqual(decrement(3n), 2n)
  *
@@ -193,7 +192,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)
@@ -214,7 +213,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)
@@ -235,7 +234,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)
@@ -256,7 +255,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)
@@ -278,7 +277,7 @@ export const greaterThanOrEqualTo: {
  * @param maximum - The `maximum` value to check.
  *
  * @example
- * import * as BigInt from 'effect/BigInt'
+ * import { BigInt } from "effect"
  *
  * const between = BigInt.between({ minimum: 0n, maximum: 5n })
  *
@@ -312,7 +311,7 @@ export const between: {
  * @param maximum - The upper end of the range.
  *
  * @example
- * import * as BigInt from 'effect/BigInt'
+ * import { BigInt } from "effect"
  *
  * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
  *
@@ -340,7 +339,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)
  *
@@ -358,7 +357,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)
  *
@@ -375,7 +374,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)
@@ -392,7 +391,7 @@ export const sign = (n: bigint): Ordering => Order(n, bigint0)
  * @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)
@@ -410,7 +409,7 @@ export const abs = (n: bigint): bigint => (n < bigint0 ? -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)
@@ -438,7 +437,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)
@@ -458,7 +457,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)
@@ -487,13 +486,12 @@ export const unsafeSqrt = (n: bigint): bigint => {
  * @param n - The `bigint` to determine the square root of.
  *
  * @example
- * import { sqrt } from 'effect/BigInt'
- * import * as Option from 'effect/Option'
+ * import { BigInt, Option } from "effect"
  *
- * assert.deepStrictEqual(sqrt(4n), Option.some(2n))
- * assert.deepStrictEqual(sqrt(9n), Option.some(3n))
- * assert.deepStrictEqual(sqrt(16n), Option.some(4n))
- * assert.deepStrictEqual(sqrt(-1n), Option.none())
+ * assert.deepStrictEqual(BigInt.sqrt(4n), Option.some(2n))
+ * assert.deepStrictEqual(BigInt.sqrt(9n), Option.some(3n))
+ * assert.deepStrictEqual(BigInt.sqrt(16n), Option.some(4n))
+ * assert.deepStrictEqual(BigInt.sqrt(-1n), Option.none())
  *
  * @category math
  * @since 2.0.0
@@ -507,7 +505,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)
  *
@@ -528,7 +526,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)
  *
@@ -556,12 +554,11 @@ export const multiplyAll = (collection: Iterable<bigint>): bigint => {
  * @param b - The `bigint` to be converted to a `number`.
  *
  * @example
- * import { toNumber } from "effect/BigInt"
- * import { Option } from "effect"
+ * import { BigInt as BI, Option } from "effect"
  *
- * assert.deepStrictEqual(toNumber(BigInt(42)), Option.some(42))
- * assert.deepStrictEqual(toNumber(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), Option.none())
- * assert.deepStrictEqual(toNumber(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), Option.none())
+ * assert.deepStrictEqual(BI.toNumber(BigInt(42)), Option.some(42))
+ * assert.deepStrictEqual(BI.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), Option.none())
+ * assert.deepStrictEqual(BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), Option.none())
  *
  * @category conversions
  * @since 2.0.0
@@ -582,12 +579,11 @@ export const toNumber = (b: bigint): Option.Option<number> => {
  * @param s - The string to be converted to a `bigint`.
  *
  * @example
- * import { fromString } from "effect/BigInt"
- * import { Option } from "effect"
+ * import { BigInt as BI, Option } from "effect"
  *
- * assert.deepStrictEqual(fromString("42"), Option.some(BigInt(42)))
- * assert.deepStrictEqual(fromString(" "), Option.none())
- * assert.deepStrictEqual(fromString("a"), Option.none())
+ * assert.deepStrictEqual(BI.fromString("42"), Option.some(BigInt(42)))
+ * assert.deepStrictEqual(BI.fromString(" "), Option.none())
+ * assert.deepStrictEqual(BI.fromString("a"), Option.none())
  *
  * @category conversions
  * @since 2.4.12
@@ -612,12 +608,11 @@ export const fromString = (s: string): Option.Option<bigint> => {
  * @param n - The number to be converted to a `bigint`.
  *
  * @example
- * import { fromNumber } from "effect/BigInt"
- * import { Option } from "effect"
+ * import { BigInt as BI, Option } from "effect"
  *
- * assert.deepStrictEqual(fromNumber(42), Option.some(BigInt(42)))
- * assert.deepStrictEqual(fromNumber(Number.MAX_SAFE_INTEGER + 1), Option.none())
- * assert.deepStrictEqual(fromNumber(Number.MIN_SAFE_INTEGER - 1), Option.none())
+ * assert.deepStrictEqual(BI.fromNumber(42), Option.some(BigInt(42)))
+ * assert.deepStrictEqual(BI.fromNumber(Number.MAX_SAFE_INTEGER + 1), Option.none())
+ * assert.deepStrictEqual(BI.fromNumber(Number.MIN_SAFE_INTEGER - 1), Option.none())
  *
  * @category conversions
  * @since 2.4.12

package/src/Boolean.ts

@@ -17,7 +17,7 @@ import * as predicate from "./Predicate.js"
  * @param input - The value to test.
  *
  * @example
- * import { isBoolean } from 'effect/Boolean'
+ * import { isBoolean } from "effect/Boolean"
  *
  * assert.deepStrictEqual(isBoolean(true), true)
  * assert.deepStrictEqual(isBoolean("true"), false)
@@ -36,9 +36,9 @@ export const isBoolean: (input: unknown) => input is boolean = predicate.isBoole
  * @param onTrue - a lazy evaluation function that will be executed when the `value` is `true`.
  *
  * @example
- * import * as B from "effect/Boolean"
+ * import { Boolean } from "effect"
  *
- * assert.deepStrictEqual(B.match(true, { onFalse: () => "It's false!", onTrue: () => "It's true!" }), "It's true!")
+ * assert.deepStrictEqual(Boolean.match(true, { onFalse: () => "It's false!", onTrue: () => "It's true!" }), "It's true!")
  *
  * @category pattern matching
  * @since 2.0.0
@@ -73,7 +73,7 @@ export const Order: order.Order<boolean> = order.boolean
  * Negates the given boolean: `!self`
  *
  * @example
- * import { not } from 'effect/Boolean'
+ * import { not } from "effect/Boolean"
  *
  * assert.deepStrictEqual(not(true), false)
  * assert.deepStrictEqual(not(false), true)
@@ -87,7 +87,7 @@ export const not = (self: boolean): boolean => !self
  * Combines two boolean using AND: `self && that`.
  *
  * @example
- * import { and } from 'effect/Boolean'
+ * import { and } from "effect/Boolean"
  *
  * assert.deepStrictEqual(and(true, true), true)
  * assert.deepStrictEqual(and(true, false), false)
@@ -106,7 +106,7 @@ export const and: {
  * Combines two boolean using NAND: `!(self && that)`.
  *
  * @example
- * import { nand } from 'effect/Boolean'
+ * import { nand } from "effect/Boolean"
  *
  * assert.deepStrictEqual(nand(true, true), false)
  * assert.deepStrictEqual(nand(true, false), true)
@@ -125,7 +125,7 @@ export const nand: {
  * Combines two boolean using OR: `self || that`.
  *
  * @example
- * import { or } from 'effect/Boolean'
+ * import { or } from "effect/Boolean"
  *
  * assert.deepStrictEqual(or(true, true), true)
  * assert.deepStrictEqual(or(true, false), true)
@@ -144,7 +144,7 @@ export const or: {
  * Combines two booleans using NOR: `!(self || that)`.
  *
  * @example
- * import { nor } from 'effect/Boolean'
+ * import { nor } from "effect/Boolean"
  *
  * assert.deepStrictEqual(nor(true, true), false)
  * assert.deepStrictEqual(nor(true, false), false)
@@ -163,7 +163,7 @@ export const nor: {
  * Combines two booleans using XOR: `(!self && that) || (self && !that)`.
  *
  * @example
- * import { xor } from 'effect/Boolean'
+ * import { xor } from "effect/Boolean"
  *
  * assert.deepStrictEqual(xor(true, true), false)
  * assert.deepStrictEqual(xor(true, false), true)
@@ -182,7 +182,7 @@ export const xor: {
  * Combines two booleans using EQV (aka XNOR): `!xor(self, that)`.
  *
  * @example
- * import { eqv } from 'effect/Boolean'
+ * import { eqv } from "effect/Boolean"
  *
  * assert.deepStrictEqual(eqv(true, true), true)
  * assert.deepStrictEqual(eqv(true, false), false)
@@ -201,7 +201,7 @@ export const eqv: {
  * Combines two booleans using an implication: `(!self || that)`.
  *
  * @example
- * import { implies } from 'effect/Boolean'
+ * import { implies } from "effect/Boolean"
  *
  * assert.deepStrictEqual(implies(true, true), true)
  * assert.deepStrictEqual(implies(true, false), false)
@@ -222,7 +222,7 @@ export const implies: {
  * @param collection - An iterable collection of booleans.
  *
  * @example
- * import { every } from 'effect/Boolean'
+ * import { every } from "effect/Boolean"
  *
  * assert.deepStrictEqual(every([true, true, true]), true)
  * assert.deepStrictEqual(every([true, false, true]), false)
@@ -244,7 +244,7 @@ export const every = (collection: Iterable<boolean>): boolean => {
  * @param collection - An iterable collection of booleans.
  *
  * @example
- * import { some } from 'effect/Boolean'
+ * import { some } from "effect/Boolean"
  *
  * assert.deepStrictEqual(some([true, false, true]), true)
  * assert.deepStrictEqual(some([false, false, false]), false)

package/src/Brand.ts

@@ -196,7 +196,7 @@ export const errors: (...errors: Array<Brand.BrandErrors>) => Brand.BrandErrors
  * @param onFailure - Takes the unbranded value that did not pass the `refinement` predicate and returns a `BrandErrors`.
  *
  * @example
- * import * as Brand from "effect/Brand"
+ * import { Brand } from "effect"
  *
  * type Int = number & Brand.Brand<"Int">
  *
@@ -247,7 +247,7 @@ export function refined<A extends Brand<any>>(
  * If you also want to perform some validation, see {@link refined}.
  *
  * @example
- * import * as Brand from "effect/Brand"
+ * import { Brand } from "effect"
  *
  * type UserId = number & Brand.Brand<"UserId">
  *
@@ -275,7 +275,7 @@ export const nominal = <A extends Brand<any>>(): Brand.Constructor<
  * This API is useful when you want to validate that the input data passes multiple brand validators.
  *
  * @example
- * import * as Brand from "effect/Brand"
+ * import { Brand } from "effect"
  *
  * type Int = number & Brand.Brand<"Int">
  * const Int = Brand.refined<Int>(

package/src/Chunk.ts

@@ -551,7 +551,7 @@ export const dropWhile: {
  * If either chunk is non-empty, the result is also a non-empty chunk.
  *
  * @example
- * import * as Chunk from "effect/Chunk"
+ * import { Chunk } from "effect"
  *
  * assert.deepStrictEqual(
  *   Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray),
@@ -575,7 +575,7 @@ export const prependAll: {
  * If either chunk is non-empty, the result is also a non-empty chunk.
  *
  * @example
- * import * as Chunk from "effect/Chunk"
+ * import { Chunk } from "effect"
  *
  * assert.deepStrictEqual(
  *   Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray),
@@ -866,7 +866,7 @@ export declare namespace Chunk {
  * If the input chunk is non-empty, the resulting chunk will also be non-empty.
  *
  * @example
- * import * as Chunk from "effect/Chunk"
+ * import { Chunk } from "effect"
  *
  * assert.deepStrictEqual(
  *   Chunk.map(Chunk.make(1, 2), (n) => n + 1),