effect 2.0.0-next.44 → 2.0.0-next.46

package/src/Struct.ts

@@ -0,0 +1,151 @@
+/**
+ * This module provides utility functions for working with structs in TypeScript.
+ *
+ * @since 2.0.0
+ */
+
+import * as Equivalence from "./Equivalence"
+import { dual } from "./Function"
+import * as order from "./Order"
+
+/**
+ * Create a new object by picking properties of an existing object.
+ *
+ * @example
+ * import { pick } from "effect/Struct"
+ * import { pipe } from "effect/Function"
+ *
+ * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, pick("a", "b")), { a: "a", b: 1 })
+ *
+ * @since 2.0.0
+ */
+export const pick = <S, Keys extends readonly [keyof S, ...Array<keyof S>]>(
+  ...keys: Keys
+) =>
+(s: S): { [K in Keys[number]]: S[K] } => {
+  const out: any = {}
+  for (const k of keys) {
+    out[k] = s[k]
+  }
+  return out
+}
+
+/**
+ * Create a new object by omitting properties of an existing object.
+ *
+ * @example
+ * import { omit } from "effect/Struct"
+ * import { pipe } from "effect/Function"
+ *
+ * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, omit("c")), { a: "a", b: 1 })
+ *
+ * @since 2.0.0
+ */
+export const omit = <S, Keys extends readonly [keyof S, ...Array<keyof S>]>(
+  ...keys: Keys
+) =>
+(s: S): { [K in Exclude<keyof S, Keys[number]>]: S[K] } => {
+  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
+ * import { getEquivalence } from "effect/Struct"
+ * import * as S from "effect/String"
+ * import * as N from "effect/Number"
+ *
+ * const PersonEquivalence = getEquivalence({
+ *   name: S.Equivalence,
+ *   age: N.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 PartialTransform<O> = Partial<{ [K in keyof O]: (a: O[K]) => unknown }>
+
+type Transformed<O, T extends PartialTransform<O>> =
+  & unknown
+  & {
+    [K in keyof O]: K extends keyof T ? T[K] extends (...a: any) => any ? ReturnType<T[K]> : O[K] : O[K]
+  }
+
+/**
+ * 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.
+ *
+ * @example
+ * import { evolve } from 'effect/Struct'
+ * import { pipe } from 'effect/Function'
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     { a: 'a', b: 1, c: 3 },
+ *     evolve({
+ *       a: (a) => a.length,
+ *       b: (b) => b * 2
+ *     })
+ *   ),
+ *   { a: 1, b: 2, c: 3 }
+ * )
+ *
+ * @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>
+} = dual(
+  2,
+  <O, T extends PartialTransform<O>>(
+    obj: O,
+    t: T
+  ): unknown & 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
+  }
+)

package/src/SubscriptionRef.ts

@@ -0,0 +1,273 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect"
+import * as internal from "./internal/subscriptionRef"
+import type * as Option from "./Option"
+import type { Pipeable } from "./Pipeable"
+import type * as PubSub from "./PubSub"
+import * as Ref from "./Ref"
+import type * as Stream from "./Stream"
+import * as Synchronized from "./SynchronizedRef"
+
+/**
+ * @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<A> extends SubscriptionRef.Variance<A>, Synchronized.SynchronizedRef<A>, Pipeable {
+  /** @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<never, never, A>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace SubscriptionRef {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<A> {
+    readonly [SubscriptionRefTypeId]: {
+      readonly _A: (_: never) => A
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const get: <A>(self: SubscriptionRef<A>) => Effect.Effect<never, never, A> = internal.get
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndSet: {
+  <A>(value: A): (self: SubscriptionRef<A>) => Effect.Effect<never, never, A>
+  <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<never, never, A>
+} = Ref.getAndSet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdate: {
+  <A>(f: (a: A) => A): (self: SubscriptionRef<A>) => Effect.Effect<never, never, A>
+  <A>(self: SubscriptionRef<A>, f: (a: A) => A): Effect.Effect<never, never, A>
+} = Ref.getAndUpdate
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdateEffect: {
+  <A, R, E>(f: (a: A) => Effect.Effect<R, E, A>): (self: SubscriptionRef<A>) => Effect.Effect<R, E, A>
+  <A, R, E>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A>
+} = Synchronized.getAndUpdateEffect
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdateSome: {
+  <A>(pf: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<never, never, A>
+  <A>(self: SubscriptionRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<never, never, A>
+} = Ref.getAndUpdateSome
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdateSomeEffect: {
+  <A, R, E>(
+    pf: (a: A) => Option.Option<Effect.Effect<R, E, A>>
+  ): (self: SubscriptionRef<A>) => Effect.Effect<R, E, A>
+  <A, R, E>(
+    self: SubscriptionRef<A>,
+    pf: (a: A) => Option.Option<Effect.Effect<R, E, A>>
+  ): Effect.Effect<R, E, A>
+} = Synchronized.getAndUpdateSomeEffect
+
+/**
+ * Creates a new `SubscriptionRef` with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <A>(value: A) => Effect.Effect<never, never, 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<never, never, B>
+  <A, B>(self: SubscriptionRef<A>, f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B>
+} = internal.modify
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const modifyEffect: {
+  <A, R, E, B>(f: (a: A) => Effect.Effect<R, E, readonly [B, A]>): (self: SubscriptionRef<A>) => Effect.Effect<R, E, B>
+  <A, R, E, B>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<R, E, readonly [B, A]>): Effect.Effect<R, E, B>
+} = 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<never, never, B>
+  <A, B>(
+    self: SubscriptionRef<A>,
+    fallback: B,
+    pf: (a: A) => Option.Option<readonly [B, A]>
+  ): Effect.Effect<never, never, 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<R, E, readonly [B, A]>>
+  ): (self: SubscriptionRef<A>) => Effect.Effect<R, E, B>
+  <A, B, R, E>(
+    self: SubscriptionRef<A>,
+    fallback: B,
+    pf: (a: A) => Option.Option<Effect.Effect<R, E, readonly [B, A]>>
+  ): Effect.Effect<R, E, B>
+} = Synchronized.modifySomeEffect
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const set: {
+  <A>(value: A): (self: SubscriptionRef<A>) => Effect.Effect<never, never, void>
+  <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<never, never, void>
+} = internal.set
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const setAndGet: {
+  <A>(value: A): (self: SubscriptionRef<A>) => Effect.Effect<never, never, A>
+  <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<never, never, A>
+} = Ref.setAndGet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const update: {
+  <A>(f: (a: A) => A): (self: SubscriptionRef<A>) => Effect.Effect<never, never, void>
+  <A>(self: SubscriptionRef<A>, f: (a: A) => A): Effect.Effect<never, never, void>
+} = Ref.update
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateEffect: {
+  <A, R, E>(f: (a: A) => Effect.Effect<R, E, A>): (self: SubscriptionRef<A>) => Effect.Effect<R, E, void>
+  <A, R, E>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<R, E, A>): Effect.Effect<R, E, void>
+} = Synchronized.updateEffect
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateAndGet: {
+  <A>(f: (a: A) => A): (self: SubscriptionRef<A>) => Effect.Effect<never, never, A>
+  <A>(self: SubscriptionRef<A>, f: (a: A) => A): Effect.Effect<never, never, A>
+} = Ref.updateAndGet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateAndGetEffect: {
+  <A, R, E>(f: (a: A) => Effect.Effect<R, E, A>): (self: SubscriptionRef<A>) => Effect.Effect<R, E, A>
+  <A, R, E>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A>
+} = Synchronized.updateAndGetEffect
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSome: {
+  <A>(f: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<never, never, void>
+  <A>(self: SubscriptionRef<A>, f: (a: A) => Option.Option<A>): Effect.Effect<never, never, void>
+} = Ref.updateSome
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSomeEffect: {
+  <A, R, E>(
+    pf: (a: A) => Option.Option<Effect.Effect<R, E, A>>
+  ): (self: SubscriptionRef<A>) => Effect.Effect<R, E, void>
+  <A, R, E>(
+    self: SubscriptionRef<A>,
+    pf: (a: A) => Option.Option<Effect.Effect<R, E, A>>
+  ): Effect.Effect<R, E, void>
+} = Synchronized.updateSomeEffect
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSomeAndGet: {
+  <A>(pf: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<never, never, A>
+  <A>(self: SubscriptionRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<never, never, A>
+} = Ref.updateSomeAndGet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSomeAndGetEffect: {
+  <A, R, E>(
+    pf: (a: A) => Option.Option<Effect.Effect<R, E, A>>
+  ): (self: SubscriptionRef<A>) => Effect.Effect<R, E, A>
+  <A, R, E>(
+    self: SubscriptionRef<A>,
+    pf: (a: A) => Option.Option<Effect.Effect<R, E, A>>
+  ): Effect.Effect<R, E, A>
+} = Synchronized.updateSomeAndGetEffect

package/src/Supervisor.ts

@@ -0,0 +1,239 @@
+/**
+ * A `Supervisor<T>` is allowed to supervise the launching and termination of
+ * fibers, producing some visible value of type `T` from the supervision.
+ *
+ * @since 2.0.0
+ */
+import type * as Context from "./Context"
+import type * as Effect from "./Effect"
+import type * as Exit from "./Exit"
+import type * as Fiber from "./Fiber"
+import * as core from "./internal/core"
+import * as circular from "./internal/layer/circular"
+import * as internal from "./internal/supervisor"
+import type * as Layer from "./Layer"
+import type * as MutableRef from "./MutableRef"
+import type * as Option from "./Option"
+import type * as SortedSet from "./SortedSet"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const SupervisorTypeId: unique symbol = internal.SupervisorTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type SupervisorTypeId = typeof SupervisorTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Supervisor<T> extends Supervisor.Variance<T> {
+  /**
+   * Returns an `Effect` that succeeds with the value produced by this
+   * supervisor. This value may change over time, reflecting what the supervisor
+   * produces as it supervises fibers.
+   */
+  value(): Effect.Effect<never, never, T>
+
+  /**
+   * Supervises the start of a `Fiber`.
+   */
+  onStart<R, E, A>(
+    context: Context.Context<R>,
+    effect: Effect.Effect<R, E, A>,
+    parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
+    fiber: Fiber.RuntimeFiber<E, A>
+  ): void
+
+  /**
+   * Supervises the end of a `Fiber`.
+   */
+  onEnd<E, A>(value: Exit.Exit<E, A>, fiber: Fiber.RuntimeFiber<E, A>): void
+
+  /**
+   * Supervises the execution of an `Effect` by a `Fiber`.
+   */
+  onEffect<E, A>(fiber: Fiber.RuntimeFiber<E, A>, effect: Effect.Effect<any, any, any>): void
+
+  /**
+   * Supervises the suspension of a computation running within a `Fiber`.
+   */
+  onSuspend<E, A>(fiber: Fiber.RuntimeFiber<E, A>): void
+
+  /**
+   * Supervises the resumption of a computation running within a `Fiber`.
+   */
+  onResume<E, A>(fiber: Fiber.RuntimeFiber<E, A>): void
+
+  /**
+   * Maps this supervisor to another one, which has the same effect, but whose
+   * value has been transformed by the specified function.
+   */
+  map<B>(f: (a: T) => B): Supervisor<B>
+
+  /**
+   * Returns a new supervisor that performs the function of this supervisor, and
+   * the function of the specified supervisor, producing a tuple of the outputs
+   * produced by both supervisors.
+   */
+  zip<A>(right: Supervisor<A>): Supervisor<readonly [T, A]>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace Supervisor {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<T> {
+    readonly [SupervisorTypeId]: {
+      readonly _T: (_: never) => T
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const addSupervisor: <A>(supervisor: Supervisor<A>) => Layer.Layer<never, never, never> = circular.addSupervisor
+
+/**
+ * Creates a new supervisor that tracks children in a set.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fibersIn: (
+  ref: MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>
+) => Effect.Effect<never, never, Supervisor<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>> = internal.fibersIn
+
+/**
+ * Creates a new supervisor that constantly yields effect when polled
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromEffect: <A>(effect: Effect.Effect<never, never, A>) => Supervisor<A> = internal.fromEffect
+
+/**
+ * A supervisor that doesn't do anything in response to supervision events.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const none: Supervisor<void> = internal.none
+
+/**
+ * Creates a new supervisor that tracks children in a set.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const track: Effect.Effect<never, never, Supervisor<Array<Fiber.RuntimeFiber<any, any>>>> = internal.track
+
+/**
+ * Unsafely creates a new supervisor that tracks children in a set.
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+export const unsafeTrack: () => Supervisor<Array<Fiber.RuntimeFiber<any, any>>> = internal.unsafeTrack
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export abstract class AbstractSupervisor<T> implements Supervisor<T> {
+  /**
+   * @since 2.0.0
+   */
+  abstract value(): Effect.Effect<never, never, T>
+
+  /**
+   * @since 2.0.0
+   */
+  onStart<R, E, A>(
+    _context: Context.Context<R>,
+    _effect: Effect.Effect<R, E, A>,
+    _parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
+    _fiber: Fiber.RuntimeFiber<E, A>
+  ): void {
+    //
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  onEnd<E, A>(
+    _value: Exit.Exit<E, A>,
+    _fiber: Fiber.RuntimeFiber<E, A>
+  ): void {
+    //
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  onEffect<E, A>(
+    _fiber: Fiber.RuntimeFiber<E, A>,
+    _effect: Effect.Effect<any, any, any>
+  ): void {
+    //
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  onSuspend<E, A>(
+    _fiber: Fiber.RuntimeFiber<E, A>
+  ): void {
+    //
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  onResume<E, A>(
+    _fiber: Fiber.RuntimeFiber<E, A>
+  ): void {
+    //
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  map<B>(f: (a: T) => B): Supervisor<B> {
+    return new internal.ProxySupervisor(this, () => core.map(this.value(), f))
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  zip<A>(
+    right: Supervisor<A>
+  ): Supervisor<readonly [T, A]> {
+    return new internal.Zip(this, right)
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  onRun<E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<E, A>): X {
+    return execution()
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  readonly [SupervisorTypeId]: {
+    _T: (_: never) => never
+  } = internal.supervisorVariance
+}

package/src/Symbol.ts

@@ -0,0 +1,28 @@
+/**
+ * @since 2.0.0
+ */
+
+import * as equivalence from "./Equivalence"
+import * as predicate from "./Predicate"
+
+/**
+ * Tests if a value is a `symbol`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isSymbol } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isSymbol(Symbol.for("a")), true)
+ * assert.deepStrictEqual(isSymbol("a"), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isSymbol: (u: unknown) => u is symbol = predicate.isSymbol
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const Equivalence: equivalence.Equivalence<symbol> = equivalence.symbol