tcomb

How does this differ from something like https://github.com/gcanti/tcomb ?

There's a fair bit of work in this area that leverages Flow type syntax, e.g: - https://github.com/gcanti/tcomb - https://github.com/gcanti/io-ts (for typescript) - https://github.com/codemix/flow-runtime (i wrote this) And another alternative is to use Design by Contract, like Eiffel: https://github.com/codemix/babel-plugin-contracts (also me)

Seems cool. Also worth checking out: tcomb[0] which can let you use your Flow types at runtime for eg; pattern matching. [0] https://github.com/gcanti/tcomb

I wrote a library [1] and a babel plugin [2] (bonus point: is Flow compatible) in order to deal with those cumbersome runtime type checks. [1] https://github.com/gcanti/tcomb [2] https://github.com/gcanti/babel-plugin-tcomb

I too used JSON Schema until it grated on me enough to finally abandon it... But I haven't taken the leap into TypeScript yet. Lately I've been specifying schemas with Tcomb[0], which I quite like. It's different from JSON Schema in that it's code and does runtime checking, so it's not a fit for every project. But it's pretty trivial to write a little node-based Tcomb validator if you want to be able to validate from a CLI. It's quite simple, but expressive, and I find that the fact that it's code can be a benefit, since it's simpler to compose complex schemas with code. As a bonus (or downside, depending on your use case), you also get pseudo-immutability on your Tcomb structs for free. [0] https://github.com/gcanti/tcomb

> I was hooked on the idea of having a type safe data record that was also immutable Me too, thus I wrote https://github.com/gcanti/tcomb

Shameless plug: https://github.com/gcanti/tcomb. Used in development/production in several places, included the new MapBox Studio

Hi, shameless plug: another (typed) immutable data structure library, https://github.com/gcanti/tcomb. Main features: - works with regular objects and arrays - runtime type checks - easy debugging with Chrome DevTools - immutability and immutability helpers - runtime type introspection - easy JSON serialization / deseralization - pattern matching Also https://github.com/gcanti/redux-tcomb (Immutable and type-checked state and actions for Redux)

Did you take a look at tcomb[0]? [0] https://github.com/gcanti/tcomb

Off topic: tcomb looks insanely cool. Thanks for pointing it out. Though HN is including one of the parens in your link, which is messing it up. Here's a pristine version for the lazy: https://github.com/gcanti/tcomb

> “The `class` keyword will probably be the most harmful feature in JavaScript." I'm glad I'm not the only one. One of the reasons Javascript became so popular is that it took many of the properties that Lispers have been extolling for decades (minimal syntax, light-weight, meta-programmable, functional, composable), but wrapped them in a familiar-enough looking package that even beginners can Get Stuff Done. (Which is where Lisps have historically failed.) I'm hoping the future of Js will continue in this direction, but looking at ES6 and Angular, it looks like too many people are trying to turn Javascript into Java. The heart of Javascript is simplicity and power. Arrow functions and modules are a great addition. Maybe with enough support from the community, instead of more syntactic sugar and complexity, ES7 will adopt macros (http://s

> Another options besides comment-based annotations is property based annotations. Basically provide a library that contains all the possible primitive types that can be checked and functions for composing higher order types. Shameless plug: I wrote a similar library based on set theory (I'm a mathematician) https://github.com/gcanti/tcomb EDIT: and here an article explaining the rationale behind the library https://gcanti.github.io/2014/09/29/javascript-types-and-set...

Lately I've seen on HN a few attempts to add runtime type checking to JavaScript. I'm happy with that, as in my experience adding a bunch of asserts in strategic places can really speed up prototyping and development, you become more confident, and chances are that you can catch bugs earlier. In the same vein I wrote a library that adds runtime type checking based on type combinators [1], check it out, we can share some ideas. [1] https://github.com/gcanti/tcomb