monocle-ts VS fp-ts

You may be interested also in checking out the implementation of Lens in monocle-ts, one of the libraries in the fp-ts ecosystem

For anyone - anyone who's faffed around with JavaScript's spread syntax when working with nested immutable data, anyway - struggling to understand the general concept or utility of lenses, I'd encourage looking into monocle-ts. The motivation [0] that kicks off the README instantly made me a believer, and TypeScript's idiosyncratic type system makes using the library remarkably natural; it fits right in without needing to deal with anything analogous to Template Haskell.

[0] https://github.com/gcanti/monocle-ts#motivation

You could have a look at the monocle-ts library. It was designed to deal with this kind of problem.

spectacles-ts integrates seamlessly with the fp-ts ecosystem (it's built on top of the excellent monocle-ts library)

lenses help with this quite a bit, check out monocle-ts

looks like more ergonomic/focused version of fp-ts[1]

[1] https://gcanti.github.io/fp-ts/

The approach of checked errors is making a comeback. See Swift, Rust, Kotlin + Arrow.kt, and several takes on it in TypeScript: purify, fp-ts, etc.

Yeah, TypeScript is shockingly good for a language that is so compatible with JavaScript. For example fp-ts. The main problem with TypeScript is pervasive mutability and side-effects.

Back at my last job I was lucky enough to stumble upon some pretty awesome colleagues thanks to which I found even greater depths in Typescript which cemented the love even more. We used FP-TS to rewrite a legacy Feathers.js application and I learned many principles I later applied to my own full-stack "framework".

Those familiar with more functional languages might be screaming about monads at their screens now. Indeed, if we want to go a step further than using discriminated unions, we can apply Either monads. Those come with a whole lot of useful tooling with them, like the possibility of monadic pattern matching and chaining operations. We have good experiences of using fp-ts in my team at Swappie, and even thought the initial learning curve can be steep, the benefits are useful. You can read more about monads in various blog posts all over the web, this one being a good example of Either specifically.

It's not just the ADTs but the exhaustive pattern matching that help make sure you've covered all of the cases in your ADT. You'll see JavaScripters use objects as a poor man's ADT where they'll use the key name as a the constructor or a { tag: key, ... }, but that has caveats (aside from feeling less first-class): 1) JavaScript can't do exhaustive pattern matching so you'll always need to handle null cases, 2) checks must all happen at runtime which means you'll end up having to throw/catch exceptions and nothing will hold your hand to say that you've missed a case. TypeScripters can handle 1 & 2 for safety, but the ergonomics are bad and verbose so you'll see a lot of folks skip it. Similar languages will have pattern matching, safety, but lack the lightweight/dense ergonomics. When you dive into a language in the ML family (Haskell, OCaml, Standard ML, et. al.), the ergonomics make you want to use them, and they are idiomatic to the ecosystem and you'll want to use them for just about everything--either the ones in the Preludes/stdlib like Maybe, Either, List, etc. or by building them yourself.

An example in the wild that demonstrates this `fp-ts`'s explanation of how to do ADTs in TypeScript where you can see the comparison in PureScript is a one-liner: https://github.com/gcanti/fp-ts/blob/master/docs/guides/pure...

I use fp-ts with its Result type, works great.

https://gcanti.github.io/fp-ts/

Why not just https://gcanti.github.io/fp-ts/?