Some significant and useful additions to the type system. I'm very happy with how TypeScript is progressing along. Wondering how things are going with Flow.
As a follower, it seems like TypeScripts typing system is quite a bit more popular... I know there's a typescript preset for babel, and am passively interested in seeing where that goes.
TBH though, I don't really see that TypeScript has many advantages over JS. Though some of this generic syntax seems easier than duck type testing in JS.
>I know there's a typescript preset for babel, and am passively interested in seeing where that goes.
That's probably going to be less popular, because with TypeScript, you often don't need Babel at all (you can transpile directly to ES5, JSX works out of the box, etc.).
I think there's room for babel and typescript to co-exist. In fact, I use typescript purely as a type checker (by setting `jsx` to `preserve`, `target` to `esnext` and `moduel` to `esnext`). As a transpiler, babel is just a lot more configurable and updates much more frequently than typescript.
There's plenty of stuff that gets into babel first, long before TypeScript considers it, if ever. async functions for starters, and everything not yet in env, for the most part.
I'd rather see typescript as a set of babel presets than deal with what it doesn't have in the box.
Something I've been wondering while watching the evolution of TypeScript is how many of these features exist in other programming languages and how many are completely new? Specifically I'm thinking of literal types, mapped types, and now conditional types.
Java and Kotlin are the really only other languages with static types that I use so for me these TypeScript features are things I had never even heard of or imagined before. Now that I have them though it's hard to go back to static types without them.
They certainly introduce nice concepts in TypeScript, I love how they can seem to fit it all in so fast, there's lots of tricky edge-cases.
Dependently typed languages like Agda and Coq can do the conditional types, as typelevel computation is in their very nature. With things like Liquid Haskell there's some spillover to 'normal' functional languages, but it's a bit clunky sometimes and it's not native to the language.
I just skimmed over some information on literal types, but think they're just not that interesting to languages that support (G)ADT's, as the overhead of not using primitives is not the case when you're compiled. But for other interpreted languages it might be very interesting!
8 comments
[ 2.9 ms ] story [ 26.5 ms ] threadTBH though, I don't really see that TypeScript has many advantages over JS. Though some of this generic syntax seems easier than duck type testing in JS.
That's probably going to be less popular, because with TypeScript, you often don't need Babel at all (you can transpile directly to ES5, JSX works out of the box, etc.).
I'd rather see typescript as a set of babel presets than deal with what it doesn't have in the box.
I think type Flatten<T> should be renamed to type Smoosh<T> hehe
Java and Kotlin are the really only other languages with static types that I use so for me these TypeScript features are things I had never even heard of or imagined before. Now that I have them though it's hard to go back to static types without them.
Dependently typed languages like Agda and Coq can do the conditional types, as typelevel computation is in their very nature. With things like Liquid Haskell there's some spillover to 'normal' functional languages, but it's a bit clunky sometimes and it's not native to the language.
I just skimmed over some information on literal types, but think they're just not that interesting to languages that support (G)ADT's, as the overhead of not using primitives is not the case when you're compiled. But for other interpreted languages it might be very interesting!