4 ms·

>Flow offers a more sophisticated type system that is designed to express types that correspond with the sort of idioms you see in JavaScript in the wild. TypeS

• root_axis 8y ago
  https://flow.org/en/docs/types/utilities/ https://flow.org/en/docs/types/utilities/ Most of that can't be achieved out of the box with TypeScript. TypeScript was designed as a language that would bridge the quality of life gap between es5 and more modern languages, Flow was designed exclusively as a type system for annotating standards compliant JS.
  • ng12 8y ago
    Not true, most of that can be done with TypeScript. $Values might be the only one missing.
    • WorldMaker 8y ago
      $Values should be possible with Typescript 3.0+ conditional infer types, presumably something very similar to the built-in ReturnType<T> conditional infer type. Untested and off the top my head but maybe something like: type Values<T> = T extends { [K keyof T]: infer R } ? R : any
      • wyze 8y ago
        It works, just need to add `in` in-between `K` and `keyof`.
    • wyze 8y ago
      Looks like $Values can be written as follows in TypeScript: type Props = { age: number name: number } type Values = Props[keyof Props]
  • paavohtl 8y ago
    Are you aware the TypeScript has mapped types and conditional types[1]? The vast majority of Flow's type utils can be implemented in TypeScript, and many of them are included by default[2]. As far as I can tell all of Flow's utility types are compiler built-ins[3], but TypeScript's built-ins are declared using the type system itself (or are just natural parts of the syntax): type Keys<T> = keyof T type Values<T> = T[keyof T] type Readonly_<T> = Readonly<T> type Shape<T> = Partial<T> type NonMaybeType<T> = NonNullable<T> // Exact<T> cannot be implemented because TS doesn't have exact types as a separate concept, // It should be noted that object literals are exact by-default if there's a type annotation // Issue: https://github.com/Microsoft/TypeScript/issues/12936 type Diff<A, B> = Pick<A, Exclude<keyof A, keyof B>> // Rest<T> should be equal to Diff, because TS doesn't have exact types type ElementType<T, K extends keyof T> = T[K] // PropertyType in unnecessary, because T[K] works for everything // Note that this is variadic - "Args" is an array of arguments type Call<F, Args extends any[]> = F extends (...args: Args) => infer B ? B : never // This works for both objects and tuples. type ObjMap<T, F> = { [K in keyof T]: Call<F, [T[K]]> } // I couldn't figure out how to implement Class<T>, but you can access the type of a class instance with // typeof ClassName.prototype // $SuperType and $Subtype are not documented, so I can't try to replicate them. // TypeScript doesn't have existential types, but you can emulate them within the type system, or avoid them using e.g "infer" // Discussion and encoding https://github.com/Microsoft/TypeScript/issues/14466#issuecomment-338045331 I don't agree with your statement about TypeScript's design. Before ES6 TypeScript _was_ quite different from JS, but for the past 3 or 4 years it has followed modern JS very closely. The flavor of JS it supports is fully compliant with ES2018, and the ONLY feature with codegen impact it has in addition to modern JS and JSX are enums - which compile down to simple object literals. [1] https://www.typescriptlang.org/docs/handbook/advanced-types.html https://www.typescriptlang.org/docs/handbook/advanced-types.... [2] https://github.com/Microsoft/TypeScript-Handbook/blob/master/pages/Utility%20Types.md https://github.com/Microsoft/TypeScript-Handbook/blob/master... [3] https://github.com/facebook/flow/blob/cf03c08109014c4503a392705b7dacb7dd827a0b/src/typing/type_annotation.ml https://github.com/facebook/flow/blob/cf03c08109014c4503a392...