import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Effectable from "effect/Effectable";
export type EffectClass<Shape, A, Err = never, Req = never> = Effect.Effect<A, Err, Req> & {
new (_: never): Shape;
};
export const effectClass: {
<A, Err = never, Req = never>(impl: Effect.Effect<A, Err, Req>): EffectClass<A, A, Err, Req>;
<Shape>(): <A, Err = never, Req = never>(
impl: Effect.Effect<A, Err, Req>,
) => EffectClass<Shape, A, Err, Req>;
} = ((impl?: any) =>
impl === undefined
? (innerImpl: any) => effectClass(innerImpl)
: (Object.assign(
class {},
// Spreading the Effect prototype onto the class (static side) makes the
// class itself a real Effect — `Effect.isEffect(X)` is true, so
// `Effect.all([X])` / `Effect.forEach` work — and subclasses
// (`class Y extends effectClass(impl)`) inherit the protocol statically.
Effectable.Prototype({
label: "alchemy/EffectClass",
evaluate: () => impl,
}),
) as unknown as EffectClass<any, any, any, any>)) as any;
export const taggedFunction = <
Tag extends Context.ServiceClass<any, any, any>,
Fn extends (...args: any[]) => any,
>(
tag: Tag,
fn: Fn,
): Tag & Fn => {
// The Proxy below forwards every Effect-protocol key to `tag` (already an
// Effect), so `asEffect`/`[Symbol.iterator]`/`pipe` need no explicit
// override — only `toString` diverges.
const overrides = {
toString: () => `${tag.toString()}.${fn.name}`,
};
return new Proxy(fn, {
get: (target, prop, receiver) =>
Reflect.has(overrides, prop)
? Reflect.get(overrides, prop, receiver)
: Reflect.has(target, prop)
? Reflect.get(target, prop, receiver)
: Reflect.get(tag as object, prop, tag),
has: (target, prop) =>
Reflect.has(overrides, prop) || Reflect.has(target, prop) || Reflect.has(tag as object, prop),
}) as Tag & Fn;
};
export const isYieldableEffect = (
value: unknown,
): value is Effect.Effect<unknown, unknown, unknown> =>
Effect.isEffect(value) &&
typeof (value as any as { [Symbol.iterator]?: unknown })[Symbol.iterator] === "function";
export type YieldableEffectLike<A = unknown, E = unknown, R = unknown> =
| Effect.Effect<A, E, R>
| {
asEffect: () => Effect.Effect<A, E, R>;
[Symbol.iterator]: () => Iterator<unknown>;
};
export const isEffectClassLike = (value: unknown): value is YieldableEffectLike =>
typeof value === "function" && typeof (value as { asEffect?: unknown }).asEffect === "function";
export const isYieldableEffectLike = (value: unknown): value is YieldableEffectLike =>
(isYieldableEffect(value) || isEffectClassLike(value)) && !("~alchemy/Kind" in value);
export type UnwrapEffect<T> = T extends Effect.Effect<infer A, any, any> ? A : T;
export type ToEffectInterface<T> = {
raw: T;
} & {
[K in keyof T]: T[K] extends (...args: any[]) => any
? (...args: Parameters<T[K]>) => Effect.Effect<Awaited<ReturnType<T[K]>>>
: T[K];
};
export const toEffectInterface = <T extends object>(raw: T) =>
({
raw,
...Object.fromEntries(
Object.entries(raw).map(([key, value]) => [
key,
typeof value === "function"
? (...args: any[]) => Effect.tryPromise(async () => value(...args))
: value,
]),
),
}) as ToEffectInterface<T>;