seriously, generics in typescript is godsent.

it's great to be able to code in javascript while having a very supportive vscode intellisense

I have not used TypeScript, but looking at it's documentation the syntax for type annotations look identical. Would you be willing to expand on why you think its approach is better / how it's different?

Thanks anyways though

types can be imported either explicitly via `require()` or via the `@type {import("foo").Bar}`

There are definitely some limitations and caveats, like `Object` being aliased to `any` (I think this is being changed in a new version), but it's still way better than untyped JS, and having typescript integration is nice since our devs are already using typescript in other places.

Can even using things like https://github.com/typescript-eslint/typescript-eslint

Flow is both more advanced and faster than Typescript, but the community isn't as large, so Typescript continues to gain marketshare

    type FooArgs = {x: string}
    type FooResult = {y: string}
    type Foo = (_: FooArgs) => FooResult

    /// <reference path="index.d.ts"/>
    /** @type {Foo} */
    export const foo = ({x}) => ({y: x})

Can with JSDoc define types? And can you define generic types? To me that is the real power of TypeScript, being able to type every object you use.

type MyType<T> = someFunc(T)

Of course these functions might be typed too…

If you have a function from A to B, you have to declare its type as

    type MyFunction = (arg1: A) => B

    type MyFunction = A => B

    function call<TS extends any[], R>(fn: (...args: TS) => R, ...args: TS): R { return fn(...args); }

    function call<TS extends any[], R>(fn: ...TS => R, ...args: TS): R { return fn(...args); }

It does support generics [0].

[0] https://github.com/gcanti/io-ts/blob/master/index.md#generic...

A big part of my confusion, I think, is that I’m not sure why you’d want to write code without type annotations. I can see a use for autogenerating them from code that doesn’t have any, but the first example on the page infers the return type of hello() as “t547061|string” which is rather more opaque than I’d prefer from a diagnostic. A big part of why I use TypeScript is because of the type annotations: both so future readers can understand my intent, and also to give the type checker hints about what I was thinking so it can point to exactly where I went wrong instead of going “this over here doesn’t work with that thing over there, I dunno, there’s probably something in the middle that’s not right.” So I’m curious what your thoughts are on why you dislike annotations and how to make type errors clear without leaning on them for support.

Type variables abstract over types and are analogous to function parameters at the values level. Think the ‘T’ in ‘List<T>’.

2) TypeScript has type aliases, meaning you can write `type MyTable = List<Map<string, number | string | Foo>>` and not have to repeat yourself everywhere.

3) TypeScript has anonymous unions and tuples, so instead of writing `Triple<Integer, String, Foo>` you can just write `[number, string, Foo]`, and likewise instead of `OneOf<Integer, String, Foo>` you can write `number | string | Foo`. These are also built in and very ergonomic, so you don't have to write a OneOf4 class whenever you want to have one of 4 things, and you don't have to write helper methods to convert between different sized OneOfs.

  // TypeScript
  add<number>(4, 5)
  new Point<bigint>(4n, 5n)

  // Types Annotations - example syntax solution
  add::<number>(4, 5)
  new Point::<bigint>(4n, 5n)

----

Hmm I didn't know this, so I tried it myself in Chrome's console... sure enough it works...

  new DOMPoint<Number>(4,5)
  

Could you explain what you mean by this? I'm not clear on what typescript behavior this describes.