Don't you have

  React.PropTypes.shape({
    foo: React.PropTypes.string,
    bar: React.PropTypes.shape({
      fieldNum: React.PropTypes.number
    })
  })

? I'm not saying it isn't verbose, but I'm pretty sure that as of a few months ago, this existed in React natively.

PropType support is pretty iffy, see e.g. https://github.com/facebook/react/issues/1833#issuecomment-1...

Thanks, I didn't know that (I've been using React.js just a month, and from beginning with TypeScript)

You can also do ImageUser.propTypes = { image: CustomImage.propTypes }

> What I really miss is the ability to say that what is the return type of the method

Agreed! There's an open issue that addresses that scenario (and a ton of others):

https://github.com/Microsoft/TypeScript/issues/6606

> I use Typescript 2.0 RC

No need to use the RC any more. 2.0 is out!

https://github.com/Microsoft/TypeScript/wiki/What's-new-in-T...

I have to say, I'm pretty confused about what the state of 2.0 is. There's been no official announcement and the latest stable version on npm is 1.8.10[1]. That being said the latest release on GitHub is 2.0.2, with no official release of 2.0 (or 2.0.1 for that matter) listed anywhere[2]. There's also no active milestone on GitHub for the 2.0 release, but there is for patch versions of 2.0? I'm sure this all just means 2.0 hasn't been released yet, but it's super confusing.

[1]: https://www.npmjs.com/package/typescript

[2]: https://github.com/Microsoft/TypeScript/releases

I've also been trying to derive a good TS pattern for redux Actions/Reducers. Do you have any code examples online that you could point me to?

I've been using discriminated unions on TS 2 to do this, and works quite well.

Example:

  const INCREMENT: "increment" = "increment";
  const DECREMENT: "decrement" = "decrement";

  interface Increment {
      type: typeof INCREMENT;
      payload: {
          inc: number;
      };
  }

   interface Decrement {
      type: typeof DECREMENT;
      payload: {
          dec: number;
      };
  }

  interface State { 
      count: number; 
  }

  type Actions = Increment | Decrement;

  function reducer(state: State, action: Actions) {
     switch (action.type) {
        case INCREMENT: {
             const { inc } = action.payload;
             return { count: state.count + inc };
         }
         case DECREMENT: {
             const { dec } = action.payload;
             return { count: state.count + dec };
         }
         default:
             return state;
     }
  }

Once TS figures out the action type is INCREMENT, it can infer the type of the payload. You don't need the Actions type either, you can just receive action: Increment | Decrement.

Yes, I'm doing basically the same (define constant a as literal type, then use "typeof" operator to define action type, and then create alias for all Actions using union type).

That's one of the reasons why I miss possibility to tell what is the type of the object that function returns. So I could do something like this (hypothetical syntax)

    const INCREMENT: "increment" = "increment";
    const DECREMENT: "decrement" = "decrement";

    function increment(inc: number) {
        return {
            type: INCREMENT,
            inc
        };
    }

    function decrement(dec: number) {
        return {
            type: DECREMENT,
            dec
        };
    }

    type Actions =
        returntypeof increment
        | returntypeof decrement;

So I won't need to write action type when I have action creator method. I hope that in future Typescript devs will add some feature to allow this kind of pattern.