NonEmptyProduct: rename bindKind to andThenBind

fp-ts · Nov 3, 2022 · 07b7061 · 07b7061
1 parent 374b1c2
commit 07b7061
Show file tree

Hide file tree

Showing 6 changed files with 17 additions and 12 deletions.
diff --git a/.changeset/red-timers-sing.md b/.changeset/red-timers-sing.md
@@ -0,0 +1,5 @@
+---
+"@fp-ts/core": patch
+---
+
+NonEmptyProduct: rename bindKind to andThenBind
diff --git a/Overview.md b/Overview.md
@@ -378,7 +378,7 @@ Extends:
 | productManyComposition | `F<G<A>>`, `Iterable<F<G<A>>>` | `F<G<[A, ...ReadonlyArray<A>]>>` |
 | nonEmptyTuple          | `[F<A>, F<B>, ...]`            | `F<[A, B, ...]>`                 |
 | nonEmptyStruct         | `{ a: F<A>, b: F<B>, ... }`    | `F<{ a: A, b: B, ... }>`         |
-| bindKind               | `F<A>`, `name: string`, `F<B>` | `F<A & { [name]: B }>`           |
+| andThenBind            | `F<A>`, `name: string`, `F<B>` | `F<A & { [name]: B }>`           |
 | productFlatten         | `F<A>`, `F<B>`                 | `F<[...A, B]>`                   |
 
 ### NonEmptyTraversable

diff --git a/src/typeclass/NonEmptyProduct.ts b/src/typeclass/NonEmptyProduct.ts
@@ -97,7 +97,7 @@ export const productMany = <F extends TypeLambda>(
 /**
  * @since 1.0.0
  */
-export const bindKind = <F extends TypeLambda>(F: NonEmptyProduct<F>) =>
+export const andThenBind = <F extends TypeLambda>(F: NonEmptyProduct<F>) =>
   <N extends string, A extends object, R2, O2, E2, B>(
     name: Exclude<N, keyof A>,
     fb: Kind<F, R2, O2, E2, B>

diff --git a/test/test-data/Option.ts b/test/test-data/Option.ts
@@ -1063,11 +1063,11 @@ export const bind: <N extends string, A extends object, B>(
  * @category do notation
  * @since 1.0.0
  */
-export const bindOption: <N extends string, A extends object, B>(
+export const andThenBind: <N extends string, A extends object, B>(
   name: Exclude<N, keyof A>,
   fb: Option<B>
 ) => (self: Option<A>) => Option<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }> =
-  nonEmptyProduct.bindKind(NonEmptyApplicative)
+  nonEmptyProduct.andThenBind(NonEmptyApplicative)
 
 // -------------------------------------------------------------------------------------
 // tuple sequencing

diff --git a/test/test-data/Predicate.ts b/test/test-data/Predicate.ts
@@ -67,13 +67,13 @@ export const Product: product.Product<PredicateTypeLambda> = {
     }
 }
 
-export const bindPredicate: <N extends string, A extends object, B>(
+export const andThenBind: <N extends string, A extends object, B>(
   name: Exclude<N, keyof A>,
   fb: Predicate<B>
 ) => (
   self: Predicate<A>
 ) => Predicate<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }> = nonEmptyProduct
-  .bindKind(
+  .andThenBind(
     NonEmptyProduct
   )
 

diff --git a/test/typeclass/NonEmptyProduct.ts b/test/typeclass/NonEmptyProduct.ts
@@ -138,18 +138,18 @@ describe("NonEmptyProduct", () => {
     })
   })
 
-  describe("bindKind", () => {
+  describe("andThenBind", () => {
     it("Covariant (Option)", () => {
-      const bindKind = _.bindKind(O.Applicative)
-      U.deepStrictEqual(pipe(O.some({ a: 1 }), bindKind("b", O.none)), O.none)
-      U.deepStrictEqual(pipe(O.some({ a: 1 }), bindKind("b", O.some(2))), O.some({ a: 1, b: 2 }))
+      const andThenBind = _.andThenBind(O.Applicative)
+      U.deepStrictEqual(pipe(O.some({ a: 1 }), andThenBind("b", O.none)), O.none)
+      U.deepStrictEqual(pipe(O.some({ a: 1 }), andThenBind("b", O.some(2))), O.some({ a: 1, b: 2 }))
     })
 
     it("Contravariant (Predicate)", () => {
       const p = pipe(
         P.Do,
-        P.bindPredicate("x", P.isString),
-        P.bindPredicate("y", P.isNumber)
+        P.andThenBind("x", P.isString),
+        P.andThenBind("y", P.isNumber)
       )
       U.deepStrictEqual(p({ x: "a", y: 1 }), true)
       U.deepStrictEqual(p({ x: "a", y: "x" }), false)