4 ms·

Practical introduction to algebraic datatypes (ADTs) in TypeScript

71 points by elnygren 5y ago

benrbray 5y ago
Definitely take a look at fp-ts [1]! It's mentioned at the end of the article, but I want to emphasize just how cool it is. [1] https://github.com/gcanti/fp-ts https://github.com/gcanti/fp-ts
- myvoiceismypass 5y ago
  Another one to look at is effect-ts[1] which is inspired by both fp-ts and also the scala library/framework ZIO [1] https://github.com/Effect-TS/core https://github.com/Effect-TS/core
- douglasisshiny 5y ago
  I know there are a bunch of small guides / articles written by the author of fp-ts, but is there a good book, guide, etc. for diving in for someone who is kind of familiar with functional concepts but not quite ready for going full haskell? A book on haskell?
  - samhh 5y ago
    I've just gone through this process over the last couple of years. To be honest, the most effective learning tool for me was dedicating my free time for a little while to learning Haskell. It's a higher upfront cost but a huge pay-off, not just in terms of understanding fp-ts but more broadly in how you'll be able to view programming through a new lens. That said, I wrote this[1] a year and a half ago for some colleagues just as I was getting into it myself. I hope it helps, and if not let me know if there's anything more specific I could help with. [1] https://samhh.com/blog/js-fp-jargon https://samhh.com/blog/js-fp-jargon
    - douglasisshiny 5y ago
      Much appreciated. I'll be sure to read through the post. I did buy a haskell book (Haskell Programming From First Principles) but haven't had time to read through it. Like you said, while there's a big upfront cost, it seems to be the most effective strategy.
lalaithion 5y ago
I think this article makes the "sum" and "product" terms out to be very complicated, when in fact it's quite simple. If we have two enums enum Bool { True, False } enum Status { Waiting, Successful, Failed } We can combine them into a product type, like a tuple, or a sum type, like a union. type Product = (Bool, Status) type Sum = Bool | Status Now, we ask ourselves, what are the valid values of type Product? (True, Waiting) (True, Successful) (True, Failed) (False, Waiting) (False, Successful) (False, Failed) There are two Bool values, and three Status values, so there are 2×3=6 values for the product of Bool and Status. Now, what about the Sum type? True False Waiting Successful Failed We have 2+3=5 total values for the sum of Bool and Product. Now, obviously, this math doesn't quite work out for types with infinite values, like strings or bigints or arrays, but that's where the analogy comes from. If you extend this further, you can even figure out what an exponential type would be: the exponential type Bool^Status is a function that takes a Status as its argument and returns a Bool.
- ronenlh 5y ago
  The Sum is called Union in the TypeScript docs, as it narrows the valid values to the overlapping elements. In the switch statement it becomes a Sum value (as shown in the article). In ReScript (shown as well, which uses OCaml under the hood) the syntax is that of a Variant, in which each element is a different nominal type.
  - lalaithion 5y ago
    Good point. For example, type NotAProduct = Bool | Bool only has 2 values, not 4. For a real product type, we need type Product = {tag: "Left", value: Bool} | {tag: "Right", value: Bool} which has the requisite 4 values.
    - feoren 5y ago
      This is also called a "discriminated union", with "tag" being the discriminator here.
g_delgado14 5y ago
I spoke about this with Feross Aboukhadijeh last week at SpeakeasyJS: https://www.youtube.com/watch?v=QyunIFfKLIU https://www.youtube.com/watch?v=QyunIFfKLIU
ramesh31 5y ago
The switch case is still a bit redundant and inelegant, particularly considering how out of place switch case syntax feels in a Javascript codebase in general. Early returns are the way to go.
- ducharmdev 5y ago
  Although I don't mind switch statements, I was thinking similarly about using early returns instead. But this is where switch/match expressions like in Rust or C# would really shine; it's too bad JavaScript/Typescript doesn't support them though.
- elnygren 5y ago
  The point of the switch-case is to mimic pattern matching and TS is smart enough tell you whether you handled all cases. Would you prefer that it's a if-elseif-else based structure instead? I guess that would work too but I feel like it could be easier to write it in a way where you accidentally forget to handle some case (since your else / last return is a potential catch-all). I personally don't mind switch-case because I'm so accustomed to it in ReasonML/ReScript already.
- deleted 5y ago
  [deleted]
inssein 5y ago
ADTs like the one described here for remote data is a good start, but I haven’t yet found a good way to compose multiple pieces of data that is in potentially different states. We use another class based concept on top at work where you can compose multiple pieces of remote data together, but it really only works well for the happy path.

