@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.1

package/src/Struct.ts

@@ -0,0 +1,243 @@
+/**
+ * This module provides utility functions for working with structs in TypeScript.
+ *
+ * @since 2.0.0
+ */
+
+import * as Equivalence from "./Equivalence.js"
+import { dual } from "./Function.js"
+import * as order from "./Order.js"
+import * as Predicate from "./Predicate.js"
+import type { MatchRecord, Simplify } from "./Types.js"
+
+/**
+ * Create a new object by picking properties of an existing object.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { pipe, Struct } from "effect"
+ *
+ * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, Struct.pick("a", "b")), { a: "a", b: 1 })
+ * assert.deepStrictEqual(Struct.pick({ a: "a", b: 1, c: true }, "a", "b"), { a: "a", b: 1 })
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const pick: {
+  <Keys extends Array<PropertyKey>>(
+    ...keys: Keys
+  ): <S extends { [K in Keys[number]]?: any }>(
+    s: S
+  ) => MatchRecord<S, { [K in Keys[number]]?: S[K] }, Simplify<Pick<S, Keys[number]>>>
+  <S extends object, Keys extends Array<keyof S>>(
+    s: S,
+    ...keys: Keys
+  ): MatchRecord<S, { [K in Keys[number]]?: S[K] }, Simplify<Pick<S, Keys[number]>>>
+} = dual(
+  (args) => Predicate.isObject(args[0]),
+  <S extends object, Keys extends Array<keyof S>>(s: S, ...keys: Keys) => {
+    const out: any = {}
+    for (const k of keys) {
+      if (k in s) {
+        out[k] = (s as any)[k]
+      }
+    }
+    return out
+  }
+)
+
+/**
+ * Create a new object by omitting properties of an existing object.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { pipe, Struct } from "effect"
+ *
+ * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, Struct.omit("c")), { a: "a", b: 1 })
+ * assert.deepStrictEqual(Struct.omit({ a: "a", b: 1, c: true }, "c"), { a: "a", b: 1 })
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const omit: {
+  <Keys extends Array<PropertyKey>>(
+    ...keys: Keys
+  ): <S extends { [K in Keys[number]]?: any }>(s: S) => Simplify<Omit<S, Keys[number]>>
+  <S extends object, Keys extends Array<keyof S>>(
+    s: S,
+    ...keys: Keys
+  ): Simplify<Omit<S, Keys[number]>>
+} = dual(
+  (args) => Predicate.isObject(args[0]),
+  <S extends object, Keys extends Array<keyof S>>(s: S, ...keys: Keys) => {
+    const out: any = { ...s }
+    for (const k of keys) {
+      delete out[k]
+    }
+    return out
+  }
+)
+
+/**
+ * Given a struct of `Equivalence`s returns a new `Equivalence` that compares values of a struct
+ * by applying each `Equivalence` to the corresponding property of the struct.
+ *
+ * Alias of {@link Equivalence.struct}.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Struct, String, Number } from "effect"
+ *
+ * const PersonEquivalence = Struct.getEquivalence({
+ *   name: String.Equivalence,
+ *   age: Number.Equivalence
+ * })
+ *
+ * assert.deepStrictEqual(
+ *   PersonEquivalence({ name: "John", age: 25 }, { name: "John", age: 25 }),
+ *   true
+ * )
+ * assert.deepStrictEqual(
+ *   PersonEquivalence({ name: "John", age: 25 }, { name: "John", age: 40 }),
+ *   false
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const getEquivalence: <R extends Record<string, Equivalence.Equivalence<any>>>(
+  isEquivalents: R
+) => Equivalence.Equivalence<
+  { readonly [K in keyof R]: [R[K]] extends [Equivalence.Equivalence<infer A>] ? A : never }
+> = Equivalence.struct
+
+/**
+ * This function creates and returns a new `Order` for a struct of values based on the given `Order`s
+ * for each property in the struct.
+ *
+ * Alias of {@link order.struct}.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+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 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]
+  }
+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 original value for that key.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { pipe, Struct } from "effect"
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     { a: 'a', b: 1, c: 3 },
+ *     Struct.evolve({
+ *       a: (a) => a.length,
+ *       b: (b) => b * 2
+ *     })
+ *   ),
+ *   { a: 1, b: 2, c: 3 }
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const evolve: {
+  <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>(obj: O, t: PartialTransform<O, T>): Transformed<O, T> => {
+    const out = { ...obj }
+    for (const k in t) {
+      if (Object.prototype.hasOwnProperty.call(obj, k)) {
+        // @ts-expect-error
+        out[k] = t[k](obj[k])
+      }
+    }
+    return out as any
+  }
+)
+
+/**
+ * Retrieves the value associated with the specified key from a struct.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { pipe, Struct } from "effect"
+ *
+ * const value = pipe({ a: 1, b: 2 }, Struct.get("a"))
+ *
+ * assert.deepStrictEqual(value, 1)
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const get =
+  <K extends PropertyKey>(key: K) => <S extends { [P in K]?: any }>(s: S): MatchRecord<S, S[K] | undefined, S[K]> =>
+    s[key]
+
+/**
+ * Retrieves the object keys that are strings in a typed manner
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Struct } from "effect"
+ *
+ * const symbol: unique symbol = Symbol()
+ *
+ * const value = {
+ *   a: 1,
+ *   b: 2,
+ *   [symbol]: 3
+ * }
+ *
+ * const keys: Array<"a" | "b"> = Struct.keys(value)
+ *
+ * assert.deepStrictEqual(keys, ["a", "b"])
+ * ```
+ *
+ * @since 3.6.0
+ */
+export const keys = <T extends {}>(o: T): Array<(keyof T) & string> => Object.keys(o) as Array<(keyof T) & string>
+
+/**
+ * Retrieves the entries (key-value pairs) of an object, where keys are strings,
+ * in a type-safe manner. Symbol keys are excluded from the result.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Struct } from "effect"
+ *
+ * const c = Symbol("c")
+ * const value = { a: "foo", b: 1, [c]: true }
+ *
+ * const entries: Array<["a" | "b", string | number]> = Struct.entries(value)
+ *
+ * assert.deepStrictEqual(entries, [["a", "foo"], ["b", 1]])
+ * ```
+ *
+ * @since 3.17.0
+ */
+export const entries = <const R>(obj: R): Array<[keyof R & string, R[keyof R & string]]> =>
+  Object.entries(obj as any) as any

