Decoder.sum is not typesafe, What is recommended to use between Decoder.union and Decoder.sum?

[kpritam]

I have two doubts:

1. Difference between Decoder.union and Decoder.sum

   • IsDecoder.sum optimized and should be used whenever possible?

2. Decoder.sum is not typesafe

   • In second argument of sum, key of object can be different than the corresponding value
   • Fails at runtime, shown in following example

const CircleD = D.type({
  kind: D.literal('Circle'),
  radius: D.number
})

const SquareD = D.type({
  kind: D.literal('Square'),
  x: D.number
})

// note here, key 'Circle1' is not valid but does not issue compile time error
const ShapeD = D.sum('kind')({
  Circle1: CircleD,
  Square: SquareD
})

// fails at runtime
ShapeD.decode({
  kind: 'Circle',
  radius: 10
 })

Above issue can be resolved if signature of sum is changed to following:

import * as D from 'io-ts/lib/Decoder'

const sum = <T extends string>(tag: T) => <A>(
  members: { [K in keyof A]: Decoder<A[K] extends { [Key in T]: K } ? A[K] : never> }
): Decoder<A[keyof A]> => D.sum(tag)(members)

// fails to compile
sum('kind')({
  Circle1: CircleD,
  Square: SquareD
})

Happy to submit PR if this make sense.

[leighman]

import { TypeOf, make } from 'io-ts/lib/Schema'

export const A = make((S) =>
  S.type({
    whatever: S.string,
    type: S.literal('a'),
  })
)
export type A = TypeOf<typeof A>

export const B = make((S) =>
  S.type({
    blah: S.string,
    type: S.literal('b'),
  })
)
export type B = TypeOf<typeof B>

export const AOrB = make((S) =>
  S.sum('type')({
    a: A(S),
    b: A(S),
  })
)

Came here to report this issue with sum. Similar potential to make errors due to gap in type safety.

[gcanti]

Is Decoder.sum optimized

Yes

is not typesafe

Alas that's right, note that the proposed change would make non-string tag values impossible to manage though:

import * as D from 'io-ts/lib/Decoder'

const sum = <T extends string>(tag: T) => <A>(
  members: { [K in keyof A]: D.Decoder<unknown, A[K] extends { [Key in T]: K } ? A[K] : never> }
): D.Decoder<unknown, A[keyof A]> => D.sum(tag)(members)

const CircleD = D.type({
  kind: D.literal(1),
  radius: D.number
})

const SquareD = D.type({
  kind: D.literal(2),
  x: D.number
})

const ShapeD = sum('kind')({
  1: CircleD, // error
  2: SquareD // error
})

[kpritam]

@gcanti following does work though (not sure how, maybe typescript bug?)

const ShapeD = sum('kind')({
  [1]: CircleD,
  [2]: SquareD
})

[gcanti]

@kpritam nice trick!