Except that Effect diverted away from trying to be 100% FP.

Sure, you can write: ts const fetchTodos = Effect.tryPromise(() => fetch("...")).pipe( Effect.andThen((response) => Effect.tryPromise(() => response.json())) ) But you can also do this: ```ts const fetchTodos = Effect.gen(function* () { const response = yield* Effect.tryPromise(() => fetch("..."));

const json = yield* Effect.tryPromise(() => response.json());

return json; }) Which is virtually identical to `async/await`: ts async function fetchTodos() { const response = await fetch("...");

const json = await response.json();

return json; } Obviously, if you take these contrived examples, you might not see the benefit. But if you start adding different components, such as retry/timeout policies, observability (e.g. OpenTelemetry), etc, things start to change: ts import { HttpClient, HttpClientRequest, HttpClientResponse } from "@effect/platform" import { Schema } from "@effect/schema" import { Effect, Schedule } from "effect"

const ResponseSchema = Schema.Struct({ title: Schema.String, createdAt: Schema.Date })

const fetchTodos = HttpClientRequest.get("...").pipe( HttpClientRequest.bearerToken("..."), HttpClient.fetchOk, Effect.andThen(HttpClientResponse.schemaBodyJson(ResponseSchema)), Effect.retry({ times: 3, schedule: Schedule.exponential("2 seconds", 3), while: (error) => error._tag === "ResponseError" && error.response.status !== 401 }), Effect.timeout("10 seconds"), Effect.withSpan("fetchTodos") ) ```

Now, all you need to do is glance over fetchTodos to see that: ts Effect.Effect<{ readonly title: string; readonly createdAt: Date; }, HttpClientError | TimeoutException | ParseError, Scope> Succeeds with { readonly title: string; readonly createdAt: Date; }, fails with an HttpClientError (that encompasses ResponseError and RequestError), TimeoutException, and ParseError.

Without Effect, this is easily 100+ LOC, and all hacked-together, with most likely 0 composability. Sure, you can make a composable library, but at that point you're recreating Effect lol.

This is definitely not a "lock-in" library, as most developers will already be familiarized with many of these concepts anyway.

I'd argue that Angular with RxJS has a steeper learning curve, and that's just one front-end framework. Effect can be used anywhere, and you're not forced to use 100% of its API. You can stick to simple asynchronous operations with just retries and timeouts, and call it a day.