package/src/Subscribable.ts

@@ -0,0 +1,100 @@
+/**
+ * @since 2.0.0
+ */
+import * as Effect from "./Effect.js"
+import { dual } from "./Function.js"
+import { pipeArguments } from "./Pipeable.js"
+import { hasProperty } from "./Predicate.js"
+import * as Readable from "./Readable.js"
+import * as Stream from "./Stream.js"
+import type { NoInfer } from "./Types.js"
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = Symbol.for("effect/Subscribable")
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Subscribable<A, E = never, R = never> extends Readable.Readable<A, E, R> {
+  readonly [TypeId]: TypeId
+  readonly changes: Stream.Stream<A, E, R>
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> => hasProperty(u, TypeId)
+
+const Proto: Omit<Subscribable<any>, "get" | "changes"> = {
+  [Readable.TypeId]: Readable.TypeId,
+  [TypeId]: TypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make = <A, E, R>(options: {
+  readonly get: Effect.Effect<A, E, R>
+  readonly changes: Stream.Stream<A, E, R>
+}): Subscribable<A, E, R> => Object.assign(Object.create(Proto), options)
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const map: {
+  <A, B>(f: (a: NoInfer<A>) => B): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E, R>
+  <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R>
+} = dual(2, <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R> =>
+  make({
+    get: Effect.map(self.get, f),
+    changes: Stream.map(self.changes, f)
+  }))
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const mapEffect: {
+  <A, B, E2, R2>(
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E | E2, R | R2>
+  <A, E, R, B, E2, R2>(
+    self: Subscribable<A, E, R>,
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): Subscribable<B, E | E2, R | R2>
+} = dual(2, <A, E, R, B, E2, R2>(
+  self: Subscribable<A, E, R>,
+  f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+): Subscribable<B, E | E2, R | R2> =>
+  make({
+    get: Effect.flatMap(self.get, f),
+    changes: Stream.mapEffect(self.changes, f)
+  }))
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unwrap = <A, E, R, E1, R1>(
+  effect: Effect.Effect<Subscribable<A, E, R>, E1, R1>
+): Subscribable<A, E | E1, R | R1> =>
+  make({
+    get: Effect.flatMap(effect, (s) => s.get),
+    changes: Stream.unwrap(Effect.map(effect, (s) => s.changes))
+  })

package/src/SubscriptionRef.ts

@@ -0,0 +1,298 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect.js"
+import * as internal from "./internal/subscriptionRef.js"
+import type * as Option from "./Option.js"
+import type * as PubSub from "./PubSub.js"
+import * as Ref from "./Ref.js"
+import type * as Stream from "./Stream.js"
+import type { Subscribable } from "./Subscribable.js"
+import * as Synchronized from "./SynchronizedRef.js"
+import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const SubscriptionRefTypeId: unique symbol = internal.SubscriptionRefTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId
+
+/**
+ * A `SubscriptionRef<A>` is a `Ref` that can be subscribed to in order to
+ * receive the current value as well as all changes to the value.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface SubscriptionRef<in out A>
+  extends SubscriptionRef.Variance<A>, Synchronized.SynchronizedRef<A>, Subscribable<A>
+{
+  /** @internal */
+  readonly ref: Ref.Ref<A>
+  /** @internal */
+  readonly pubsub: PubSub.PubSub<A>
+  /** @internal */
+  readonly semaphore: Effect.Semaphore
+  /**
+   * A stream containing the current value of the `Ref` as well as all changes
+   * to that value.
+   */
+  readonly changes: Stream.Stream<A>
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: SubscriptionRefUnify<this>
+  readonly [Unify.ignoreSymbol]?: SubscriptionRefUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface SubscriptionRefUnify<A extends { [Unify.typeSymbol]?: any }>
+  extends Synchronized.SynchronizedRefUnify<A>
+{
+  SubscriptionRef?: () => Extract<A[Unify.typeSymbol], SubscriptionRef<any>>
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface SubscriptionRefUnifyIgnore extends Synchronized.SynchronizedRefUnifyIgnore {
+  SynchronizedRef?: true
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace SubscriptionRef {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<in out A> {
+    readonly [SubscriptionRefTypeId]: {
+      readonly _A: Types.Invariant<A>
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const get: <A>(self: SubscriptionRef<A>) => Effect.Effect<A> = internal.get
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndSet: {
+  <A>(value: A): (self: SubscriptionRef<A>) => Effect.Effect<A>
+  <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<A>
+} = Ref.getAndSet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdate: {
+  <A>(f: (a: A) => A): (self: SubscriptionRef<A>) => Effect.Effect<A>
+  <A>(self: SubscriptionRef<A>, f: (a: A) => A): Effect.Effect<A>
+} = Ref.getAndUpdate
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdateEffect: {
+  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
+  <A, R, E>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
+} = Synchronized.getAndUpdateEffect
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdateSome: {
+  <A>(pf: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<A>
+  <A>(self: SubscriptionRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
+} = Ref.getAndUpdateSome
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdateSomeEffect: {
+  <A, R, E>(
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
+  <A, R, E>(
+    self: SubscriptionRef<A>,
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ): Effect.Effect<A, E, R>
+} = Synchronized.getAndUpdateSomeEffect
+
+/**
+ * Creates a new `SubscriptionRef` with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <A>(value: A) => Effect.Effect<SubscriptionRef<A>> = internal.make
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const modify: {
+  <A, B>(f: (a: A) => readonly [B, A]): (self: SubscriptionRef<A>) => Effect.Effect<B>
+  <A, B>(self: SubscriptionRef<A>, f: (a: A) => readonly [B, A]): Effect.Effect<B>
+} = internal.modify
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const modifyEffect: {
+  <B, A, E, R>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): (self: SubscriptionRef<A>) => Effect.Effect<B, E, R>
+  <A, B, E, R>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, E, R>
+} = internal.modifyEffect
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const modifySome: {
+  <B, A>(
+    fallback: B,
+    pf: (a: A) => Option.Option<readonly [B, A]>
+  ): (self: SubscriptionRef<A>) => Effect.Effect<B>
+  <A, B>(
+    self: SubscriptionRef<A>,
+    fallback: B,
+    pf: (a: A) => Option.Option<readonly [B, A]>
+  ): Effect.Effect<B>
+} = Ref.modifySome
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const modifySomeEffect: {
+  <A, B, R, E>(
+    fallback: B,
+    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
+  ): (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<B, E, R>
+  <A, B, R, E>(
+    self: Synchronized.SynchronizedRef<A>,
+    fallback: B,
+    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
+  ): Effect.Effect<B, E, R>
+} = Synchronized.modifySomeEffect
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const set: {
+  <A>(value: A): (self: SubscriptionRef<A>) => Effect.Effect<void>
+  <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<void>
+} = internal.set
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const setAndGet: {
+  <A>(value: A): (self: SubscriptionRef<A>) => Effect.Effect<A>
+  <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<A>
+} = Ref.setAndGet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const update: {
+  <A>(f: (a: A) => A): (self: SubscriptionRef<A>) => Effect.Effect<void>
+  <A>(self: SubscriptionRef<A>, f: (a: A) => A): Effect.Effect<void>
+} = Ref.update
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateEffect: {
+  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>
+  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<void, E, R>
+} = Synchronized.updateEffect
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateAndGet: {
+  <A>(f: (a: A) => A): (self: SubscriptionRef<A>) => Effect.Effect<A>
+  <A>(self: SubscriptionRef<A>, f: (a: A) => A): Effect.Effect<A>
+} = Ref.updateAndGet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateAndGetEffect: {
+  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
+  <A, R, E>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
+} = Synchronized.updateAndGetEffect
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSome: {
+  <A>(f: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<void>
+  <A>(self: SubscriptionRef<A>, f: (a: A) => Option.Option<A>): Effect.Effect<void>
+} = Ref.updateSome
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSomeEffect: {
+  <A, R, E>(
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ): (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>
+  <A, R, E>(
+    self: Synchronized.SynchronizedRef<A>,
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ): Effect.Effect<void, E, R>
+} = Synchronized.updateSomeEffect
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSomeAndGet: {
+  <A>(pf: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<A>
+  <A>(self: SubscriptionRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
+} = Ref.updateSomeAndGet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSomeAndGetEffect: {
+  <A, R, E>(
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
+  <A, R, E>(
+    self: SubscriptionRef<A>,
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ): Effect.Effect<A, E, R>
+} = Synchronized.updateSomeAndGetEffect