Add intersection decoder

Author: Elias Mulhall

src/combinators.ts

@@ -55,6 +55,8 @@ export function union(ad: Decoder<any>, bd: Decoder<any>, ...ds: Decoder<any>[])
   return Decoder.oneOf(ad, bd, ...ds);
 }
 
+export const intersection = Decoder.intersection;
+
 /** See `Decoder.withDefault` */
 export const withDefault: <A>(defaultValue: A, decoder: Decoder<A>) => Decoder<A> =
   Decoder.withDefault;

src/decoder.ts

@@ -439,6 +439,41 @@ export class Decoder<A> {
     return Decoder.oneOf(ad, bd, ...decoders);
   }
 
+  /**
+   * Combines 2-8 object decoders into a decoder for the intersection of all the objects.
+   *
+   * Example:
+   * ```
+   * interface Pet {
+   *   name: string;
+   *   maxLegs: number;
+   * }
+   *
+   * interface Cat extends Pet {
+   *   evil: boolean;
+   * }
+   *
+   * const petDecoder: Decoder<Pet> = object({name: string(), maxLegs: number()});
+   * const catDecoder: Decoder<Cat> = intersection(petDecoder, object({evil: boolean()}));
+   * ```
+   */
+  static intersection <A, B>(ad: Decoder<A>, bd: Decoder<B>): Decoder<A & B>; // prettier-ignore
+  static intersection <A, B, C>(ad: Decoder<A>, bd: Decoder<B>, cd: Decoder<C>): Decoder<A & B & C>; // prettier-ignore
+  static intersection <A, B, C, D>(ad: Decoder<A>, bd: Decoder<B>, cd: Decoder<C>, dd: Decoder<D>): Decoder<A & B & C & D>; // prettier-ignore
+  static intersection <A, B, C, D, E>(ad: Decoder<A>, bd: Decoder<B>, cd: Decoder<C>, dd: Decoder<D>, ed: Decoder<E>): Decoder<A & B & C & D & E>; // prettier-ignore
+  static intersection <A, B, C, D, E, F>(ad: Decoder<A>, bd: Decoder<B>, cd: Decoder<C>, dd: Decoder<D>, ed: Decoder<E>, fd: Decoder<F>): Decoder<A & B & C & D & E & F>; // prettier-ignore
+  static intersection <A, B, C, D, E, F, G>(ad: Decoder<A>, bd: Decoder<B>, cd: Decoder<C>, dd: Decoder<D>, ed: Decoder<E>, fd: Decoder<F>, gd: Decoder<G>): Decoder<A & B & C & D & E & F & G>; // prettier-ignore
+  static intersection <A, B, C, D, E, F, G, H>(ad: Decoder<A>, bd: Decoder<B>, cd: Decoder<C>, dd: Decoder<D>, ed: Decoder<E>, fd: Decoder<F>, gd: Decoder<G>, hd: Decoder<H>): Decoder<A & B & C & D & E & F & G & H>; // prettier-ignore
+  static intersection(ad: Decoder<any>, bd: Decoder<any>, ...ds: Decoder<any>[]): Decoder<any> {
+    return new Decoder((json: any) =>
+      [ad, bd, ...ds].reduce(
+        (acc: Result.Result<any, Partial<DecoderError>>, decoder) =>
+          Result.map2(Object.assign, acc, decoder.decode(json)),
+        Result.ok({})
+      )
+    );
+  }
+
   /**
    * Decoder that always succeeds with either the decoded value, or a fallback
    * default value.

src/index.ts

@@ -15,6 +15,7 @@ export {
   optional,
   oneOf,
   union,
+  intersection,
   withDefault,
   valueAt,
   succeed,

src/result.ts

@@ -105,6 +105,15 @@ export const successes = <A>(results: Result<A, any>[]): A[] =>
 export const map = <A, B, E>(f: (value: A) => B, r: Result<A, E>): Result<B, E> =>
   r.ok === true ? ok<B>(f(r.result)) : r;
 
+/**
+ * Apply `f` to the result of two `Ok`s, or pass an error through. If both
+ * `Result`s are errors then the first one is returned.
+ */
+export const map2 = <A, B, C, E>(f: (av: A, bv: B) => C, ar: Result<A, E>, br: Result<B, E>): Result<C, E> =>
+  ar.ok === false ? ar :
+    br.ok === false ? br :
+      ok<C>(f(ar.result, br.result));
+
 /**
  * Apply `f` to the error of an `Err`, or pass the success through.
  */

test/json-decode.test.ts

@@ -13,6 +13,7 @@ import {
   optional,
   oneOf,
   union,
+  intersection,
   withDefault,
   valueAt,
   succeed,
@@ -472,6 +473,47 @@ describe('union', () => {
   });
 });
 
+describe('intersection', () => {
+  it('uses two decoders to decode an extended interface', () => {
+    interface A {
+      a: number;
+    }
+
+    interface AB extends A {
+      b: string;
+    }
+
+    const aDecoder: Decoder<A> = object({a: number()});
+    const abDecoder: Decoder<AB> = intersection(aDecoder, object({b: string()}));
+
+    expect(abDecoder.run({a: 12, b: '!!!'})).toEqual({ok: true, result: {a: 12, b: '!!!'}});
+  });
+
+  it('can combine many decoders', () => {
+    interface UVWXYZ {
+      u: true;
+      v: string[];
+      w: boolean | null;
+      x: number;
+      y: string;
+      z: boolean;
+    }
+
+    const uvwxyzDecoder: Decoder<UVWXYZ> = intersection(
+      object({u: constant(true)}),
+      object({v: array(string())}),
+      object({w: union(boolean(), constant(null))}),
+      object({x: number()}),
+      object({y: string(), z: boolean()})
+    );
+
+    expect(uvwxyzDecoder.run({u: true, v: [], w: null, x: 4, y: 'y', z: false})).toEqual({
+      ok: true,
+      result: {u: true, v: [], w: null, x: 4, y: 'y', z: false}
+    });
+  });
+});
+
 describe('withDefault', () => {
   const decoder = withDefault('puppies', string());