5 ms·

> That said, I don't really have an opinion on who is at fault here - coders for writing overly elaborate types, or Typescript for allowing them. Backwards com

by goto11 4y ago

> That said, I don't really have an opinion on who is at fault here - coders for writing overly elaborate types, or Typescript for allowing them. Backwards compatibility is to blame. Typescript was designed to support a number of patterns which was already used in JavaScript. For example events are registered in the DOM like `element.addEventListener("click", (ev) => ...)`. The type of the callback will depend on the string passed as the first argument, so the type system need to support literal strings as type discriminators which is a weird feature not necessary in most other languages. If the API had been designed with static typing in mind from the beginning, it would have been designed differently and wouldn't need such a complex type system.

madeofpalk 4y ago
Weird - using constant string discriminators feel very natural and normal to me in Typescript. What do other languages do without them?
- refulgentis 4y ago
  Most model it as an actual enum, if backed by strings. Typescript, by comparison, requires being able to indicate a type just from a string argument
  - esprehn 4y ago
    Allowing literal strings and type aliases of unions of strings to represent enums doesn't seem unreasonable. It's the same concept as many other languages with some extra quotes, ex. https://ocaml.org/docs/data-types#a-simple-custom-type https://ocaml.org/docs/data-types#a-simple-custom-type
    - deleted 4y ago
      [deleted]
  - wruza 4y ago
    This doesn’t change anything: foo(get_some_myenum_value(), …) {type:get_another(), …} These are as unguessable as if myenum was a string.
  - madeofpalk 4y ago
    Hmm. That doesn't feel like much of a difference to me?
    - refulgentis 4y ago
      It's huge? I'm really confused lol. I write in Dart/Java/C++/ObjC/TS regularly to maintain a cross-platform library and this is a massive difference from every typechecker in any other language, much less the narrower thing of if the idea of reifying random strings into an enum is a novel feature. I get a very strong sense from the thread that people are talking past eachother, somehow.
