Experimental: make sum safer, closes #523

CHANGELOG.md

@@ -14,9 +14,35 @@
 **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.12
+
+- **Experimental**
+  - (\*) make `sum` safer, closes #523 (@gcanti)
+
+(\*) breaking change
+
+In case of non-`string` tag values, the respective key must be enclosed in brackets
+
+```ts
+export const MySum: D.Decoder<
+  unknown,
+  | {
+      type: 1 // non-`string` tag value
+      a: string
+    }
+  | {
+      type: 2 // non-`string` tag value
+      b: number
+    }
+> = D.sum('type')({
+  [1]: D.type({ type: D.literal(1), a: D.string }),
+  [2]: D.type({ type: D.literal(2), b: D.number })
+})
+```
+
 # 2.2.11
 
-- **Polish**
+- **Experimental**
   - `Decoder`
     - make `toForest` stack-safe, #520 (@safareli)
 

Decoder.md

@@ -224,6 +224,27 @@ export const MySum: D.Decoder<
 })
 ```
 
+**non-`string` tag values**
+
+In case of non-`string` tag values, the respective key must be enclosed in brackets
+
+```ts
+export const MySum: D.Decoder<
+  unknown,
+  | {
+      type: 1 // non-`string` tag value
+      a: string
+    }
+  | {
+      type: 2 // non-`string` tag value
+      b: number
+    }
+> = D.sum('type')({
+  [1]: D.type({ type: D.literal(1), a: D.string }),
+  [2]: D.type({ type: D.literal(2), b: D.number })
+})
+```
+
 ## The `union` combinator
 
 The `union` combinator describes untagged unions

docs/modules/Decoder.ts.md

@@ -358,7 +358,7 @@ Added in v2.2.7
 ```ts
 export declare const sum: <T extends string>(
   tag: T
-) => <A>(members: { [K in keyof A]: Decoder<unknown, A[K]> }) => Decoder<unknown, A[keyof A]>
+) => <A>(members: { [K in keyof A]: Decoder<unknown, A[K] & Record<T, K>> }) => Decoder<unknown, A[keyof A]>
 ```
 
 Added in v2.2.7

docs/modules/Eq.ts.md

@@ -112,7 +112,9 @@ Added in v2.2.2
 **Signature**
 
 ```ts
-export declare function sum<T extends string>(tag: T): <A>(members: { [K in keyof A]: Eq<A[K]> }) => Eq<A[keyof A]>
+export declare function sum<T extends string>(
+  tag: T
+): <A>(members: { [K in keyof A]: Eq<A[K] & Record<T, K>> }) => Eq<A[keyof A]>
 ```
 
 Added in v2.2.2

docs/modules/Guard.ts.md

@@ -171,7 +171,7 @@ Added in v2.2.0
 ```ts
 export declare const sum: <T extends string>(
   tag: T
-) => <A>(members: { [K in keyof A]: Guard<unknown, A[K]> }) => Guard<unknown, A[keyof A]>
+) => <A>(members: { [K in keyof A]: Guard<unknown, A[K] & Record<T, K>> }) => Guard<unknown, A[keyof A]>
 ```
 
 Added in v2.2.0

docs/modules/Schemable.ts.md

@@ -67,7 +67,9 @@ export interface Schemable<S> {
   readonly array: <A>(item: HKT<S, A>) => HKT<S, Array<A>>
   readonly tuple: <A extends ReadonlyArray<unknown>>(...components: { [K in keyof A]: HKT<S, A[K]> }) => HKT<S, A>
   readonly intersect: <B>(right: HKT<S, B>) => <A>(left: HKT<S, A>) => HKT<S, A & B>
-  readonly sum: <T extends string>(tag: T) => <A>(members: { [K in keyof A]: HKT<S, A[K]> }) => HKT<S, A[keyof A]>
+  readonly sum: <T extends string>(
+    tag: T
+  ) => <A>(members: { [K in keyof A]: HKT<S, A[K] & Record<T, K>> }) => HKT<S, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => HKT<S, A>) => HKT<S, A>
 }
 ```
@@ -92,7 +94,9 @@ export interface Schemable1<S extends URIS> {
   readonly array: <A>(item: Kind<S, A>) => Kind<S, Array<A>>
   readonly tuple: <A extends ReadonlyArray<unknown>>(...components: { [K in keyof A]: Kind<S, A[K]> }) => Kind<S, A>
   readonly intersect: <B>(right: Kind<S, B>) => <A>(left: Kind<S, A>) => Kind<S, A & B>
-  readonly sum: <T extends string>(tag: T) => <A>(members: { [K in keyof A]: Kind<S, A[K]> }) => Kind<S, A[keyof A]>
+  readonly sum: <T extends string>(
+    tag: T
+  ) => <A>(members: { [K in keyof A]: Kind<S, A[K] & Record<T, K>> }) => Kind<S, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => Kind<S, A>) => Kind<S, A>
 }
 ```
@@ -123,7 +127,7 @@ export interface Schemable2C<S extends URIS2, E> {
   readonly intersect: <B>(right: Kind2<S, E, B>) => <A>(left: Kind2<S, E, A>) => Kind2<S, E, A & B>
   readonly sum: <T extends string>(
     tag: T
-  ) => <A>(members: { [K in keyof A]: Kind2<S, E, A[K]> }) => Kind2<S, E, A[keyof A]>
+  ) => <A>(members: { [K in keyof A]: Kind2<S, E, A[K] & Record<T, K>> }) => Kind2<S, E, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => Kind2<S, E, A>) => Kind2<S, E, A>
 }
 ```

