fp-ts

I was (still am) a huge fan of fp-ts [1], which, in effect, was rolled into the Effect-TS ecosystem. And I'm still bummed TS+ [2] didn't work out, because I've never managed to love Effect-TS the way I loved fp-ts. Maybe it's the lack of tacit function calling, the conventions, AI/modern-marketing push, or simply the daunting scope and scale (even more so with v4). Still, despite my gripes, if you're willing to spend the time and effort, it's the safest and most elegant way to write TypeScript. Plus, it's now dependency-free, and the increasingly good LSP/editor support removes a lot of the friction that used to come with completions and diagnostics. [1] https://github.com/gcanti/fp-ts [2] https://effect.website/blog/ts-plus-postmortem

If you are interested in this kind of things, also have a look at fp-ts and it’s version of pipe and flow. Also comes with various monads to play around with! [1] https://github.com/gcanti/fp-ts

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, OC

This is great, thanks for sharing. I'm currently using @arrows/composition https://caderek.github.io/arrows/packages/composition/#pipe because of the light way library approach, which you seem to share. I also try fp-ts https://github.com/gcanti/fp-ts but is a bit an academic style, so difficult to introduce in everyday work. Implementation of pipe: https://gcanti.github.io/fp-ts/modules/function.ts.html#pipe I still need to wrap my head on your use of generics, but yours looks more flexible than the static type approach that other libraries (include RxJS) implements, does your pipe support types for any length of arguments? Does require a specific version of TypeScript? Nice work.

That looks interesting, I hadn't heard of the project. Will definitely have a look at the library. But it defines its pipe function the same way RXJS does, separately for any number of arguments: function pipe<A>(a: A): A function pipe<A, B>(a: A, ab: (a: A) => B): B function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D ... https://github.com/gcanti/fp-ts/blob/master/src/function.ts#...

Hi Everyone, I am not here to start a debate about OOPS vs Functional programming. So if you are not doing functional programming and don't like it simply ignore this thread. This thread is for everyone who uses functional programming in their day to day life and have gone through the struggle of building mental models about functional way of doing things. I am not looking for a guide to learn haskell syntax and any other programming syntax. I am looking for how to really learn functional programming how to build the mental models in order to think functionally. So that even if a language is not functional by nature, I can model my functions and data in functional way of building programs. I myself write JS and Typescript for living and i came across this library https://github.com/gcanti/fp-ts But not even 1% of this library make sense

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

See https://github.com/gcanti/fp-ts. Heavily haskell-inspired and includes a TS implementation of higher-kinded types.

https://github.com/gcanti/fp-ts https://github.com/gcanti/io-ts If you're using TS these are pretty much footgun eliminator.

I'm surprised the list doesn't mention untyped-exception and how to deal with the inability to figure out the type from the catch block. Untyped exception in TypeScript is one of the most vulnerable point of static type escapes. Unlike any, which is explicit, exception caught in catch block is implicit. Personally I prefer to wrap catches into a specific type/symbol `UnknownError { data: unknown }`, and discriminated union to indicate success/failure on return. fp-ts (https://github.com/gcanti/fp-ts) is my go-to library for this

Yes, in fact this reminds me of the HKT implementation[1] found in fp-ts[2][3] interface HKT<F, A> { _URI: F _A: A } interface Mappable<F> { map<A, B>(f: (a: A) => B, fa: HKT<F, A>): HKT<F, B> } where F is a unique identifier representing the type constructor and A its type parameter. [1]: https://www.cl.cam.ac.uk/~jdy22/papers/lightweight-higher-ki... [2]: https://github.com/gcanti/fp-ts [3]: https://gist.github.com/gcanti/2b455c5008c2e1674ab3e8d5790cd...

In functional programming the Option type exists to make the 'literally no value' case more explicit. https://en.m.wikipedia.org/wiki/Option_type If you are using TypeScript (TFA mentions it), fp-ts provides a good functional programming layer. Although if you aren't already familiar with functional programming it's going to be hard as the documentation is rather lacking. https://github.com/gcanti/fp-ts/blob/master/src/Option.ts

That's helpful, thanks. The recent syntax switch[1] does feel like it will further fragment the community. And TypeScript has some pretty attractive functional projects: https://github.com/gcanti/fp-ts https://github.com/Matechs-Garage/matechs-effect [1]: https://reasonml.org/blog/bucklescript-8-1-new-syntax