- goto11 4y ago
  The event type could just be exposed as a regular property so you could write `element.onclick.add((ev => ...)` so you would get static typing without any need for magic strings. Magic string are use all over JavaScript for different purposes. For example createElement('P') could just be new PHtmlElement() ... In other cases magic strings could be replaced with enums.
  - madeofpalk 4y ago
    Changing Javascript is explicitly out of scope for Typescript. I was curious how other languages did discriminators in a way that makes Typescript's feel alien. Just having different functions doesn't really tackle that.
    - deleted 4y ago
      [deleted]
    - goto11 4y ago
      The pattern I'm most familiar with is using type constructors: type Shape = Square Int | Circle Int and then pattern matching: print (Square size) = .. print (Circle radius) = ... In Typescript this would be something like: type Shape = { type: 'square', size: number } | { type: 'circle', radius: number } And string matching for type narrowing: function print(shape: Shape) { if (shape.type === 'square) { ... } else if (shape.type === 'square) { ... } } The TypeScript approach is comparatively weird and verbose but also pretty clever since it doesn't require any change to the core language. It also have some pitfalls, e.g. you can write: print({type: 'square', size: 10}); But you cant write: const x = {type: 'square', size: 10}; print(x); <-- type error You have to write: const x = {type: 'square' as const, size: 10}; print(x); Things like this just complicates the type system and type inference.
leonidasv 4y ago
This example looks like a simple sum type with method overload. Don't think that's complex, that's bread and butter in some functional languages. Now take mapped types, template literal types, key remapping... Those features aren't necessary to express legacy DOM APIs, this is just for the sake of having a complex typing system. And that's not to add a new feature that unlocks some type magic that wasn't possible before. No, those are just shorthands for things that you could already express in the existing typing system.
- goto11 4y ago
  It is not just to support the DOM it is also frameworks like JQuery, React, Vue etc. For example the 'options' parameter is a common pattern where an object with a set of properties are provided to override a some default behavior. So you need to define a Foo type with a set of properties, and then you need to define a type which is like Foo except all properties are optional. Some frameworks implement their own flavor of inheritance e.g. through mixins. The type of an object with mixins is not just the sum of all properties, you might also have one property overriding a property of a different type in base mixin, so you are adding and removing properties. You need a really powerful type system to be able to represent this.

by goto11 4y ago

madeofpalk 4y ago

Weird - using constant string discriminators feel very natural and normal to me in Typescript. What do other languages do without them?

refulgentis 4y ago
Most model it as an actual enum, if backed by strings. Typescript, by comparison, requires being able to indicate a type just from a string argument
- esprehn 4y ago
  Allowing literal strings and type aliases of unions of strings to represent enums doesn't seem unreasonable. It's the same concept as many other languages with some extra quotes, ex. https://ocaml.org/docs/data-types#a-simple-custom-type https://ocaml.org/docs/data-types#a-simple-custom-type
  - deleted 4y ago
    [deleted]
- wruza 4y ago
  This doesn’t change anything: foo(get_some_myenum_value(), …) {type:get_another(), …} These are as unguessable as if myenum was a string.
- madeofpalk 4y ago
  Hmm. That doesn't feel like much of a difference to me?
  - refulgentis 4y ago
    It's huge? I'm really confused lol. I write in Dart/Java/C++/ObjC/TS regularly to maintain a cross-platform library and this is a massive difference from every typechecker in any other language, much less the narrower thing of if the idea of reifying random strings into an enum is a novel feature. I get a very strong sense from the thread that people are talking past eachother, somehow.
goto11 4y ago
The event type could just be exposed as a regular property so you could write `element.onclick.add((ev => ...)` so you would get static typing without any need for magic strings. Magic string are use all over JavaScript for different purposes. For example createElement('P') could just be new PHtmlElement() ... In other cases magic strings could be replaced with enums.
- madeofpalk 4y ago
  Changing Javascript is explicitly out of scope for Typescript. I was curious how other languages did discriminators in a way that makes Typescript's feel alien. Just having different functions doesn't really tackle that.
  - deleted 4y ago
    [deleted]
  - goto11 4y ago
    The pattern I'm most familiar with is using type constructors: type Shape = Square Int | Circle Int and then pattern matching: print (Square size) = .. print (Circle radius) = ... In Typescript this would be something like: type Shape = { type: 'square', size: number } | { type: 'circle', radius: number } And string matching for type narrowing: function print(shape: Shape) { if (shape.type === 'square) { ... } else if (shape.type === 'square) { ... } } The TypeScript approach is comparatively weird and verbose but also pretty clever since it doesn't require any change to the core language. It also have some pitfalls, e.g. you can write: print({type: 'square', size: 10}); But you cant write: const x = {type: 'square', size: 10}; print(x); <-- type error You have to write: const x = {type: 'square' as const, size: 10}; print(x); Things like this just complicates the type system and type inference.

leonidasv 4y ago

This example looks like a simple sum type with method overload. Don't think that's complex, that's bread and butter in some functional languages. Now take mapped types, template literal types, key remapping... Those features aren't necessary to express legacy DOM APIs, this is just for the sake of having a complex typing system. And that's not to add a new feature that unlocks some type magic that wasn't possible before. No, those are just shorthands for things that you could already express in the existing typing system.

goto11 4y ago
It is not just to support the DOM it is also frameworks like JQuery, React, Vue etc. For example the 'options' parameter is a common pattern where an object with a set of properties are provided to override a some default behavior. So you need to define a Foo type with a set of properties, and then you need to define a type which is like Foo except all properties are optional. Some frameworks implement their own flavor of inheritance e.g. through mixins. The type of an object with mixins is not just the sum of all properties, you might also have one property overriding a property of a different type in base mixin, so you are adding and removing properties. You need a really powerful type system to be able to represent this.