effect 3.3.0 → 3.3.2

package/src/Option.ts

@@ -1057,7 +1057,7 @@ export const filter: {
  * @since 2.0.0
  */
 export const getEquivalence = <A>(isEquivalent: Equivalence.Equivalence<A>): Equivalence.Equivalence<Option<A>> =>
-  Equivalence.make((x, y) => x === y || (isNone(x) ? isNone(y) : isNone(y) ? false : isEquivalent(x.value, y.value)))
+  Equivalence.make((x, y) => isNone(x) ? isNone(y) : isNone(y) ? false : isEquivalent(x.value, y.value))
 
 /**
  * The `Order` instance allows `Option` values to be compared with

package/src/Predicate.ts

@@ -799,15 +799,55 @@ export const eqv: {
 } = dual(2, <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A> => (a) => self(a) === that(a))
 
 /**
+ * Represents the logical implication combinator for predicates. In formal
+ * logic, the implication operator `->` denotes that if the first proposition
+ * (antecedent) is true, then the second proposition (consequent) must also be
+ * true. In simpler terms, `p implies q` can be interpreted as "if p then q". If
+ * the first predicate holds, then the second predicate must hold
+ * for the given context.
+ *
+ * In practical terms within TypeScript, `p implies q` is equivalent to `!p || (p && q)`.
+ *
+ * Note that if the antecedent is `false`, the result is `true` by default
+ * because the outcome of the consequent cannot be determined.
+ *
+ * This function is useful in situations where you need to enforce rules or
+ * constraints that are contingent on certain conditions.
+ * It proves especially helpful in defining property tests.
+ *
+ * The example below illustrates the transitive property of order using the
+ * `implies` function. In simple terms, if `a <= b` and `b <= c`, then `a <= c`
+ * must be true.
+ *
+ * @example
+ * import { Predicate } from "effect"
+ *
+ * type Triple = {
+ *   readonly a: number
+ *   readonly b: number
+ *   readonly c: number
+ * }
+ *
+ * const transitivity = Predicate.implies(
+ *   // antecedent
+ *   (input: Triple) => input.a <= input.b && input.b <= input.c,
+ *   // consequent
+ *   (input: Triple) => input.a <= input.c
+ * )
+ *
+ * assert.equal(transitivity({ a: 1, b: 2, c: 3 }), true)
+ * // antecedent is `false`, so the result is `true`
+ * assert.equal(transitivity({ a: 1, b: 0, c: 0 }), true)
+ *
  * @category combinators
  * @since 2.0.0
  */
 export const implies: {
-  <A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>
-  <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>
+  <A>(consequent: Predicate<A>): (antecedent: Predicate<A>) => Predicate<A>
+  <A>(antecedent: Predicate<A>, consequent: Predicate<A>): Predicate<A>
 } = dual(
   2,
-  <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A> => (a) => self(a) ? that(a) : true
+  <A>(antecedent: Predicate<A>, consequent: Predicate<A>): Predicate<A> => (a) => antecedent(a) ? consequent(a) : true
 )
 
 /**

package/src/Redacted.ts

@@ -1,4 +1,9 @@
 /**
+ * The Redacted module provides functionality for handling sensitive information
+ * securely within your application. By using the `Redacted` data type, you can
+ * ensure that sensitive values are not accidentally exposed in logs or error
+ * messages.
+ *
  * @since 3.3.0
  */
 import type * as Equal from "./Equal.js"
@@ -54,26 +59,75 @@ export declare namespace Redacted {
 export const isRedacted: (u: unknown) => u is Redacted<unknown> = redacted_.isRedacted
 
 /**
+ * This function creates a `Redacted<A>` instance from a given value `A`,
+ * securely hiding its content.
+ *
+ * @example
+ * import { Redacted } from "effect"
+ *
+ * const API_KEY = Redacted.make("1234567890")
+ *
  * @since 3.3.0
  * @category constructors
  */
 export const make: <A>(value: A) => Redacted<A> = redacted_.make
 
 /**
+ * Retrieves the original value from a `Redacted` instance. Use this function
+ * with caution, as it exposes the sensitive data.
+ *
+ * @example
+ * import { Redacted } from "effect"
+ *
+ * const API_KEY = Redacted.make("1234567890")
+ *
+ * assert.equal(Redacted.value(API_KEY), "1234567890")
+ *
  * @since 3.3.0
  * @category getters
  */
 export const value: <A>(self: Redacted<A>) => A = redacted_.value
 
 /**
+ * Erases the underlying value of a `Redacted` instance, rendering it unusable.
+ * This function is intended to ensure that sensitive data does not remain in
+ * memory longer than necessary.
+ *
+ * @example
+ * import { Redacted } from "effect"
+ *
+ * const API_KEY = Redacted.make("1234567890")
+ *
+ * assert.equal(Redacted.value(API_KEY), "1234567890")
+ *
+ * Redacted.unsafeWipe(API_KEY)
+ *
+ * assert.throws(() => Redacted.value(API_KEY), new Error("Unable to get redacted value"))
+ *
  * @since 3.3.0
  * @category unsafe
  */
 export const unsafeWipe: <A>(self: Redacted<A>) => boolean = redacted_.unsafeWipe
 
 /**
+ * Generates an equivalence relation for `Redacted<A>` values based on an
+ * equivalence relation for the underlying values `A`. This function is useful
+ * for comparing `Redacted` instances without exposing their contents.
+ *
+ * @example
+ * import { Redacted, Equivalence } from "effect"
+ *
+ * const API_KEY1 = Redacted.make("1234567890")
+ * const API_KEY2 = Redacted.make("1-34567890")
+ * const API_KEY3 = Redacted.make("1234567890")
+ *
+ * const equivalence = Redacted.getEquivalence(Equivalence.string)
+ *
+ * assert.equal(equivalence(API_KEY1, API_KEY2), false)
+ * assert.equal(equivalence(API_KEY1, API_KEY3), true)
+ *
  * @category equivalence
  * @since 3.3.0
  */
 export const getEquivalence = <A>(isEquivalent: Equivalence.Equivalence<A>): Equivalence.Equivalence<Redacted<A>> =>
-  Equivalence.make((x, y) => x === y || (isEquivalent(value(x), value(y))))
+  Equivalence.make((x, y) => isEquivalent(value(x), value(y)))

package/src/Stream.ts

@@ -93,9 +93,6 @@ export interface StreamUnifyIgnore extends Effect.EffectUnifyIgnore {
  */
 declare module "./Effect.js" {
   interface Effect<A, E, R> extends Stream<A, E, R> {}
-  interface EffectUnifyIgnore {
-    Stream?: true
-  }
 }
 
 /**

package/src/Struct.ts

@@ -119,14 +119,14 @@ export const getOrder: <R extends { readonly [x: string]: order.Order<any> }>(
   fields: R
 ) => order.Order<{ [K in keyof R]: [R[K]] extends [order.Order<infer A>] ? A : never }> = order.struct
 
-type PartialTransform<O> = Partial<{ [K in keyof O]: (a: O[K]) => unknown }>
-
-type Transformed<O, T extends PartialTransform<O>> =
+type Transformed<O, T> =
   & unknown
   & {
-    [K in keyof O]: K extends keyof T ? T[K] extends (...a: any) => any ? ReturnType<T[K]> : O[K] : O[K]
+    [K in keyof O]: K extends keyof T ? (T[K] extends (...a: any) => any ? ReturnType<T[K]> : O[K]) : O[K]
   }
-
+type PartialTransform<O, T> = {
+  [K in keyof T]: T[K] extends (a: O[K & keyof O]) => any ? T[K] : (a: O[K & keyof O]) => unknown
+}
 /**
  * Transforms the values of a Struct provided a transformation function for each key.
  * If no transformation function is provided for a key, it will return the origional value for that key.
@@ -148,16 +148,11 @@ type Transformed<O, T extends PartialTransform<O>> =
  * @since 2.0.0
  */
 export const evolve: {
-  <O, T extends PartialTransform<O>>(t: T): (
-    obj: O
-  ) => Transformed<O, T>
-  <O, T extends PartialTransform<O>>(obj: O, t: T): Transformed<O, T>
+  <O, T>(t: PartialTransform<O, T>): (obj: O) => Transformed<O, T>
+  <O, T>(obj: O, t: PartialTransform<O, T>): Transformed<O, T>
 } = dual(
   2,
-  <O, T extends PartialTransform<O>>(
-    obj: O,
-    t: T
-  ): unknown & Transformed<O, T> => {
+  <O, T>(obj: O, t: PartialTransform<O, T>): Transformed<O, T> => {
     const out = { ...obj }
     for (const k in t) {
       if (Object.prototype.hasOwnProperty.call(obj, k)) {

package/src/index.ts

@@ -615,6 +615,11 @@ export * as Record from "./Record.js"
 export * as RedBlackTree from "./RedBlackTree.js"
 
 /**
+ * The Redacted module provides functionality for handling sensitive information
+ * securely within your application. By using the `Redacted` data type, you can
+ * ensure that sensitive values are not accidentally exposed in logs or error
+ * messages.
+ *
  * @since 3.3.0
  */
 export * as Redacted from "./Redacted.js"

package/src/internal/cause.ts

@@ -1055,7 +1055,7 @@ export const spanToTrace = globalValue("effect/Tracer/spanToTrace", () => new We
 
 const prettyErrorStack = (message: string, stack: string, span?: Span | undefined): string => {
   const out: Array<string> = [message]
-  const lines = stack.split("\n")
+  const lines = stack.startsWith(message) ? stack.slice(message.length).split("\n") : stack.split("\n")
 
   for (let i = 1; i < lines.length; i++) {
     if (lines[i].includes("Generator.next")) {

package/src/internal/config.ts

@@ -180,8 +180,8 @@ export const boolean = (name?: string): Config.Config<boolean> => {
 }
 
 /** @internal */
-export const array = <A>(config: Config.Config<A>, name?: string): Config.Config<ReadonlyArray<A>> => {
-  return pipe(chunk(config, name), map(Chunk.toReadonlyArray))
+export const array = <A>(config: Config.Config<A>, name?: string): Config.Config<Array<A>> => {
+  return pipe(chunk(config, name), map(Chunk.toArray))
 }
 
 /** @internal */

package/src/internal/fiberRuntime.ts

@@ -1826,7 +1826,7 @@ export const all = <
     return allEither(effects, reconcile, options) as any
   }
 
-  return reconcile._tag === "Some"
+  return options?.discard !== true && reconcile._tag === "Some"
     ? core.map(
       forEach(effects, identity, options as any),
       reconcile.value

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.3.0"
+let moduleVersion = "3.3.2"
 
 export const getCurrentVersion = () => moduleVersion