effect 3.1.0 → 3.1.2

package/src/Trie.ts

@@ -44,8 +44,7 @@ export interface Trie<in out Value> extends Iterable<[string, Value]>, Equal, Pi
  * Creates an empty `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.empty<string>()
  *
@@ -61,8 +60,7 @@ export const empty: <V = never>() => Trie<V> = TR.empty
  * Creates a new `Trie` from an iterable collection of key/value pairs (e.g. `Array<[string, V]>`).
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const iterable: Array<readonly [string, number]> = [["call", 0], ["me", 1], ["mind", 2], ["mid", 3]]
  * const trie = Trie.fromIterable(iterable)
@@ -80,8 +78,7 @@ export const fromIterable: <V>(entries: Iterable<readonly [string, V]>) => Trie<
  * Constructs a new `Trie` from the specified entries (`[string, V]`).
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.make(["ca", 0], ["me", 1])
  *
@@ -99,7 +96,7 @@ export const make: <Entries extends Array<readonly [string, any]>>(
  * Insert a new entry in the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie1 = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0)
@@ -127,7 +124,7 @@ export const insert: {
  * The keys are returned in alphabetical order, regardless of insertion order.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("cab", 0),
@@ -149,7 +146,7 @@ export const keys: <V>(self: Trie<V>) => IterableIterator<string> = TR.keys
  * Values are ordered based on their key in alphabetical order, regardless of insertion order.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -171,7 +168,7 @@ export const values: <V>(self: Trie<V>) => IterableIterator<V> = TR.values
  * The entries are returned by keys in alphabetical order, regardless of insertion order.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -192,7 +189,7 @@ export const entries: <V>(self: Trie<V>) => IterableIterator<[string, V]> = TR.e
  * Equivalent to `Array.from(Trie.entries(trie))`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -212,7 +209,7 @@ export const toEntries = <V>(self: Trie<V>): Array<[string, V]> => Array.from(en
  * that have `prefix` as prefix (`prefix` included if it exists).
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("she", 0),
@@ -237,7 +234,7 @@ export const keysWithPrefix: {
  * that have `prefix` as prefix (`prefix` included if it exists).
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("she", 0),
@@ -264,7 +261,7 @@ export const valuesWithPrefix: {
  * that have `prefix` as prefix (`prefix` included if it exists).
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("she", 0),
@@ -289,7 +286,7 @@ export const entriesWithPrefix: {
  * that have `prefix` as prefix (`prefix` included if it exists).
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -314,8 +311,7 @@ export const toEntriesWithPrefix: {
  * that is a prefix of that `key` if it exists, `None` otherwise.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Option from "effect/Option"
+ * import { Trie, Option } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -340,7 +336,7 @@ export const longestPrefixOf: {
  * Returns the size of the `Trie` (number of entries in the `Trie`).
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("a", 0),
@@ -358,8 +354,7 @@ export const size: <V>(self: Trie<V>) => number = TR.size
  * Safely lookup the value for the specified key in the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Option from "effect/Option"
+ * import { Trie, Option } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -389,7 +384,7 @@ export const get: {
  * Check if the given key exists in the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -419,7 +414,7 @@ export const has: {
  * Checks if the `Trie` contains any entries.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>()
  * const trie1 = trie.pipe(Trie.insert("ma", 0))
@@ -439,7 +434,7 @@ export const isEmpty: <V>(self: Trie<V>) => boolean = TR.isEmpty
  * get a value from the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -460,8 +455,7 @@ export const unsafeGet: {
  * Remove the entry for the specified key in the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Option from "effect/Option"
+ * import { Trie, Option } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("call", 0),
@@ -489,7 +483,7 @@ export const remove: {
  * Reduce a state over the entries of the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -528,8 +522,7 @@ export const reduce: {
  * Maps over the entries of the `Trie` using the specified function.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -564,8 +557,7 @@ export const map: {
  * Filters entries out of a `Trie` using the specified predicate.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -600,9 +592,7 @@ export const filter: {
  * and filters out `None` values.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
- * import * as Option from "effect/Option"
+ * import { Trie, Equal, Option } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -637,9 +627,7 @@ export const filterMap: {
  * Filters out `None` values from a `Trie` of `Options`s.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
- * import * as Option from "effect/Option"
+ * import { Trie, Equal, Option } from "effect"
  *
  * const trie = Trie.empty<Option.Option<number>>().pipe(
  *   Trie.insert("shells", Option.some(0)),
@@ -663,7 +651,7 @@ export const compact: <A>(self: Trie<Option<A>>) => Trie<A> = TR.compact
  * Applies the specified function to the entries of the `Trie`.
  *
  * @example
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * let value = 0
  *
@@ -690,9 +678,7 @@ export const forEach: {
  * Updates the value of the specified key within the `Trie` if it exists.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
- * import * as Option from "effect/Option"
+ * import { Trie, Equal, Option } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -716,8 +702,7 @@ export const modify: {
  * Removes all entries in the `Trie` which have the specified keys.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),
@@ -742,8 +727,7 @@ export const removeMany: {
  * Insert multiple entries in the `Trie` at once.
  *
  * @example
- * import * as Trie from "effect/Trie"
- * import * as Equal from "effect/Equal"
+ * import { Trie, Equal } from "effect"
  *
  * const trie = Trie.empty<number>().pipe(
  *   Trie.insert("shells", 0),

package/src/Types.ts

@@ -7,7 +7,7 @@
 /**
  * Returns the tags in a type.
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res = Types.Tags<string | { _tag: "a" } | { _tag: "b" } > // "a" | "b"
  *
@@ -19,7 +19,7 @@ export type Tags<E> = E extends { _tag: string } ? E["_tag"] : never
 /**
  * Excludes the tagged object from the type.
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res = Types.ExcludeTag<string | { _tag: "a" } | { _tag: "b" }, "a"> // string | { _tag: "b" }
  *
@@ -32,7 +32,7 @@ export type ExcludeTag<E, K extends Tags<E>> = Exclude<E, { _tag: K }>
  * Extracts the type of the given tag.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res = Types.ExtractTag<{ _tag: "a", a: number } | { _tag: "b", b: number }, "b"> // { _tag: "b", b: number }
  *
@@ -54,7 +54,7 @@ export type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) ext
  * Simplifies the type signature of a type.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res = Types.Simplify<{ a: number } & { b: number }> // { a: number; b: number; }
  *
@@ -69,7 +69,7 @@ export type Simplify<A> = {
  * Determines if two types are equal.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res1 = Types.Equals<{ a: number }, { a: number }> // true
  * type Res2 = Types.Equals<{ a: number }, { b: number }> // false
@@ -86,7 +86,7 @@ export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
  * Determines if a record contains any of the given keys.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type Res1 = Types.Has<{ a: number }, "a" | "b"> // true
  * type Res2 = Types.Has<{ c: number }, "a" | "b"> // false
@@ -102,7 +102,7 @@ export type Has<A, Key extends string> = (Key extends infer K ? K extends keyof
  * Merges two object where the keys of the left object take precedence in the case of a conflict.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  * type MergeLeft = Types.MergeLeft<{ a: number, b: number; }, { a: string }> // { a: number; b: number; }
  *
  * @since 2.0.0
@@ -118,7 +118,7 @@ export type MergeLeft<K, H> = Simplify<
  * Merges two object where the keys of the right object take precedence in the case of a conflict.
  *
  * @example
- * import * as Types from "effect/Types"
+ * import type { Types } from "effect"
  * type MergeRight = Types.MergeRight<{ a: number, b: number; }, { a: string }> // { a: string; b: number; }
  *
  * @since 2.0.0
@@ -153,7 +153,7 @@ export type Concurrency = number | "unbounded" | "inherit"
  * Make all properties in `T` mutable. Supports arrays, tuples, and records as well.
  *
  * @example
- * import type * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type MutableStruct = Types.Mutable<{ readonly a: string; readonly b: number }> // { a: string; b: number; }
  *
@@ -174,7 +174,7 @@ export type Mutable<T> = {
  * Like `Types.Mutable`, but works recursively.
  *
  * @example
- * import type * as Types from "effect/Types"
+ * import type { Types } from "effect"
  *
  * type DeepMutableStruct = Types.DeepMutable<{
  *   readonly a: string;

package/src/Utils.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import { identity } from "./Function.js"
+import { globalValue } from "./GlobalValue.js"
 import type { Kind, TypeLambda } from "./HKT.js"
 import { getBugErrorMessage } from "./internal/errors.js"
 import { isNullable, isObject } from "./Predicate.js"
@@ -24,7 +25,7 @@ import type * as Types from "./Types.js"
  * @category symbols
  * @since 2.0.0
  */
-export const GenKindTypeId = Symbol.for("effect/Gen/GenKind")
+export const GenKindTypeId: unique symbol = Symbol.for("effect/Gen/GenKind")
 
 /**
  * @category symbols
@@ -716,7 +717,7 @@ function add64(
 /**
  * @since 3.0.6
  */
-export const YieldWrapTypeId = Symbol.for("effect/Utils/YieldWrap")
+export const YieldWrapTypeId: unique symbol = Symbol.for("effect/Utils/YieldWrap")
 
 /**
  * @since 3.0.6
@@ -746,3 +747,40 @@ export function yieldWrapGet<T>(self: YieldWrap<T>): T {
   }
   throw new Error(getBugErrorMessage("yieldWrapGet"))
 }
+
+/**
+ * Note: this is an experimental feature made available to allow custom matchers in tests, not to be directly used yet in user code
+ *
+ * @since 3.1.1
+ * @status experimental
+ * @category modifiers
+ */
+export const structuralRegionState = globalValue(
+  "effect/Utils/isStructuralRegion",
+  (): { enabled: boolean; tester: ((a: unknown, b: unknown) => boolean) | undefined } => ({
+    enabled: false,
+    tester: undefined
+  })
+)
+
+/**
+ * Note: this is an experimental feature made available to allow custom matchers in tests, not to be directly used yet in user code
+ *
+ * @since 3.1.1
+ * @status experimental
+ * @category modifiers
+ */
+export const structuralRegion = <A>(body: () => A, tester?: (a: unknown, b: unknown) => boolean): A => {
+  const current = structuralRegionState.enabled
+  const currentTester = structuralRegionState.tester
+  structuralRegionState.enabled = true
+  if (tester) {
+    structuralRegionState.tester = tester
+  }
+  try {
+    return body()
+  } finally {
+    structuralRegionState.enabled = current
+    structuralRegionState.tester = currentTester
+  }
+}

package/src/internal/core-effect.ts

@@ -25,12 +25,13 @@ import type * as Random from "../Random.js"
 import * as Ref from "../Ref.js"
 import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
-import type { MergeRecord, NoInfer } from "../Types.js"
+import type { NoInfer } from "../Types.js"
 import { yieldWrapGet } from "../Utils.js"
 import * as internalCause from "./cause.js"
 import { clockTag } from "./clock.js"
 import * as core from "./core.js"
 import * as defaultServices from "./defaultServices.js"
+import * as doNotation from "./doNotation.js"
 import * as fiberRefsPatch from "./fiberRefs/patch.js"
 import type { FiberRuntime } from "./fiberRuntime.js"
 import * as metricLabel from "./metric/label.js"
@@ -369,56 +370,39 @@ export const Do: Effect.Effect<{}> = core.succeed({})
 
 /* @internal */
 export const bind: {
-  <N extends string, K, A, E2, R2>(
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => Effect.Effect<A, E2, R2>
-  ): <E, R>(self: Effect.Effect<K, E, R>) => Effect.Effect<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
-  <K, E, R, N extends string, A, E2, R2>(
-    self: Effect.Effect<K, E, R>,
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => Effect.Effect<A, E2, R2>
-  ): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
-} = dual(3, <K, E, R, N extends string, A, E2, R2>(
-  self: Effect.Effect<K, E, R>,
-  tag: Exclude<N, keyof K>,
-  f: (_: K) => Effect.Effect<A, E2, R2>
-): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R> =>
-  core.flatMap(self, (k) =>
-    core.map(
-      f(k),
-      (a): MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: a } as any)
-    )))
+  <N extends string, A extends object, B, E2, R2>(
+    name: Exclude<N, keyof A>,
+    f: (a: A) => Effect.Effect<B, E2, R2>
+  ): <E1, R1>(
+    self: Effect.Effect<A, E1, R1>
+  ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E2 | E1, R2 | R1>
+  <A extends object, N extends string, E1, R1, B, E2, R2>(
+    self: Effect.Effect<A, E1, R1>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E1 | E2, R1 | R2>
+} = doNotation.bind<Effect.EffectTypeLambda>(core.map, core.flatMap)
 
 /* @internal */
 export const bindTo: {
-  <N extends string>(tag: N): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Record<N, A>, E, R>
-  <A, E, R, N extends string>(self: Effect.Effect<A, E, R>, tag: N): Effect.Effect<Record<N, A>, E, R>
-} = dual(
-  2,
-  <A, E, R, N extends string>(self: Effect.Effect<A, E, R>, tag: N): Effect.Effect<Record<N, A>, E, R> =>
-    core.map(self, (a) => ({ [tag]: a } as Record<N, A>))
-)
+  <N extends string>(name: N): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<{ [K in N]: A }, E, R>
+  <A, E, R, N extends string>(self: Effect.Effect<A, E, R>, name: N): Effect.Effect<{ [K in N]: A }, E, R>
+} = doNotation.bindTo<Effect.EffectTypeLambda>(core.map)
 
 /* @internal */
 export const let_: {
-  <N extends string, K, A>(
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => A
-  ): <E, R>(self: Effect.Effect<K, E, R>) => Effect.Effect<MergeRecord<K, { [k in N]: A }>, E, R>
-  <K, E, R, N extends string, A>(
-    self: Effect.Effect<K, E, R>,
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => A
-  ): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E, R>
-} = dual(3, <K, E, R, N extends string, A>(
-  self: Effect.Effect<K, E, R>,
-  tag: Exclude<N, keyof K>,
-  f: (_: K) => A
-): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E, R> =>
-  core.map(
-    self,
-    (k): MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: f(k) } as any)
-  ))
+  <N extends string, A extends object, B>(
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): <E, R>(
+    self: Effect.Effect<A, E, R>
+  ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
+  <A extends object, N extends string, E, R, B>(
+    self: Effect.Effect<A, E, R>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
+} = doNotation.let_<Effect.EffectTypeLambda>(core.map)
 
 /* @internal */
 export const dropUntil: {

package/src/internal/core.ts

@@ -197,10 +197,18 @@ class EffectPrimitiveFailure {
     this._tag = _op
   }
   [Equal.symbol](this: {}, that: unknown) {
-    return this === that
+    return exitIsExit(that) && that._op === "Failure" &&
+      // @ts-expect-error
+      Equal.equals(this.effect_instruction_i0, that.effect_instruction_i0)
   }
   [Hash.symbol](this: {}) {
-    return Hash.cached(this, Hash.random(this))
+    return pipe(
+      // @ts-expect-error
+      Hash.string(this._tag),
+      // @ts-expect-error
+      Hash.combine(Hash.hash(this.effect_instruction_i0)),
+      Hash.cached(this)
+    )
   }
   get cause() {
     return this.effect_instruction_i0
@@ -238,10 +246,18 @@ class EffectPrimitiveSuccess {
     this._tag = _op
   }
   [Equal.symbol](this: {}, that: unknown) {
-    return this === that
+    return exitIsExit(that) && that._op === "Success" &&
+      // @ts-expect-error
+      Equal.equals(this.effect_instruction_i0, that.effect_instruction_i0)
   }
   [Hash.symbol](this: {}) {
-    return Hash.cached(this, Hash.random(this))
+    return pipe(
+      // @ts-expect-error
+      Hash.string(this._tag),
+      // @ts-expect-error
+      Hash.combine(Hash.hash(this.effect_instruction_i0)),
+      Hash.cached(this)
+    )
   }
   get value() {
     return this.effect_instruction_i0

package/src/internal/doNotation.ts

@@ -0,0 +1,77 @@
+import { dual } from "../Function.js"
+import type { Kind, TypeLambda } from "../HKT.js"
+
+type Map<F extends TypeLambda> = {
+  <A, B>(f: (a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, B>
+  <R, O, E, A, B>(self: Kind<F, R, O, E, A>, f: (a: A) => B): Kind<F, R, O, E, B>
+}
+
+type FlatMap<F extends TypeLambda> = {
+  <A, R2, O2, E2, B>(
+    f: (a: A) => Kind<F, R2, O2, E2, B>
+  ): <R1, O1, E1>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O1 | O2, E1 | E2, B>
+  <R1, O1, E1, A, R2, O2, E2, B>(
+    self: Kind<F, R1, O1, E1, A>,
+    f: (a: A) => Kind<F, R2, O2, E2, B>
+  ): Kind<F, R1 & R2, O1 | O2, E1 | E2, B>
+}
+
+/** @internal */
+export const let_ = <F extends TypeLambda>(
+  map: Map<F>
+): {
+  <N extends string, A extends object, B>(
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): <R, O, E>(
+    self: Kind<F, R, O, E, A>
+  ) => Kind<F, R, O, E, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
+  <R, O, E, A extends object, N extends string, B>(
+    self: Kind<F, R, O, E, A>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): Kind<F, R, O, E, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
+} =>
+  dual(3, <R, O, E, A extends object, N extends string, B>(
+    self: Kind<F, R, O, E, A>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => B
+  ): Kind<F, R, O, E, { [K in keyof A | N]: K extends keyof A ? A[K] : B }> =>
+    map(self, (a) => Object.assign({}, a, { [name]: f(a) }) as any))
+
+/** @internal */
+export const bindTo = <F extends TypeLambda>(map: Map<F>): {
+  <N extends string>(
+    name: N
+  ): <R, O, E, A>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, { [K in N]: A }>
+  <R, O, E, A, N extends string>(
+    self: Kind<F, R, O, E, A>,
+    name: N
+  ): Kind<F, R, O, E, { [K in N]: A }>
+} =>
+  dual(2, <R, O, E, A, N extends string>(
+    self: Kind<F, R, O, E, A>,
+    name: N
+  ): Kind<F, R, O, E, { [K in N]: A }> => map(self, (a) => ({ [name]: a } as { [K in N]: A })))
+
+/** @internal */
+export const bind = <F extends TypeLambda>(map: Map<F>, flatMap: FlatMap<F>): {
+  <N extends string, A extends object, R2, O2, E2, B>(
+    name: Exclude<N, keyof A>,
+    f: (a: A) => Kind<F, R2, O2, E2, B>
+  ): <R1, O1, E1>(
+    self: Kind<F, R1, O1, E1, A>
+  ) => Kind<F, R1 & R2, O1 | O2, E1 | E2, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
+  <R1, O1, E1, A extends object, N extends string, R2, O2, E2, B>(
+    self: Kind<F, R1, O1, E1, A>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => Kind<F, R2, O2, E2, B>
+  ): Kind<F, R1 & R2, O1 | O2, E1 | E2, { [K in keyof A | N]: K extends keyof A ? A[K] : B }>
+} =>
+  dual(3, <R1, O1, E1, A, N extends string, R2, O2, E2, B>(
+    self: Kind<F, R1, O1, E1, A>,
+    name: Exclude<N, keyof A>,
+    f: (a: A) => Kind<F, R2, O2, E2, B>
+  ): Kind<F, R1 & R2, O1 | O2, E1 | E2, { [K in keyof A | N]: K extends keyof A ? A[K] : B }> =>
+    flatMap(self, (a) =>
+      map(f(a), (b) => Object.assign({}, a, { [name]: b }) as { [K in keyof A | N]: K extends keyof A ? A[K] : B })))