babel-plugin-typecheck

Cool article. I'm the author of https://github.com/codemix/babel-plugin-typecheck mentioned and the next version of the plugin (WIP) takes this kind of approach, so that you can reference a type at runtime: type User = {name: string, isAdmin: boolean}; // compiles to const User = t.object( t.property('name', t.string()), t.property('isAdmin', t.boolean()) ); // which you can then use with User.check({name: 'Alice'}); // boolean User.assert({nom: false}); // throws Ultimately it should be possible to use this to implement pattern matching in JS based on flow types, for example: type User = { name: string; roles: Role[]; }; type Role = { id: number; name: string; users: User[] }; const url = match(someInput, (user: User) => `/users/${user.

No love for react-devtools [0]? I'm amazed it wasn't even an honorable mention, considering he mentioned react and redux (which is probably generally used with react). I'm also surprised he didn't mention flowtype [1], which is by Facebook and is supported by Babel! If you're writing React, you're probably already using Babel, so using flow is very low friction. Furthermore, if you're interested in runtime assertions, you can use babel-plugin-typecheck [2], which will convert your flowtype annotations into assertions. If we're looking to be pragmatic, IMO, this is the optimal path to take. The library that Elliot is working on looks interesting, but even he recognizes in its page that it's still a work-in-progress. If you're writing a modern JS app and you wanna take advantage of all the ES6 goodies, you'll pick up babel. And if you're us

This plugin is pretty cool. It provides runtime flow-ish typechecking. It shows how easy it can be to consume type signatures and operate on them https://github.com/codemix/babel-plugin-typecheck

I feel like I can somewhat relate, I've been adding flowtype [0] annotations to my JS code, which is transpiled with babel. However, since I'm using unsupported ES2015 features and experimental ES2016+ features, it fails to run over my code (which is completely understandable). The workaround I've found is to use a plugin [1], which converts the type annotations into runtime checks. It's not perfect, but I've found it helps catch some bugs quickly. It's also really helpful for documentation purposes: you know that this function param takes a number param, if you're not passing in a number you've made a mistake. Also, having the inline type is nicer than having it in a jsdoc-style comment above. I think there's diminishing returns as you add more annotations to your code and you make them stricter, but having basic sanity checks has been h

I guess I failed to make this point properly, but Babel already supports static typing - you can use a plugin[0] and/or you can use it with Flow[1]. [0] https://github.com/codemix/babel-plugin-typecheck [1] http://flowtype.org/