Typescript 2.0.x与2.1.x，类型定义由switch / case语句过滤

Question

@ngrx/store (an observable redux implementation for angular (2) ) uses this pattern to get the proper type to a reducer

See the actual code

export const ActionTypes = {
  FOO:  type('foo'),
  BAR:  type('bar')
};

export class FooAction implements Action {
  type = ActionTypes.FOO;

  constructor(public payload: string) { }
}

export class BarAction implements Action {
  type = ActionTypes.BAR;

  constructor(public payload: number) { }
}

export type Actions
  = Foo
  | Bar;

along with a reducer:

export class SomeReducerState {
  foo: string;
  bar: number;
}

const initialState = {
  foo: undefined,
  bar: 0
};

export function someReducer(
  state: SomeReducerState = initialState,
  action: some.Actions
): SomeReducerState {

  switch (action.type) {
    case some.ActionTypes.FOO:
      return Object.assign({}, state, { foo: action.payload });
    case some.ActionTypes.BAR:
      return Object.assign({}, state, { bar: action.payload });
    default:
      return state;
  }

}

The way it worked in typescript 2.0.x was that(I think) it would use the switch/case to decide/filter out what's the proper type for action.payload , so inside case some.ActionTypes.FOO action.payload was string , inside BAR it was number . Now with typescript 2.1.x it seems to be any . Is there any way to achieve the same results with 2.1.x? is that a bug?

Answer 1

The way to do it is by using readonly on type . Another benefit is that it won't require the type utility function to coerce the type of the strings anymore.

Full code here .