[ramda] Why does dissoc uses a generic ?

Actual definition is :

declare function dissoc<T>(
    key: string,
    ...args: Array<void>
  ): (src: { [k: string]: T }) => { [k: string]: T };
declare function dissoc<T>(
    key: string,
    src: { [k: string]: T }
): { [k: string]: T };

I don’t get why we want to enforce a unique type T a object content ?

I have a union use case where this causes trouble :

// @flow
import * as R from 'ramda'

type OtherType = { toto: string }

export type ActionA = {|
  type: string,
  payload: {| somePayload: string |}
|}

export type ActionB = {|
  type: string,
  payload: {| someOtherPayload: OtherType |}
|}

export type Action = ActionA | ActionB

const filterAction = (a: Action): {} => R.dissoc('type')(a)

I don’t see why Flow errors, and I don’t see any problem with this code …

When I change libdef to the following, I don’t have any problem :

declare function dissoc(
    key: string
  ): (src: { [k: string]: any }) => { [k: string]: any };
  declare function dissoc(
    key: string,
    src: { [k: string]: any }
  ): { [k: string]: any };

[LoganBarnett]

Don’t we want (obj1.a: number | string | boolean) to fail because a is not on obj1, and (obj1.b: number | string | boolean) to fail because it is a string?

[AndrewSouthpaw]

Oops, you’re quite right, I had missed that.