add pipeables

CHANGELOG.md

@@ -34,7 +34,7 @@
     - refactoring with the new `Schemable` interface (@gcanti)
     - add `interpreter` function (@gcanti)
 - **Internal**
-  - upgrade to `typescript@3.9.2` (@gcanti)
+  - upgrade to `typescript@3.9.3` (@gcanti)
 
 # 2.2.2
 

docs/modules/Codec.ts.md

@@ -23,6 +23,7 @@ Added in v2.2.3
 - [boolean](#boolean)
 - [codec](#codec)
 - [fromDecoder](#fromdecoder)
+- [imap](#imap)
 - [intersection](#intersection)
 - [lazy](#lazy)
 - [literal](#literal)
@@ -155,6 +156,16 @@ export declare function fromDecoder<A>(decoder: D.Decoder<A>): Codec<A, A>
 
 Added in v2.2.3
 
+# imap
+
+**Signature**
+
+```ts
+export declare const imap: <E, A, B>(f: (a: A) => B, g: (b: B) => A) => (fa: Codec<E, A>) => Codec<E, B>
+```
+
+Added in v2.2.3
+
 # intersection
 
 **Signature**

docs/modules/Decoder.ts.md

@@ -21,8 +21,6 @@ Added in v2.2.0
 - [UnknownRecord](#unknownrecord)
 - [alt](#alt)
 - [ap](#ap)
-- [apFirst](#apfirst)
-- [apSecond](#apsecond)
 - [array](#array)
 - [boolean](#boolean)
 - [decoder](#decoder)
@@ -143,26 +141,6 @@ export declare const ap: <A>(fa: Decoder<A>) => <B>(fab: Decoder<(a: A) => B>) =
 
 Added in v2.2.0
 
-# apFirst
-
-**Signature**
-
-```ts
-export declare const apFirst: <B>(fb: Decoder<B>) => <A>(fa: Decoder<A>) => Decoder<A>
-```
-
-Added in v2.2.0
-
-# apSecond
-
-**Signature**
-
-```ts
-export declare const apSecond: <B>(fb: Decoder<B>) => <A>(fa: Decoder<A>) => Decoder<B>
-```
-
-Added in v2.2.0
-
 # array
 
 **Signature**

docs/modules/JsonCodec.ts.md

@@ -18,6 +18,7 @@ Added in v2.2.3
 - [URI](#uri)
 - [array](#array)
 - [boolean](#boolean)
+- [imap](#imap)
 - [intersection](#intersection)
 - [jsonCodec](#jsoncodec)
 - [lazy](#lazy)
@@ -101,6 +102,16 @@ export declare const boolean: JsonCodec<boolean>
 
 Added in v2.2.3
 
+# imap
+
+**Signature**
+
+```ts
+export declare const imap: <A, B>(f: (a: A) => B, g: (b: B) => A) => (fa: JsonCodec<A>) => JsonCodec<B>
+```
+
+Added in v2.2.3
+
 # intersection
 
 **Signature**

src/Codec.ts

@@ -192,6 +192,19 @@ export function lazy<O, A>(id: string, f: () => Codec<O, A>): Codec<O, A> {
   return make(D.lazy(id, f), E.lazy(f))
 }
 
+// -------------------------------------------------------------------------------------
+// pipeables
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 2.2.3
+ */
+export const imap: <E, A, B>(f: (a: A) => B, g: (b: B) => A) => (fa: Codec<E, A>) => Codec<E, B> = (f, g) => (fa) =>
+  imap_(fa, f, g)
+
+const imap_: <E, A, B>(fa: Codec<E, A>, f: (a: A) => B, g: (b: B) => A) => Codec<E, B> = (fa, f, g) =>
+  make(D.decoder.map(fa, f), E.encoder.contramap(fa, g))
+
 // -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------
@@ -217,5 +230,5 @@ declare module 'fp-ts/lib/HKT' {
  */
 export const codec: Invariant2<URI> = {
   URI,
-  imap: (fa, f, g) => make(D.decoder.map(fa, f), E.encoder.contramap(fa, g))
+  imap: imap_
 }

src/Decoder.ts

@@ -5,7 +5,7 @@ import { Alternative1 } from 'fp-ts/lib/Alternative'
 import { Applicative1 } from 'fp-ts/lib/Applicative'
 import { Either, either, isLeft, isRight, left, mapLeft, right } from 'fp-ts/lib/Either'
 import { NonEmptyArray } from 'fp-ts/lib/NonEmptyArray'
-import { pipe, pipeable } from 'fp-ts/lib/pipeable'
+import { pipe } from 'fp-ts/lib/pipeable'
 import { Forest, Tree } from 'fp-ts/lib/Tree'
 import * as G from './Guard'
 import { Literal, memoize, Schemable1, WithRefinement1, WithUnion1, WithUnknownContainers1 } from './Schemable'
@@ -444,6 +444,37 @@ export function union<A extends ReadonlyArray<unknown>>(
   }
 }
 
+// -------------------------------------------------------------------------------------
+// pipeables
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 2.2.0
+ */
+export const alt: <A>(that: () => Decoder<A>) => (fa: Decoder<A>) => Decoder<A> = (that) => (fa) => alt_(fa, that)
+
+const alt_: <A>(fx: Decoder<A>, fy: () => Decoder<A>) => Decoder<A> = (fx, fy) => ({
+  decode: (u) => either.alt(fx.decode(u), () => fy().decode(u))
+})
+
+/**
+ * @since 2.2.0
+ */
+export const ap: <A>(fa: Decoder<A>) => <B>(fab: Decoder<(a: A) => B>) => Decoder<B> = (fa) => (fab) => ap_(fab, fa)
+
+const ap_: <A, B>(fab: Decoder<(a: A) => B>, fa: Decoder<A>) => Decoder<B> = (fab, fa) => ({
+  decode: (u) => either.ap(fab.decode(u), fa.decode(u))
+})
+
+/**
+ * @since 2.2.0
+ */
+export const map: <A, B>(f: (a: A) => B) => (fa: Decoder<A>) => Decoder<B> = (f) => (fa) => map_(fa, f)
+
+const map_: <A, B>(fa: Decoder<A>, f: (a: A) => B) => Decoder<B> = (fa, f) => ({
+  decode: (u) => either.map(fa.decode(u), f)
+})
+
 // -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------
@@ -474,18 +505,12 @@ export const decoder: Applicative1<URI> &
   WithUnion1<URI> &
   WithRefinement1<URI> = {
   URI,
-  map: (fa, f) => ({
-    decode: (u) => either.map(fa.decode(u), f)
-  }),
+  map: map_,
   of: (a) => ({
     decode: () => success(a)
   }),
-  ap: (fab, fa) => ({
-    decode: (u) => either.ap(fab.decode(u), fa.decode(u))
-  }),
-  alt: (fx, fy) => ({
-    decode: (u) => either.alt(fx.decode(u), () => fy().decode(u))
-  }),
+  ap: ap_,
+  alt: alt_,
   zero: () => never,
   literal,
   string,
@@ -505,28 +530,3 @@ export const decoder: Applicative1<URI> &
   union,
   refinement: refinement as WithRefinement1<URI>['refinement']
 }
-
-const { alt, ap, apFirst, apSecond, map } = pipeable(decoder)
-
-export {
-  /**
-   * @since 2.2.0
-   */
-  alt,
-  /**
-   * @since 2.2.0
-   */
-  ap,
-  /**
-   * @since 2.2.0
-   */
-  apFirst,
-  /**
-   * @since 2.2.0
-   */
-  apSecond,
-  /**
-   * @since 2.2.0
-   */
-  map
-}

src/Encoder.ts

@@ -160,6 +160,30 @@ export function lazy<O, A>(f: () => Encoder<O, A>): Encoder<O, A> {
   }
 }
 
+// -------------------------------------------------------------------------------------
+// pipeables
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 2.2.3
+ */
+export const contramap: <A, B>(f: (b: B) => A) => <E>(fa: Encoder<E, A>) => Encoder<E, B> = (f) => (fa) =>
+  encoder.contramap(fa, f)
+
+const contramap_: <E, A, B>(fa: Encoder<E, A>, f: (b: B) => A) => Encoder<E, B> = (fa, f) => ({
+  encode: (b) => fa.encode(f(b))
+})
+
+/**
+ * @since 2.2.3
+ */
+export const compose: <E, A>(ea: Encoder<E, A>) => <B>(ab: Encoder<A, B>) => Encoder<E, B> = (ea) => (ab) =>
+  encoder.compose(ab, ea)
+
+const compose_: <E, A, B>(ab: Encoder<A, B>, la: Encoder<E, A>) => Encoder<E, B> = (ab, ea) => ({
+  encode: (b) => ea.encode(ab.encode(b))
+})
+
 // -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------
@@ -185,23 +209,7 @@ declare module 'fp-ts/lib/HKT' {
  */
 export const encoder: Contravariant2<URI> & Category2<URI> = {
   URI,
-  contramap: (fa, f) => ({
-    encode: (b) => fa.encode(f(b))
-  }),
-  compose: (ab, ea) => ({
-    encode: (b) => ea.encode(ab.encode(b))
-  }),
+  contramap: contramap_,
+  compose: compose_,
   id
 }
-
-/**
- * @since 2.2.3
- */
-export const contramap: <A, B>(f: (b: B) => A) => <E>(fa: Encoder<E, A>) => Encoder<E, B> = (f) => (fa) =>
-  encoder.contramap(fa, f)
-
-/**
- * @since 2.2.3
- */
-export const compose: <E, A>(ea: Encoder<E, A>) => <B>(ab: Encoder<A, B>) => Encoder<E, B> = (ea) => (ab) =>
-  encoder.compose(ab, ea)

src/Eq.ts

@@ -148,6 +148,10 @@ export function lazy<A>(f: () => Eq<A>): Eq<A> {
   }
 }
 
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+
 /**
  * @since 2.2.2
  */

src/JsonCodec.ts

@@ -129,6 +129,15 @@ export const sum: <T extends string>(
  */
 export const lazy: <A>(id: string, f: () => JsonCodec<A>) => JsonCodec<A> = C.lazy
 
+// -------------------------------------------------------------------------------------
+// pipeables
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 2.2.3
+ */
+export const imap: <A, B>(f: (a: A) => B, g: (b: B) => A) => (fa: JsonCodec<A>) => JsonCodec<B> = C.imap
+
 // -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------

src/JsonEncoder.ts

@@ -103,6 +103,15 @@ export const sum: <T extends string>(
  */
 export const lazy: <A>(f: () => JsonEncoder<A>) => JsonEncoder<A> = E.lazy
 
+// -------------------------------------------------------------------------------------
+// pipeables
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 2.2.3
+ */
+export const contramap: <A, B>(f: (b: B) => A) => (fa: JsonEncoder<A>) => JsonEncoder<B> = E.contramap
+
 // -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------
@@ -143,8 +152,3 @@ export const jsonEncoder: Contravariant1<URI> & Schemable1<URI> = {
   sum,
   lazy: (_, f) => lazy(f)
 }
-
-/**
- * @since 2.2.3
- */
-export const contramap: <A, B>(f: (b: B) => A) => (fa: JsonEncoder<A>) => JsonEncoder<B> = E.contramap

test/Codec.ts

@@ -3,6 +3,7 @@ import { left, right } from 'fp-ts/lib/Either'
 import * as C from '../src/Codec'
 import * as D from '../src/Decoder'
 import * as G from '../src/Guard'
+import { pipe } from 'fp-ts/lib/pipeable'
 
 const NumberFromString: C.Codec<string, number> = C.make(
   D.parse(D.string, (s) => {
@@ -42,6 +43,18 @@ describe('Codec', () => {
     })
   })
 
+  it('imap', () => {
+    const codec = pipe(
+      C.string,
+      C.imap(
+        (s) => ({ value: s }),
+        ({ value }) => value
+      )
+    )
+    assert.deepStrictEqual(codec.decode('a'), right({ value: 'a' }))
+    assert.deepStrictEqual(codec.encode({ value: 'a' }), 'a')
+  })
+
   describe('withExpected', () => {
     describe('decode', () => {
       it('should, return the provided expected', () => {