docs/modules/TaskDecoder.ts.md

@@ -361,7 +361,7 @@ Added in v2.2.7
 ```ts
 export declare const sum: <T extends string>(
   tag: T
-) => <A>(members: { [K in keyof A]: TaskDecoder<unknown, A[K]> }) => TaskDecoder<unknown, A[keyof A]>
+) => <A>(members: { [K in keyof A]: TaskDecoder<unknown, A[K] & Record<T, K>> }) => TaskDecoder<unknown, A[keyof A]>
 ```
 
 Added in v2.2.7

docs/modules/Type.ts.md

@@ -130,7 +130,7 @@ Added in v2.2.3
 ```ts
 export declare const sum: <T extends string>(
   _tag: T
-) => <A>(members: { [K in keyof A]: Type<A[K]> }) => Type<A[keyof A]>
+) => <A>(members: { [K in keyof A]: Type<A[K] & Record<T, K>> }) => Type<A[keyof A]>
 ```
 
 Added in v2.2.3

dtslint/ts3.5/Codec.ts

@@ -106,8 +106,10 @@ _.fromSum('_tag')({
 // sum
 //
 
+const S1 = _.type({ _tag: _.literal('A'), a: _.string })
+const S2 = _.type({ _tag: _.literal('B'), b: _.number })
+
 // $ExpectType Codec<unknown, { _tag: "A"; a: string; } | { _tag: "B"; b: number; }, { _tag: "A"; a: string; } | { _tag: "B"; b: number; }>
-_.sum('_tag')({
-  A: _.type({ _tag: _.literal('A'), a: _.string }),
-  B: _.type({ _tag: _.literal('B'), b: _.number })
-})
+_.sum('_tag')({ A: S1, B: S2 })
+// // $ExpectError
+// _.sum('_tag')({ A: S1, B: S1 })

dtslint/ts3.5/Decoder.ts

@@ -123,11 +123,13 @@ _.fromSum('_tag')({
 // sum
 //
 
+const S1 = _.type({ _tag: _.literal('A'), a: _.string })
+const S2 = _.type({ _tag: _.literal('B'), b: _.number })
+
 // $ExpectType Decoder<unknown, { _tag: "A"; a: string; } | { _tag: "B"; b: number; }>
-_.sum('_tag')({
-  A: _.type({ _tag: _.literal('A'), a: _.string }),
-  B: _.type({ _tag: _.literal('B'), b: _.number })
-})
+_.sum('_tag')({ A: S1, B: S2 })
+// $ExpectError
+_.sum('_tag')({ A: S1, B: S1 })
 
 //
 // union

dtslint/ts3.5/Eq.ts

@@ -15,3 +15,15 @@ _.partial({
     c: _.number
   })
 })
+
+//
+// sum
+//
+
+const S1 = _.type({ _tag: _.Schemable.literal('A'), a: _.string })
+const S2 = _.type({ _tag: _.Schemable.literal('B'), b: _.number })
+
+// $ExpectType Eq<{ _tag: "A"; a: string; } | { _tag: "B"; b: number; }>
+_.sum('_tag')({ A: S1, B: S2 })
+// // $ExpectError
+// _.sum('_tag')({ A: S1, B: S1 })

dtslint/ts3.5/Guard.ts

@@ -30,3 +30,15 @@ _.partial({
 
 // $ExpectType { a: string; b: { c: number; }; }
 export type A = _.TypeOf<typeof A>
+
+//
+// sum
+//
+
+const S1 = _.type({ _tag: _.literal('A'), a: _.string })
+const S2 = _.type({ _tag: _.literal('B'), b: _.number })
+
+// $ExpectType Guard<unknown, { _tag: "A"; a: string; } | { _tag: "B"; b: number; }>
+_.sum('_tag')({ A: S1, B: S2 })
+// $ExpectError
+_.sum('_tag')({ A: S1, B: S1 })

dtslint/ts3.5/Schema.ts

@@ -100,6 +100,8 @@ const S2 = make((S) => S.type({ _tag: S.literal('B'), b: S.number }))
 
 // $ExpectType Schema<{ _tag: "A"; a: string; } | { _tag: "B"; b: number; }>
 make((S) => S.sum('_tag')({ A: S1(S), B: S2(S) }))
+// $ExpectError
+make((S) => S.sum('_tag')({ A: S1(S), B: S1(S) }))
 
 //
 // lazy

dtslint/ts3.5/TaskDecoder.ts

@@ -0,0 +1,13 @@
+import * as _ from '../../src/TaskDecoder'
+
+//
+// sum
+//
+
+const S1 = _.type({ _tag: _.literal('A'), a: _.string })
+const S2 = _.type({ _tag: _.literal('B'), b: _.number })
+
+// $ExpectType TaskDecoder<unknown, { _tag: "A"; a: string; } | { _tag: "B"; b: number; }>
+_.sum('_tag')({ A: S1, B: S2 })
+// $ExpectError
+_.sum('_tag')({ A: S1, B: S1 })

dtslint/ts3.5/tslint.json

@@ -14,6 +14,13 @@
     "object-literal-shorthand": false,
     "prefer-object-spread": false,
     "whitespace": false,
-    "use-default-type-parameter": false
+    "use-default-type-parameter": false,
+    "interface-name": false,
+    "no-promise-as-boolean": false,
+    "no-eval": false,
+    "label-position": false,
+    "function-constructor": false,
+    "invalid-void": false,
+    "no-construct": false
   }
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "io-ts",
-  "version": "2.2.11",
+  "version": "2.2.12",
   "description": "TypeScript runtime type system for IO decoding/encoding",
   "main": "lib/index.js",
   "module": "es6/index.js",
@@ -59,7 +59,7 @@
     "ts-node": "8.8.2",
     "tslint": "6.1.1",
     "tslint-config-standard": "9.0.0",
-    "typescript": "^3.9.6"
+    "typescript": "^4.0.3"
   },
   "tags": [
     "typescript",

src/Codec.ts

@@ -227,7 +227,7 @@ export function record<O, A>(codomain: Codec<unknown, O, A>): Codec<unknown, Rec
 export const fromTuple = <C extends ReadonlyArray<Codec<any, any, any>>>(
   ...components: C
 ): Codec<{ [K in keyof C]: InputOf<C[K]> }, { [K in keyof C]: OutputOf<C[K]> }, { [K in keyof C]: TypeOf<C[K]> }> =>
-  make(D.fromTuple(...components) as any, E.tuple(...components))
+  make(D.fromTuple(...components) as any, E.tuple(...components)) as any
 
 /**
  * @category combinators

src/Decoder.ts

@@ -295,7 +295,7 @@ export const record = <A>(codomain: Decoder<unknown, A>): Decoder<unknown, Recor
 export const fromTuple = <C extends ReadonlyArray<Decoder<any, any>>>(
   ...components: C
 ): Decoder<{ [K in keyof C]: InputOf<C[K]> }, { [K in keyof C]: TypeOf<C[K]> }> =>
-  K.fromTuple(M)((i, e) => FS.of(DE.index(i, DE.required, e)))(...components)
+  K.fromTuple(M)((i, e) => FS.of(DE.index(i, DE.required, e)))(...components) as any
 
 /**
  * @category combinators
@@ -345,7 +345,7 @@ export const fromSum = <T extends string>(tag: T) => <MS extends Record<string,
  * @since 2.2.7
  */
 export const sum = <T extends string>(tag: T) => <A>(
-  members: { [K in keyof A]: Decoder<unknown, A[K]> }
+  members: { [K in keyof A]: Decoder<unknown, A[K] & Record<T, K>> }
 ): Decoder<unknown, A[keyof A]> => pipe(UnknownRecord as any, compose(fromSum(tag)(members)))
 
 /**

src/Eq.ts

@@ -145,7 +145,9 @@ export const intersect = <B>(right: Eq<B>) => <A>(left: Eq<A>): Eq<A & B> => ({
  * @category combinators
  * @since 2.2.2
  */
-export function sum<T extends string>(tag: T): <A>(members: { [K in keyof A]: Eq<A[K]> }) => Eq<A[keyof A]> {
+export function sum<T extends string>(
+  tag: T
+): <A>(members: { [K in keyof A]: Eq<A[K] & Record<T, K>> }) => Eq<A[keyof A]> {
   return (members: Record<string, Eq<any>>) => {
     return {
       equals: (x: Record<string, any>, y: Record<string, any>) => {

src/Guard.ts

@@ -218,7 +218,7 @@ export const union = <A extends readonly [unknown, ...Array<unknown>]>(
  * @since 2.2.0
  */
 export const sum = <T extends string>(tag: T) => <A>(
-  members: { [K in keyof A]: Guard<unknown, A[K]> }
+  members: { [K in keyof A]: Guard<unknown, A[K] & Record<T, K>> }
 ): Guard<unknown, A[keyof A]> =>
   pipe(
     UnknownRecord,

src/Kleisli.ts

@@ -287,7 +287,7 @@ export function fromSum<M extends URIS2, E>(
     const keys = Object.keys(members)
     return {
       decode: (ir) => {
-        const v = ir[tag]
+        const v: any = ir[tag]
         if (v in members) {
           return (members as any)[v].decode(ir)
         }