effect
Pyrsistent
Our great sponsors
effect | Pyrsistent | |
---|---|---|
25 | 6 | |
3,801 | 1,968 | |
14.2% | - | |
9.9 | 7.2 | |
6 days ago | 2 months ago | |
TypeScript | Python | |
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.
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).
Pyrsistent
-
Text Parsing: Now You Have Three Problems (David Beazley)
There are python libraries that implement Clojure style functional data types. Have you tried pyrsistent - https://github.com/tobgu/pyrsistent
-
What are some amazing, great python external modules, libraries to explore?
Hissp is really interesting. Read through the docs and you'll understand Python more deeply. It works well with Toolz and Pyrsistent.
-
Hello, HPy
It still is, and Cython is great for accelerating critical Python code.
A C extension is far preferable when you want to code in C, either to write a new data type[1], or write a Python frontend to a C library[2] that is too complex to be well supported by simple FFI.
I think people use Cython more internally when they value the maintainability of "mostly Python" over the fact that it's slower than what native C would get them.
-
Toolz: A functional standard library for Python
There's Pyrsistent[1], which provides persistent data structures.
What are some alternatives?
fp-ts - Functional programming in TypeScript
Toolz - A functional standard library for Python.
fn.py - Functional programming in Python: implementation of missing features to enjoy FP
funcy - A fancy and practical functional tools
Coconut - Simple, elegant, Pythonic functional programming.
CyToolz - Cython implementation of Toolz: High performance functional utilities
effect - effect isolation in Python, to facilitate more purely functional code
Deal - 🤝 Design by contract for Python. Write bug-free code. Add a few decorators, get static analysis and tests for free.
returns - Make your functions return something meaningful, typed, and safe!
classes - Smart, pythonic, ad-hoc, typed polymorphism for Python
pratica - 🥃 Functional Algebraic Data Types
tyrian - Elm-inspired Scala UI library.