add support for non-string tag values to sum, closes #481

CHANGELOG.md

@@ -14,6 +14,12 @@
 **Note**: Gaps between patch versions are faulty/broken releases.
 **Note**: A feature tagged as Experimental is in a high state of flux, you're at risk of it changing without notice.
 
+# 2.2.6
+
+- **Experimental**
+  - `Decoder`
+    - add support for non-`string` tag values to `sum`, closes #481 (@gcanti)
+
 # 2.2.5
 
 - **Experimental**

package.json

@@ -1,6 +1,6 @@
 {
   "name": "io-ts",
-  "version": "2.2.5",
+  "version": "2.2.6",
   "description": "TypeScript runtime type system for IO decoding/encoding",
   "files": [
     "lib",

src/Decoder.ts

@@ -431,7 +431,7 @@ export function lazy<A>(id: string, f: () => Decoder<A>): Decoder<A> {
  * @since 2.2.0
  */
 export function sum<T extends string>(tag: T): <A>(members: { [K in keyof A]: Decoder<A[K]> }) => Decoder<A[keyof A]> {
-  return (members) => {
+  return <A>(members: { [K in keyof A]: Decoder<A[K]> }) => {
     const keys = Object.keys(members)
     if (keys.length === 0) {
       return never
@@ -443,9 +443,9 @@ export function sum<T extends string>(tag: T): <A>(members: { [K in keyof A]: De
         if (isLeft(e)) {
           return e
         }
-        const v = e.right[tag]
-        if (G.string.is(v) && v in members) {
-          return (members as any)[v].decode(u)
+        const v = e.right[tag] as keyof A
+        if (v in members) {
+          return members[v].decode(u)
         }
         return left([
           tree(`required property ${JSON.stringify(tag)}`, [

src/Guard.ts

@@ -205,10 +205,10 @@ export function union<A extends ReadonlyArray<unknown>>(...members: { [K in keyo
  * @since 2.2.0
  */
 export function sum<T extends string>(tag: T): <A>(members: { [K in keyof A]: Guard<A[K]> }) => Guard<A[keyof A]> {
-  return (members: Record<string, Guard<unknown>>) =>
+  return <A>(members: { [K in keyof A]: Guard<A[K]> }) =>
     refinement(UnknownRecord, (r): r is any => {
-      const v = r[tag]
-      if (string.is(v) && v in members) {
+      const v = r[tag] as keyof A
+      if (v in members) {
         return members[v].is(r)
       }
       return false

test/Decoder.ts

@@ -55,6 +55,21 @@ describe('Decoder', () => {
     })
   })
 
+  describe('sum', () => {
+    it('should support non-`string` tag values', () => {
+      const decoder = D.sum('_tag')({
+        true: D.type({ _tag: D.literal(true), a: D.string }),
+        false: D.type({ _tag: D.literal(false), b: D.number })
+      })
+      assert.deepStrictEqual(decoder.decode({ _tag: true, a: 'a' }), E.right({ _tag: true, a: 'a' }))
+      assert.deepStrictEqual(decoder.decode({ _tag: false, b: 1 }), E.right({ _tag: false, b: 1 }))
+      assert.deepStrictEqual(
+        decoder.decode({ _tag: false, b: 'a' }),
+        E.left([D.tree('required property "b"', [D.tree('cannot decode "a", should be number')])])
+      )
+    })
+  })
+
   describe('intersect', () => {
     it('should concat strings', () => {
       assert.deepStrictEqual(D.intersect('a', 'b'), 'b')

test/Guard.ts

@@ -230,5 +230,15 @@ describe('Guard', () => {
       assert.deepStrictEqual(sum({}).is(null), false)
       assert.deepStrictEqual(sum({}).is({}), false)
     })
+
+    it('should support non-`string` tag values', () => {
+      const guard = G.sum('_tag')({
+        true: G.type({ _tag: G.literal(true), a: G.string }),
+        false: G.type({ _tag: G.literal(false), b: G.number })
+      })
+      assert.deepStrictEqual(guard.is({ _tag: true, a: 'a' }), true)
+      assert.deepStrictEqual(guard.is({ _tag: false, b: 1 }), true)
+      assert.deepStrictEqual(guard.is({ _tag: false, b: 'a' }), false)
+    })
   })
 })

test/Schema.ts

@@ -121,12 +121,4 @@ describe('Schema', () => {
     )
     check(schema)
   })
-
-  // it('UnknownArray', () => {
-  //   check(make((S) => S.UnknownArray))
-  // })
-
-  // it('UnknownRecord', () => {
-  //   check(make((S) => S.UnknownRecord))
-  // })
 })