Options
All
  • Public
  • Public/Protected
  • All
Menu

Package env

@typed/env

A data-type for environment-dependent computations.

Index

Namespaces

Interfaces

Type aliases

Variables

Functions

Type aliases

CapabilitiesOf

CapabilitiesOf<A>: A extends Env<infer R, any> ? R : never

Extracts the capabilities required to satisfy an environment

Type parameters

  • A

LazyResume

LazyResume<A>: { resume: (cb: (value: A) => Disposable) => Disposable; type: "lazy" }

Type parameters

  • A

Type declaration

  • Readonly resume: (cb: (value: A) => Disposable) => Disposable
      • (cb: (value: A) => Disposable): Disposable

      • Parameters

        • cb: (value: A) => Disposable
            • (value: A): Disposable

            • Parameters

              • value: A

              Returns Disposable

        Returns Disposable

  • Readonly type: "lazy"

Provide

Provide<E, C>: [keyof Omit<CapabilitiesOf<E>, keyof C>] extends [never] ? Pure<ValueOf<E>> : Env<Omit<CapabilitiesOf<E>, keyof C>, ValueOf<E>>

Type parameters

ValueOf

ValueOf<A>: A extends Env<any, infer R> ? R : A extends Pure<infer R> ? R : never

Get the return value of an Env

Type parameters

  • A

ValueResume

ValueResume<A>: { type: "value"; value: A }

Type parameters

  • A

Type declaration

  • Readonly type: "value"
  • Readonly value: A

Variables

Const chain

chain: { <A, E1, B, E2>(fn: (value: A) => Env<E1, B>, env: Env<E2, A>): Env<E1 & E2, B>; <A, E1, B>(fn: (value: A) => Env<E1, B>): <E2>(env: Env<E2, A>) => Env<E1 & E2, B> } = curry(__chain) as {<A, E1, B, E2>(fn: (value: A) => Env<E1, B>, env: Env<E2, A>): Env<E1 & E2, B><A, E1, B>(fn: (value: A) => Env<E1, B>): <E2>(env: Env<E2, A>) => Env<E1 & E2, B>}

Type declaration

    • <A, E1, B, E2>(fn: (value: A) => Env<E1, B>, env: Env<E2, A>): Env<E1 & E2, B>
    • <A, E1, B>(fn: (value: A) => Env<E1, B>): <E2>(env: Env<E2, A>) => Env<E1 & E2, B>

    • Type parameters

      • A

      • E1

      • B

      • E2

      Parameters

      • fn: (value: A) => Env<E1, B>
          • (value: A): Env<E1, B>

          • Parameters

            • value: A

            Returns Env<E1, B>

      • env: Env<E2, A>

      Returns Env<E1 & E2, B>

    • Type parameters

      • A

      • E1

      • B

      Parameters

      • fn: (value: A) => Env<E1, B>
          • (value: A): Env<E1, B>

          • Parameters

            • value: A

            Returns Env<E1, B>

      Returns <E2>(env: Env<E2, A>) => Env<E1 & E2, B>

        • <E2>(env: Env<E2, A>): Env<E1 & E2, B>

        • Type parameters

          • E2

          Parameters

          • env: Env<E2, A>

          Returns Env<E1 & E2, B>

Const runEnv

runEnv: { <A, B>(fn: (value: B) => Disposable, resources: A, env: Env<A, B>): Disposable; <A, B>(fn: (value: B) => Disposable, resources: A): (env: Env<A, B>) => Disposable; <B>(fn: (value: B) => Disposable): { <A>(resources: A, env: Env<A, B>): Disposable; <A>(resources: A): (env: Env<A, B>) => Disposable } } = curry(<A extends {}, B>(fn: (value: B) => Disposable, resources: A, env: Env<A, B>): Disposable =>Resume.run(fn, env(resources)),) as {<A extends {}, B>(fn: (value: B) => Disposable, resources: A, env: Env<A, B>): Disposable<A extends {}, B>(fn: (value: B) => Disposable, resources: A): (env: Env<A, B>) => Disposable<B>(fn: (value: B) => Disposable): {<A extends {}>(resources: A, env: Env<A, B>): Disposable<A extends {}>(resources: A): (env: Env<A, B>) => Disposable}}

Type declaration

    • <A, B>(fn: (value: B) => Disposable, resources: A, env: Env<A, B>): Disposable
    • <A, B>(fn: (value: B) => Disposable, resources: A): (env: Env<A, B>) => Disposable
    • <B>(fn: (value: B) => Disposable): { <A>(resources: A, env: Env<A, B>): Disposable; <A>(resources: A): (env: Env<A, B>) => Disposable }

    • Type parameters

      • A: {}

      • B

      Parameters

      • fn: (value: B) => Disposable
          • (value: B): Disposable

          • Parameters

            • value: B

            Returns Disposable

      • resources: A
      • env: Env<A, B>

      Returns Disposable

    • Type parameters

      • A: {}

      • B

      Parameters

      • fn: (value: B) => Disposable
          • (value: B): Disposable

          • Parameters

            • value: B

            Returns Disposable

      • resources: A

      Returns (env: Env<A, B>) => Disposable

        • (env: Env<A, B>): Disposable

        • Parameters

          • env: Env<A, B>

          Returns Disposable

    • Type parameters

      • B

      Parameters

      • fn: (value: B) => Disposable
          • (value: B): Disposable

          • Parameters

            • value: B

            Returns Disposable

      Returns { <A>(resources: A, env: Env<A, B>): Disposable; <A>(resources: A): (env: Env<A, B>) => Disposable }

        • <A>(resources: A, env: Env<A, B>): Disposable
        • <A>(resources: A): (env: Env<A, B>) => Disposable

        • Type parameters

          • A: {}

          Parameters

          • resources: A
          • env: Env<A, B>

          Returns Disposable

        • Type parameters

          • A: {}

          Parameters

          • resources: A

          Returns (env: Env<A, B>) => Disposable

            • (env: Env<A, B>): Disposable

            • Parameters

              • env: Env<A, B>

              Returns Disposable

Const runPure

runPure: { <A>(f: (value: A) => Disposable, pure: Pure<A>): Disposable; <A>(f: (value: A) => Disposable): (pure: Pure<A>) => Disposable } = curry(function runPure<A>(f: (value: A) => Disposable, pure: Pure<A>): Disposable {return runEnv(f, {}, pure)})

Runs a Pure Env with the given callback

param

:: (a -> Disposable) Callback for pure Value

param

:: Pure Pure to run

returns

:: Disposable

Type declaration

    • Type parameters

      • A

      Parameters

      • f: (value: A) => Disposable
          • (value: A): Disposable

          • Parameters

            • value: A

            Returns Disposable

      • pure: Pure<A>

      Returns Disposable

    • Type parameters

      • A

      Parameters

      • f: (value: A) => Disposable
          • (value: A): Disposable

          • Parameters

            • value: A

            Returns Disposable

      Returns (pure: Pure<A>) => Disposable

        • (pure: Pure<A>): Disposable

        • Parameters

          Returns Disposable

Functions

Const execPure

  • execPure(pure: Pure<any>): Disposable

provide

  • provide<E, C>(env: E, capabilities: C): Provide<E, C>

withEnv

Generated using TypeDoc