TypeScript 3.7: The Biggest Features and How to Use Them

https://github.com/facebookincubator/idx

Idx is a bit more verbose because you have to write an arrow function for each invocation, and it doesn't support default values.

  interface ContactInfo {
    address_1: string;
    address_2?: string;
    city: string;
    state: string;
    zip: string;
    phone: number;
  }
  function isContactInfo(arg: any): arg is ContactInfo {
    let valid = false;
    const contactInfoFields: { readonly [key: string]: string[] } = {
      address_1: [ 'string', ],
      address_2: [ 'string', 'undefined' ],
      city: [ 'string', ],
      state: [ 'string', ],
      zip: [ 'string', ],
      phone: [ 'number' ],
    };

    if (typeof arg !== 'object') {
      return valid;
    }
    for (const key in contactInfoFields) {
      if(!contactInfoFields[key].includes(typeof arg[key]) || arg[key] === '' || Number.isNaN(arg[key])) {
        return valid;
      }
    }
    valid = true;
    return valid;
  }

  instanceof
  typeof
  Array.isArray()
  == null

2. Use https://github.com/YousefED/typescript-json-schema to generate a JSON schema, then use a json schema validator to do runtime validation. That's how https://github.com/Polymer/tachometer handles config file parsing and it works very well.

It’s easily the #1 thing I miss syntax-wise after using Elixir/Erlang for any period of time.

Patterns fit perfectly with the typed and functional approach, especially with Maybe monads which are used everywhere in some apps.

Now we just need `if let` and `guard let` in TypeScript and we'll be good!

[0]: https://www.typescriptlang.org/docs/handbook/basic-types.htm...

[1]: https://microsoft.github.io/TypeScript-New-Handbook/outline/

It mostly eliminates the need to have immediately evaluated wrapper async functions that we would have needed so far.

(async () => { await foo(); })();

The added benefit is that imported scripts would be implicitly awaited upon, which has been clunky to do otherwise - you'd need to have a module that exposes an async function and expect the consumer to await on them. But the moment you do that you'd no longer be able to directly run the script through node, so you'd end up needing one more file that imports this module and runs it directly.

Availability of top-level await makes experimenting with (promise-returning) APIs in REPL much easier. It is also a bit step forward in making typescript more useful as a general purpose scripting language (outside webdev context).