Allow constant decoder to match constant arrays and objects

Augment `constant` so that it can be used on any json data. This shouldn't
impact performance for preexisting use cases for `constant`, but will perform a
deep structural comparison for object and array decoders.

Update documentation to show that string and number literal types inside of
arrays and objects still require type annotations.

Author: Elias Mulhall

src/decoder.ts

@@ -1,4 +1,5 @@
 import * as Result from './result';
+const isEqual = require('lodash/isEqual'); // this syntax avoids TS1192
 
 /**
  * Information describing how json data failed to match a decoder.
@@ -177,15 +178,19 @@ export class Decoder<A> {
    * and numbers, as detailed by this table:
    *
    * ```
-   *  | Decoder                      | Type              |
-   *  | ---------------------------- | ----------------- |
-   *  | constant(true)               | Decoder<true>     |
-   *  | constant(false)              | Decoder<false>    |
-   *  | constant(null)               | Decoder<null>     |
-   *  | constant('alaska')           | Decoder<string>   |
-   *  | constant<'alaska'>('alaska') | Decoder<'alaska'> |
-   *  | constant(50)                 | Decoder<number>   |
-   *  | constant<50>(50)             | Decoder<50>       |
+   *  | Decoder                      | Type                 |
+   *  | ---------------------------- | ---------------------|
+   *  | constant(true)               | Decoder<true>        |
+   *  | constant(false)              | Decoder<false>       |
+   *  | constant(null)               | Decoder<null>        |
+   *  | constant('alaska')           | Decoder<string>      |
+   *  | constant<'alaska'>('alaska') | Decoder<'alaska'>    |
+   *  | constant(50)                 | Decoder<number>      |
+   *  | constant<50>(50)             | Decoder<50>          |
+   *  | constant([1,2,3])            | Decoder<number[]>    |
+   *  | constant<[1,2,3]>([1,2,3])   | Decoder<[1,2,3]>     |
+   *  | constant({x: 't'})           | Decoder<{x: string}> |
+   *  | constant<{x: 't'}>({x: 't'}) | Decoder<{x: 't'}>    |
    * ```
    *
    *
@@ -234,7 +239,7 @@ export class Decoder<A> {
   static constant(value: any): Decoder<any> {
     return new Decoder(
       (json: any) =>
-        json === value
+        isEqual(json, value)
           ? Result.ok(value)
           : Result.err({message: `expected ${JSON.stringify(value)}, got ${JSON.stringify(json)}`})
     );

test/json-decode.test.ts

@@ -146,6 +146,28 @@ describe('constant', () => {
 
     expect(decoder.run({x: null})).toEqual({ok: true, result: {x: null}});
   });
+
+  it('can decode a constant array', () => {
+    type A = [1, 2, 3];
+    const decoder: Decoder<A> = constant<A>([1, 2, 3]);
+
+    expect(decoder.run([1, 2, 3])).toEqual({ok: true, result: [1, 2, 3]});
+    expect(decoder.run([1, 2, 3, 4])).toMatchObject({
+      ok: false,
+      error: {at: 'input', message: 'expected [1,2,3], got [1,2,3,4]'}
+    });
+  });
+
+  it('can decode a constant object', () => {
+    type O = {a: true; b: 12};
+    const decoder: Decoder<O> = constant<O>({a: true, b: 12});
+
+    expect(decoder.run({a: true, b: 12})).toEqual({ok: true, result: {a: true, b: 12}});
+    expect(decoder.run({a: true, b: 7})).toMatchObject({
+      ok: false,
+      error: {at: 'input', message: 'expected {"a":true,"b":12}, got {"a":true,"b":7}'}
+    });
+  });
 });
 
 describe('object', () => {