remove useless constraint

docs/modules/Decoder.ts.md

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

docs/modules/Eq.ts.md

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

docs/modules/Guard.ts.md

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

docs/modules/JsonCodec.ts.md

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

docs/modules/JsonEncoder.ts.md

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

docs/modules/Schemable.ts.md

@@ -43,9 +43,7 @@ export interface Schemable<S> {
   readonly array: <A>(items: 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 intersection: <A, B>(left: HKT<S, A>, right: HKT<S, B>) => HKT<S, A & B>
-  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 sum: <T extends string>(tag: T) => <A>(members: { [K in keyof A]: HKT<S, A[K]> }) => HKT<S, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => HKT<S, A>) => HKT<S, A>
 }
 ```
@@ -70,9 +68,7 @@ export interface Schemable1<S extends URIS> {
   readonly array: <A>(items: 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 intersection: <A, B>(left: Kind<S, A>, right: Kind<S, B>) => Kind<S, A & B>
-  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 sum: <T extends string>(tag: T) => <A>(members: { [K in keyof A]: Kind<S, A[K]> }) => Kind<S, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => Kind<S, A>) => Kind<S, A>
 }
 ```

docs/modules/Type.ts.md

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

dtslint/ts3.5/Econder.ts

@@ -68,6 +68,8 @@ const sum = E.sum('_tag')
 // $ExpectType Encoder<{ _tag: "A"; a: string; } | { _tag: "B"; b: number; }, { _tag: "A"; a: number; } | { _tag: "B"; b: boolean; }>
 sum({ A: S1, B: S2 })
 
+const S3 = E.type({ _tag: E.id<'C'>(), c: E.id<string>() })
+
 //
 // lazy
 //

src/Decoder.ts

@@ -386,9 +386,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] & Record<T, K>> }) => Decoder<A[keyof A]> {
+export function sum<T extends string>(tag: T): <A>(members: { [K in keyof A]: Decoder<A[K]> }) => Decoder<A[keyof A]> {
   return (members) => {
     const keys = Object.keys(members)
     if (keys.length === 0) {

src/Encoder.ts

@@ -143,9 +143,9 @@ export function intersection<O, A, P, B>(left: Encoder<O, A>, right: Encoder<P,
 export function sum<T extends string>(
   tag: T
 ): <M extends Record<string, Encoder<any, any>>>(members: M) => Encoder<OutputOf<M[keyof M]>, TypeOf<M[keyof M]>> {
-  return (members: Record<string, Encoder<any, any>>) => {
+  return (members) => {
     return {
-      encode: (a: Record<string, any>) => members[a[tag]].encode(a)
+      encode: (a) => members[a[tag]].encode(a)
     }
   }
 }

src/Eq.ts

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

src/Guard.ts

@@ -182,14 +182,12 @@ 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] & Record<T, K>> }) => Guard<A[keyof A]> {
-  return <A>(members: { [K in keyof A]: Guard<A[K] & Record<T, K>> }) =>
-    refinement(UnknownRecord, (r): r is { [K in keyof A]: A[K] & Record<T, K> }[keyof A] => {
+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>>) =>
+    refinement(UnknownRecord, (r): r is any => {
       const v = r[tag]
       if (string.is(v) && v in members) {
-        return (members as any)[v].is(r)
+        return members[v].is(r)
       }
       return false
     })

src/JsonCodec.ts

@@ -122,7 +122,7 @@ export const intersection: <A, B>(left: JsonCodec<A>, right: JsonCodec<B>) => Js
  */
 export const sum: <T extends string>(
   tag: T
-) => <A>(members: { [K in keyof A]: JsonCodec<A[K] & Record<T, K>> }) => JsonCodec<A[keyof A]> = C.sum as any
+) => <A>(members: { [K in keyof A]: JsonCodec<A[K]> }) => JsonCodec<A[keyof A]> = C.sum as any
 
 /**
  * @since 2.2.3

src/JsonEncoder.ts

@@ -96,7 +96,7 @@ export const intersection: <A, B>(left: JsonEncoder<A>, right: JsonEncoder<B>) =
  */
 export const sum: <T extends string>(
   tag: T
-) => <A>(members: { [K in keyof A]: JsonEncoder<A[K] & Record<T, K>> }) => JsonEncoder<A[keyof A]> = E.sum as any
+) => <A>(members: { [K in keyof A]: JsonEncoder<A[K]> }) => JsonEncoder<A[keyof A]> = E.sum as any
 
 /**
  * @since 2.2.3

src/Schemable.ts

@@ -24,9 +24,7 @@ export interface Schemable<S> {
   readonly array: <A>(items: 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 intersection: <A, B>(left: HKT<S, A>, right: HKT<S, B>) => HKT<S, A & B>
-  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 sum: <T extends string>(tag: T) => <A>(members: { [K in keyof A]: HKT<S, A[K]> }) => HKT<S, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => HKT<S, A>) => HKT<S, A>
 }
 
@@ -46,9 +44,7 @@ export interface Schemable1<S extends URIS> {
   readonly array: <A>(items: 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 intersection: <A, B>(left: Kind<S, A>, right: Kind<S, B>) => Kind<S, A & B>
-  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 sum: <T extends string>(tag: T) => <A>(members: { [K in keyof A]: Kind<S, A[K]> }) => Kind<S, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => Kind<S, A>) => Kind<S, A>
 }
 

src/Type.ts

@@ -124,9 +124,7 @@ export function lazy<A>(id: string, f: () => Type<A>): Type<A> {
 /**
  * @since 2.2.3
  */
-export function sum<T extends string>(
-  _tag: T
-): <A>(members: { [K in keyof A]: Type<A[K] & Record<T, K>> }) => Type<A[keyof A]> {
+export function sum<T extends string>(_tag: T): <A>(members: { [K in keyof A]: Type<A[K]> }) => Type<A[keyof A]> {
   return (members) => t.union(Object.values(members) as any)
 }
 

test/Arbitrary.ts

@@ -87,7 +87,7 @@ export function intersection<A, B>(left: Arbitrary<A>, right: Arbitrary<B>): Arb
 
 export function sum<T extends string>(
   _tag: T
-): <A>(members: { [K in keyof A]: Arbitrary<A[K] & Record<T, K>> }) => Arbitrary<A[keyof A]> {
+): <A>(members: { [K in keyof A]: Arbitrary<A[K]> }) => Arbitrary<A[keyof A]> {
   return (members: Record<string, Arbitrary<any>>) => fc.oneof(...Object.keys(members).map((k) => members[k]))
 }