71 points by elnygren 5y ago

Definitely take a look at fp-ts [1]! It's mentioned at the end of the article, but I want to emphasize just how cool it is. [1] https://github.com/gcanti/fp-ts https://github.com/gcanti/fp-ts

myvoiceismypass 5y ago
Another one to look at is effect-ts[1] which is inspired by both fp-ts and also the scala library/framework ZIO [1] https://github.com/Effect-TS/core https://github.com/Effect-TS/core
douglasisshiny 5y ago
I know there are a bunch of small guides / articles written by the author of fp-ts, but is there a good book, guide, etc. for diving in for someone who is kind of familiar with functional concepts but not quite ready for going full haskell? A book on haskell?
- samhh 5y ago
  I've just gone through this process over the last couple of years. To be honest, the most effective learning tool for me was dedicating my free time for a little while to learning Haskell. It's a higher upfront cost but a huge pay-off, not just in terms of understanding fp-ts but more broadly in how you'll be able to view programming through a new lens. That said, I wrote this[1] a year and a half ago for some colleagues just as I was getting into it myself. I hope it helps, and if not let me know if there's anything more specific I could help with. [1] https://samhh.com/blog/js-fp-jargon https://samhh.com/blog/js-fp-jargon
  - douglasisshiny 5y ago
    Much appreciated. I'll be sure to read through the post. I did buy a haskell book (Haskell Programming From First Principles) but haven't had time to read through it. Like you said, while there's a big upfront cost, it seems to be the most effective strategy.

lalaithion 5y ago

I think this article makes the "sum" and "product" terms out to be very complicated, when in fact it's quite simple. If we have two enums enum Bool { True, False } enum Status { Waiting, Successful, Failed } We can combine them into a product type, like a tuple, or a sum type, like a union. type Product = (Bool, Status) type Sum = Bool | Status Now, we ask ourselves, what are the valid values of type Product? (True, Waiting) (True, Successful) (True, Failed) (False, Waiting) (False, Successful) (False, Failed) There are two Bool values, and three Status values, so there are 2×3=6 values for the product of Bool and Status. Now, what about the Sum type? True False Waiting Successful Failed We have 2+3=5 total values for the sum of Bool and Product. Now, obviously, this math doesn't quite work out for types with infinite values, like strings or bigints or arrays, but that's where the analogy comes from. If you extend this further, you can even figure out what an exponential type would be: the exponential type Bool^Status is a function that takes a Status as its argument and returns a Bool.

ronenlh 5y ago
The Sum is called Union in the TypeScript docs, as it narrows the valid values to the overlapping elements. In the switch statement it becomes a Sum value (as shown in the article). In ReScript (shown as well, which uses OCaml under the hood) the syntax is that of a Variant, in which each element is a different nominal type.
- lalaithion 5y ago
  Good point. For example, type NotAProduct = Bool | Bool only has 2 values, not 4. For a real product type, we need type Product = {tag: "Left", value: Bool} | {tag: "Right", value: Bool} which has the requisite 4 values.
  - feoren 5y ago
    This is also called a "discriminated union", with "tag" being the discriminator here.

g_delgado14 5y ago

I spoke about this with Feross Aboukhadijeh last week at SpeakeasyJS: https://www.youtube.com/watch?v=QyunIFfKLIU https://www.youtube.com/watch?v=QyunIFfKLIU

ramesh31 5y ago

The switch case is still a bit redundant and inelegant, particularly considering how out of place switch case syntax feels in a Javascript codebase in general. Early returns are the way to go.

ducharmdev 5y ago
Although I don't mind switch statements, I was thinking similarly about using early returns instead. But this is where switch/match expressions like in Rust or C# would really shine; it's too bad JavaScript/Typescript doesn't support them though.
elnygren 5y ago
The point of the switch-case is to mimic pattern matching and TS is smart enough tell you whether you handled all cases. Would you prefer that it's a if-elseif-else based structure instead? I guess that would work too but I feel like it could be easier to write it in a way where you accidentally forget to handle some case (since your else / last return is a potential catch-all). I personally don't mind switch-case because I'm so accustomed to it in ReasonML/ReScript already.
deleted 5y ago
[deleted]

inssein 5y ago

ADTs like the one described here for remote data is a good start, but I haven’t yet found a good way to compose multiple pieces of data that is in potentially different states. We use another class based concept on top at work where you can compose multiple pieces of remote data together, but it really only works well for the happy path.