Well, in all seriousness that’s basically what dependent types are.

It will be like “there is an error compiling your compiler sir”

Or even the language. On this point: type systems are hard to get right, we know that the Java type system is unsound, even ignoring its covariant array types.

https://news.ycombinator.com/item?id=13050491

This is called dependent typing, and is supported by some languages such as Idris (https://www.idris-lang.org/)

And 10 years later, someone will eventually bring back dynamic typing and every one will go monkeys

This is the feature of TypeScript that I'm most looking forward to. Default all variable and constant declarations to type 'any' so that TypeScript can look identical to JavaScript. Then we can remove the transpile step from our projects.

You can already do exactly that. Just put .js at the end of your filename.

Or set `noImplicitAny` to false if you want to retain some type checking.

I need to use the '.ts' extension because my boss demands it. TypeScript needs a feature to allow me to fool my boss into thinking that I'm using TypeScript while actually using JavaScript.

TypeScript has dynamic types. It's a superset of JavaScript, not a separate language.

It's still there. `any`.

but you don't have to type it now! it's literally a revolution in developer efficiency!

...and all the older folks just keep pointing at lisp and shaking their heads.

You don't have to type it in typescript either.

Just don't turn on the `noImplicitAny` compiler option. Yes, that's right. It's the default. https://www.typescriptlang.org/tsconfig#noImplicitAny

Shake away, lisp folks. If you can show me how to run lisp in a browser with tolerable performance and debugging, I might understand why you're shaking your heads.

I think the lints are on by default, though, so it'll compile but you still get warned.

That is ingenious! That would get me excited about TypeScript! Dynamic typing, no cumbersome transpilation step, no source mapping, 100% backward compatibility with JavaScript. That would be a dream come true.

We need a way to go back to JS without hurting the egos of TS community. It will require a massive marketing innovation to achieve this.

As a member of "the TS community", I hereby authorize you to go back to JS. My ego remains un-damaged.

> Can you tell all the companies to stop obsessing about TypeScript and to allow developers to use JavaScript too?

I don't have that much influence. Most of those companies have come to their own conclusions.

At my company, the reason we wouldn't allow that is that it makes the codebase more difficult to approach for a new developer. Knowing the types accepted and returned is helpful for reading unfamiliar code.

As a toy project, I'm actually experimenting with this, but instead with Lua.

https://github.com/capsadmin/nattlua

You can see some examples in the readme.

To me it makes sense that the typesystem is basically lua rather than a mathematical ish looking language.

It could prove to be more difficult to work with but I guess I'll find out.

> Put JavaScript into types.

It's not without precedent - Haskell has a Turing complete type system. (There's also Scala, Rust, and C++ templates which are all arguably Turing tarpits.)

TypeScript also has a Turing-complete type system, if I remember correctly.

The joke in the release notes here asking developers not to publish Fibonacci computations in the type system to npm is not entirely a joke.

So, generics?