@effect/io

What is @effect/io?

@effect/io is a library for building robust, type-safe, and composable applications in TypeScript. It provides a powerful set of tools for managing side effects, concurrency, and error handling in a functional programming style.

What are @effect/io's main functionalities?

Effect Management

This feature allows you to create and manage effects, which are computations that can produce values or perform side effects. The example demonstrates creating a simple effect that succeeds with the value 42 and then running it.

const { Effect } = require('@effect/io');

const effect = Effect.succeed(42);
effect.run().then(console.log); // Outputs: 42

Error Handling

This feature provides robust error handling capabilities. The example shows how to create an effect that fails with an error and how to handle that error when running the effect.

const { Effect } = require('@effect/io');

const effect = Effect.fail(new Error('Something went wrong'));
effect.run().catch(console.error); // Outputs: Error: Something went wrong

Concurrency

This feature allows you to compose and run effects concurrently. The example demonstrates combining two effects that succeed with values 1 and 2, respectively, and running them together.

const { Effect } = require('@effect/io');

const effect1 = Effect.succeed(1);
const effect2 = Effect.succeed(2);
const combinedEffect = Effect.zip(effect1, effect2);
combinedEffect.run().then(console.log); // Outputs: [1, 2]

Resource Management

This feature provides tools for managing resources that need to be acquired and released. The example shows how to create a resource, use it in an effect, and ensure that cleanup is performed afterward.

const { Effect, Resource } = require('@effect/io');

const resource = Resource.make(
  Effect.succeed('resource'),
  () => Effect.succeed(console.log('cleanup'))
);

resource.use(res => Effect.succeed(console.log(res))).run(); // Outputs: 'resource' and then 'cleanup'

Other packages similar to @effect/io

rxjs

RxJS is a library for reactive programming using Observables, to make it easier to compose asynchronous or callback-based code. Compared to @effect/io, RxJS focuses more on reactive streams and less on effect management and resource handling.

fp-ts

fp-ts is a library for functional programming in TypeScript. It provides many of the same functional programming constructs as @effect/io, but it is more focused on providing a comprehensive suite of functional programming utilities rather than specifically managing effects and concurrency.

redux-saga

redux-saga is a library that aims to make application side effects (e.g., asynchronous actions) easier to manage, more efficient to execute, and better at handling failures. It uses generator functions to handle side effects in a Redux application. While it shares some similarities with @effect/io in terms of managing side effects, it is more tightly coupled with Redux and less general-purpose.

README

WIP.

Docs: https://effect-ts.github.io/io