fp-ts
effect
Our great sponsors
fp-ts | effect | |
---|---|---|
96 | 25 | |
10,386 | 3,920 | |
- | 16.8% | |
7.5 | 9.9 | |
8 days ago | about 3 hours ago | |
TypeScript | TypeScript | |
MIT License | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
fp-ts
-
Type-Safe Printf() in TypeScript
While I certainly agree, I've found that this is often an indication of too-complex an architecture, and a fundamental re-think being necessary. I've had projects that depend on [fp-ts], which end up incredibly generic-heavy, but still make it entirely through a typecheck(not build- typescript's just worse at that than other tools like esbuild) in seconds-at-worse.
Obviously depends on your organization/project/application, but I do like these things as complexity-smells.
[fp-ts]: https://gcanti.github.io/fp-ts/
-
Introducing fp-utils a functional utility library for Deno / Node
Unlike more comprehensive functional libraries like fp-ts, each module can be imported and resolved separately. If you just need options, simply add the option module and you're good to go.
-
Blog post: graphs and monads with Typescript
While it's quite abstract, I believe it may be useful to those of you who is interested to learn more about functional programming [in Typescript] and also get more intuition on diverse programming ideas. I use fp-ts as a functional programming library there.
-
Functional Programming Library for Golang by IBM
The library for TypeScript that this is influenced by is here:
https://github.com/gcanti/fp-ts
Interesting how both languages with this library converge to a similar syntax, due to heavy use of functions.
-
Is Scala worth learning in 2023?
Learn something that pays the bill first - nowadays it's Golang/Rust react/typescript. Then you can try some pure fp libs like fp-ts and fp-core.rs, and look through existing scala cats docs. If you'll feel bad about it - that's totally fine and expectable, fp takes a paradigm shift and not that many dev able to shift their brains way of thought due to basic psychological rigidity) (inability to change habits and to modify concepts/attitudes once developed). And that's purely a staffing and management issue - folks hired randoms out of the blue, and called 'em a team.
-
Application Bootstrapping with fp-ts
fp-ts, a library that caters to functional programming in TypeScript, comes with some micro-abstractions that already solve a few of our needs.
-
Error Handling Patterns
looks like more ergonomic/focused version of fp-ts[1]
-
To`class` or not to `class`?
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.
-
For Production Users: Haskell in an age of Rust and Python
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.
-
Why I use Typescript nominal types [3via series part 3]
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".
effect
-
A better way to handle errors in JavaScript
Just use a library that already contains this and more functional programming idioms, like fp-ts or its successor, Effect [0]. It is a little more complex to learn but much more robust that simply implementing your own Result and other types.
-
Building React Components Using Unions in TypeScript
effect-ts
- Alternatives to scala FP
-
Functions vs. Procedures: Keep them separate.
But could we manage to achieve the same (avoid the same side-effect pollution), but entirely without handling it through the type system? Could we even manage to do it in JavaScript/TypeScript? Even without Haskell-ist wizardry like effect-ts?
- Javascript futures and Result monads belong together
-
What DI framework are you using?
I inject services with https://github.com/Effect-TS/effect and Layers
-
Introduction
I have chosen fp-ts since it is the tool I am the most familiar with but there are others out there, for example effect-ts.
-
State of Scala.js frameworks
FYI there's a ZIO "port" for Typescript (https://github.com/Effect-TS/core) so if you want, you can still write pure FP code in frontend too. I haven't tried it yet though, I myself am a backend engineer and only play with frontend stuff for personal projects, when I've got some time.
-
The case for TS+
// file: IO.ts export class IO { constructor(readonly io: () => A) {} } export const succeed = (a: A) => new IO(() => a); export const succeedWith = (a: () => A) => new IO(a); export function map(f: (a: A) => B): (self: IO) => IO { return (self: IO) => new IO(() => f(self.io())); } export function flatMap(f: (a: A) => IO): (self: IO) => IO { return (self) => new IO(() => f(self.io()).io()); } export function zip(b: IO): (self: IO) => IO<[A, B]> { return (self) => new IO(() => [self.io(), b.io()]); } export function run(self: IO) { return self.io(); } // file: Function.ts // omitted definition of pipe, long https://github.com/Effect-TS/core/blob/master/packages/system/src/Function/pipe.ts // file: USE.ts import * as IO from "./IO"; import { pipe } from "./Function"; export const program = pipe( IO.succeed(0), IO.map((n) => n + 1), IO.flatMap((r) => IO.succeedWith(() => { console.log(`result: ${r}`); }) ) ); IO.run(program);
-
GraphQL error handling to the max with Typescript, codegen and fp-ts
In order to make our throwing and unsafe APIs into safe data fetching functions, we'll use data types and techniques from the Functional Programming paradigm. In particular, we'll use the fp-ts library (but you can choose the FP library of your choice, e.g. purify, effect, monio, and others).
What are some alternatives?
ramda - :ram: Practical functional Javascript
proposal-pattern-matching - Pattern matching syntax for ECMAScript
purescript - A strongly-typed language that compiles to JavaScript
io-ts - Runtime type system for IO decoding/encoding
TypeScript - TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
immutable-js - Immutable persistent data collections for Javascript which increase efficiency and simplicity.
eslint-plugin-functional - ESLint rules to disable mutation and promote fp in JavaScript and TypeScript.
zod - TypeScript-first schema validation with static type inference
neverthrow - Type-Safe Errors for JS & TypeScript
ts-toolbelt - 👷 TypeScript's largest type utility library
rust - Empowering everyone to build reliable and efficient software.
typing - Python static typing home. Hosts the documentation and a user help forum.