@typed/fx 1.17.4 → 1.18.0

package/src/internal/deferred-ref.ts

@@ -0,0 +1,26 @@
+import { Effectable } from "effect"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import type * as Exit from "effect/Exit"
+import * as Option from "effect/Option"
+
+export class DeferredRef<E, A> extends Effectable.Class<never, E, A> {
+  // Keep track of the latest value emitted by the stream
+  private current: Option.Option<Exit.Exit<E, A>> = Option.none()
+
+  constructor(private deferred: Deferred.Deferred<E, A>) {
+    super()
+  }
+
+  commit() {
+    return Effect.suspend(() => Option.getOrElse(this.current, () => Deferred.await(this.deferred)))
+  }
+
+  done(exit: Exit.Exit<E, A>) {
+    return Effect.suspend(() => {
+      this.current = Option.some(exit)
+
+      return Deferred.done(this.deferred, exit)
+    })
+  }
+}

package/src/internal/effect-operator.ts

@@ -0,0 +1,282 @@
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import { WithContext } from "../Sink"
+import type { SyncOperator } from "./sync-operator"
+
+// Effect operators are a subset of operators which can be safely fused together assynchronously
+
+export type EffectOperator =
+  | MapEffect<any, any, any, any>
+  | TapEffect<any, any, any, any>
+  | FilterEffect<any, any, any>
+  | FilterMapEffect<any, any, any, any>
+
+export interface MapEffect<A, R2, E2, B> {
+  readonly _tag: "MapEffect"
+  readonly f: (a: A) => Effect.Effect<R2, E2, B>
+}
+
+export const MapEffect = <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): MapEffect<A, R2, E2, B> => ({
+  _tag: "MapEffect",
+  f
+})
+
+export interface TapEffect<A, R2, E2, B> {
+  readonly _tag: "TapEffect"
+  readonly f: (a: A) => Effect.Effect<R2, E2, B>
+}
+
+export const TapEffect = <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): TapEffect<A, R2, E2, B> => ({
+  _tag: "TapEffect",
+  f
+})
+
+export interface FilterEffect<A, R2, E2> {
+  readonly _tag: "FilterEffect"
+  readonly f: (a: A) => Effect.Effect<R2, E2, boolean>
+}
+
+export const FilterEffect = <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): FilterEffect<A, R2, E2> => ({
+  _tag: "FilterEffect",
+  f
+})
+
+export interface FilterMapEffect<A, R2, E2, B> {
+  readonly _tag: "FilterMapEffect"
+  readonly f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
+}
+
+export const FilterMapEffect = <A, R2, E2, B>(
+  f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
+): FilterMapEffect<A, R2, E2, B> => ({ _tag: "FilterMapEffect", f })
+
+type EffectOperatorFusionMap = {
+  readonly [K in EffectOperator["_tag"]]: {
+    readonly [K2 in EffectOperator["_tag"]]: (
+      op1: Extract<EffectOperator, { readonly _tag: K }>,
+      op2: Extract<EffectOperator, { readonly _tag: K2 }>
+    ) => EffectOperator
+  }
+}
+
+const EffectOperatorFusionMap: EffectOperatorFusionMap = {
+  MapEffect: {
+    MapEffect: (op1, op2) => MapEffect((a: any) => Effect.flatMap(op1.f(a), op2.f)),
+    TapEffect: (op1, op2) => TapEffect((a: any) => Effect.tap(op1.f(a), op2.f)),
+    FilterEffect: (op1, op2) =>
+      FilterMapEffect((a: any) =>
+        Effect.flatMap(
+          op1.f(a),
+          (b) => Effect.map(op2.f(b), (b2) => b2 ? Option.some(b) : Option.none())
+        )
+      ),
+    FilterMapEffect: (op1, op2) => FilterMapEffect((a: any) => Effect.flatMap(op1.f(a), op2.f))
+  },
+  TapEffect: {
+    MapEffect: (op1, op2) => MapEffect((a: any) => Effect.flatMap(op1.f(a), () => op2.f(a))),
+    TapEffect: (op1, op2) => TapEffect((a: any) => Effect.flatMap(op1.f(a), () => op2.f(a))),
+    FilterEffect: (op1, op2) => FilterEffect((a: any) => Effect.flatMap(op1.f(a), () => op2.f(a))),
+    FilterMapEffect: (op1, op2) => FilterMapEffect((a: any) => Effect.flatMap(op1.f(a), () => op2.f(a)))
+  },
+  FilterEffect: {
+    MapEffect: (op1, op2) =>
+      FilterMapEffect((a: any) =>
+        Effect.flatMap(
+          op1.f(a),
+          (b) => b ? Effect.map(op2.f(a), Option.some) : Effect.succeedNone
+        )
+      ),
+    TapEffect: (op1, op2) => FilterEffect((a: any) => Effect.tap(op1.f(a), () => op2.f(a))),
+    FilterEffect: (op1, op2) =>
+      FilterEffect((a: any) =>
+        Effect.zip(
+          op1.f(a),
+          op2.f(a)
+        ).pipe(
+          Effect.map(([b1, b2]) => b1 && b2)
+        )
+      ),
+    FilterMapEffect: (op1, op2) =>
+      FilterMapEffect((a: any) =>
+        Effect.flatMap(
+          op1.f(a),
+          (b) => b ? op2.f(a) : Effect.succeedNone
+        )
+      )
+  },
+  FilterMapEffect: {
+    MapEffect: (op1, op2) =>
+      FilterMapEffect((a: any) =>
+        Effect.flatMap(
+          op1.f(a),
+          Option.match({
+            onNone: () => Effect.succeedNone,
+            onSome: op2.f
+          })
+        )
+      ),
+    TapEffect: (op1, op2) =>
+      FilterMapEffect((a: any) =>
+        Effect.flatMap(
+          op1.f(a),
+          Option.match({
+            onNone: () => Effect.succeedNone,
+            onSome: (b) => op2.f(a).pipe(Effect.map(() => b))
+          })
+        )
+      ),
+    FilterEffect: (op1, op2) =>
+      FilterMapEffect((a: any) =>
+        Effect.flatMap(
+          op1.f(a),
+          Option.match({
+            onNone: () => Effect.succeedNone,
+            onSome: (b) =>
+              op2.f(b)
+                .pipe(
+                  Effect.map((b2) => b2 ? Option.some(b) : Option.none())
+                )
+          })
+        )
+      ),
+    FilterMapEffect: (op1, op2) =>
+      FilterMapEffect((a: any) =>
+        Effect.flatMap(
+          op1.f(a),
+          Option.match({
+            onNone: () => Effect.succeedNone,
+            onSome: (b) => op2.f(b)
+          })
+        )
+      )
+  }
+}
+
+export function fuseEffectOperators(op1: EffectOperator, op2: EffectOperator): EffectOperator {
+  return EffectOperatorFusionMap[op1._tag][op2._tag](op1 as any, op2 as any)
+}
+
+export function liftSyncOperator(op: SyncOperator): EffectOperator {
+  switch (op._tag) {
+    case "Filter":
+      return FilterEffect((a) => Effect.sync(() => op.f(a)))
+    case "FilterMap":
+      return FilterMapEffect((a) => Effect.sync(() => op.f(a)))
+    case "Map":
+      return MapEffect((a) => Effect.sync(() => op.f(a)))
+  }
+}
+
+export function matchEffectOperator<A, B, C, D>(
+  operator: EffectOperator,
+  matchers: {
+    readonly MapEffect: (f: MapEffect<any, any, any, any>) => A
+    readonly TapEffect: (f: TapEffect<any, any, any, any>) => B
+    readonly FilterEffect: (f: FilterEffect<any, any, any>) => C
+    readonly FilterMapEffect: (f: FilterMapEffect<any, any, any, any>) => D
+  }
+): A | B | C | D {
+  switch (operator._tag) {
+    case "MapEffect":
+      return matchers.MapEffect(operator)
+    case "TapEffect":
+      return matchers.TapEffect(operator)
+    case "FilterEffect":
+      return matchers.FilterEffect(operator)
+    case "FilterMapEffect":
+      return matchers.FilterMapEffect(operator)
+  }
+}
+
+export function compileEffectOperatorSink<R>(
+  operator: EffectOperator,
+  sink: WithContext<R, any, any>
+): WithContext<R, any, any> {
+  return matchEffectOperator(operator, {
+    MapEffect: (op) => WithContext(sink.onFailure, (a) => Effect.matchCauseEffect(op.f(a), sink)),
+    FilterEffect: (op) =>
+      WithContext(
+        sink.onFailure,
+        (a) =>
+          Effect.matchCauseEffect(op.f(a), {
+            onFailure: sink.onFailure,
+            onSuccess: (b) => b ? sink.onSuccess(a) : Effect.unit
+          })
+      ),
+    FilterMapEffect: (op) =>
+      WithContext(sink.onFailure, (a) =>
+        Effect.matchCauseEffect(op.f(a), {
+          onFailure: sink.onFailure,
+          onSuccess: Option.match({
+            onNone: () => Effect.unit,
+            onSome: sink.onSuccess
+          })
+        })),
+    TapEffect: (op) => WithContext(sink.onFailure, (a) => Effect.matchCauseEffect(Effect.as(op.f(a), a), sink))
+  })
+}
+
+export function compileCauseEffectOperatorSink<R>(
+  operator: EffectOperator,
+  sink: WithContext<R, any, any>
+): WithContext<R, any, any> {
+  return matchEffectOperator(operator, {
+    MapEffect: (op) =>
+      WithContext(
+        (a) =>
+          Effect.matchCauseEffect(
+            op.f(a),
+            WithContext((cause2) => sink.onFailure(Cause.sequential(a, cause2)), sink.onFailure)
+          ),
+        sink.onSuccess
+      ),
+    FilterEffect: (op) =>
+      WithContext(
+        (a) =>
+          Effect.matchCauseEffect(op.f(a), {
+            onFailure: (cause2) => sink.onFailure(Cause.sequential(a, cause2)),
+            onSuccess: (b) => b ? sink.onFailure(a) : Effect.unit
+          }),
+        sink.onSuccess
+      ),
+    FilterMapEffect: (op) =>
+      WithContext((a) =>
+        Effect.matchCauseEffect(op.f(a), {
+          onFailure: (cause2) => sink.onFailure(Cause.sequential(a, cause2)),
+          onSuccess: Option.match({
+            onNone: () => Effect.unit,
+            onSome: sink.onFailure
+          })
+        }), sink.onSuccess),
+    TapEffect: (op) =>
+      WithContext(
+        (a) =>
+          Effect.matchCauseEffect(
+            Effect.as(op.f(a), a),
+            WithContext((cause2) => sink.onFailure(Cause.sequential(a, cause2)), sink.onFailure)
+          ),
+        sink.onSuccess
+      )
+  })
+}
+
+export function compileEffectLoop<B, A, R2, E2, C>(
+  operator: EffectOperator,
+  loop: (b: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
+): (b: B, i: any) => Effect.Effect<R2, E2, Option.Option<readonly [C, B]>> {
+  return matchEffectOperator(operator, {
+    MapEffect: (op) => (b, i) => Effect.map(Effect.flatMap(op.f(i), (a) => loop(b, a)), Option.some),
+    TapEffect: (op) => (b, i) => Effect.map(Effect.flatMap(op.f(i), () => loop(b, i)), Option.some),
+    FilterEffect: (op) => (b, i) =>
+      Effect.flatMap(op.f(i), (a) => a ? Effect.map(loop(b, i), Option.some) : Effect.succeedNone),
+    FilterMapEffect: (op) => (b, i) =>
+      Effect.flatMap(
+        op.f(i),
+        Option.match({
+          onNone: () => Effect.succeedNone,
+          onSome: (a) => Effect.map(loop(b, a), Option.some)
+        })
+      )
+  })
+}

package/src/internal/effect-primitive.ts

@@ -0,0 +1,230 @@
+import type * as Cause from "effect/Cause"
+import type * as Effect from "effect/Effect"
+import type * as Either from "effect/Either"
+import type * as Exit from "effect/Exit"
+import type * as Fiber from "effect/Fiber"
+import type * as FiberId from "effect/FiberId"
+import type * as FiberStatus from "effect/FiberStatus"
+import type { LazyArg } from "effect/Function"
+import type * as Option from "effect/Option"
+import type * as BlockedRequests from "effect/RequestBlock"
+import type * as RuntimeFlags from "effect/RuntimeFlags"
+import type * as RuntimeFlagsPatch from "effect/RuntimeFlagsPatch"
+
+// -----------------------------------------------------------------------------
+// Effect - very low-level effect primitives
+// NOTE: This probably isn't the greatest decision I've ever made, but I really wanna explore
+// an initial encoding of streams utilizing Effect as the basis with intrinsic interoperation.
+// -----------------------------------------------------------------------------
+
+/** @internal */
+export const EffectTypeId: Effect.EffectTypeId = Symbol.for("effect/Effect") as Effect.EffectTypeId
+
+/**
+ * @internal
+ */
+export type InternalEffect = EffectPrimitive | EffectContinuation
+
+/** @internal */
+export type EffectPrimitive =
+  | Async
+  | Blocked
+  | Commit
+  | Either.Either<any, any>
+  | Failure
+  | FailureWithAnnotation
+  | OpTag
+  | Option.Option<any>
+  | RunBlocked
+  | Success
+  | Sync
+  | UpdateRuntimeFlags
+  | WithRuntime
+  | Yield
+
+/** @internal */
+export type EffectContinuation =
+  | OnSuccess
+  | OnStep
+  | OnSuccessAndFailure
+  | OnFailure
+  | While
+  | RevertFlags
+
+/** @internal */
+export enum OpCodes {
+  OP_ASYNC = "Async",
+  OP_BLOCKED = "Blocked",
+  OP_COMMIT = "Commit",
+  OP_FAILURE = "Failure",
+  OP_FAILURE_WITH_ANNOTATION = "FailureWithAnnotation",
+  OP_ON_FAILURE = "OnFailure",
+  OP_ON_STEP = "OnStep",
+  OP_ON_SUCCESS = "OnSuccess",
+  OP_ON_SUCCESS_AND_FAILURE = "OnSuccessAndFailure",
+  OP_REVERT_FLAGS = "RevertFlags",
+  OP_RUN_BLOCKED = "RunBlocked",
+  OP_SUCCESS = "Success",
+  OP_SYNC = "Sync",
+  OP_TAG = "Tag",
+  OP_UPDATE_RUNTIME_FLAGS = "UpdateRuntimeFlags",
+  OP_WHILE = "While",
+  OP_WITH_RUNTIME = "WithRuntime",
+  OP_YIELD = "Yield"
+}
+
+/** @internal */
+export interface RevertFlags extends Effect.Effect<never, never, never> {
+  readonly _tag: OpCodes.OP_REVERT_FLAGS
+  readonly patch: RuntimeFlagsPatch.RuntimeFlagsPatch
+  readonly op: EffectPrimitive & { _tag: OpCodes.OP_UPDATE_RUNTIME_FLAGS }
+}
+
+/** @internal */
+export type Op<Tag extends string, Body = {}> = Effect.Effect<never, never, never> & Body & {
+  readonly _tag: Tag
+}
+
+/** @internal */
+export interface Async extends
+  Op<OpCodes.OP_ASYNC, {
+    readonly i0: (resume: (effect: EffectPrimitive) => void) => void
+    readonly i1: FiberId.FiberId
+  }>
+{}
+
+/** @internal */
+export interface Blocked<R = any, E = any, A = any> extends
+  Op<OpCodes.OP_BLOCKED, {
+    readonly i0: BlockedRequests.RequestBlock<R>
+    readonly i1: Effect.Effect<R, E, A>
+  }>
+{}
+
+/** @internal */
+export interface RunBlocked<R = any> extends
+  Op<OpCodes.OP_RUN_BLOCKED, {
+    readonly i0: BlockedRequests.RequestBlock<R>
+  }>
+{}
+
+/** @internal */
+export interface Failure extends
+  Op<OpCodes.OP_FAILURE, {
+    readonly i0: Cause.Cause<unknown>
+  }>
+{}
+
+/** @internal */
+export interface FailureWithAnnotation extends
+  Op<OpCodes.OP_FAILURE_WITH_ANNOTATION, {
+    readonly i0: (annotate: <E>(cause: Cause.Cause<E>) => Cause.Cause<E>) => Cause.Cause<unknown>
+  }>
+{}
+
+/** @internal */
+export interface OpTag extends Op<OpCodes.OP_TAG, {}> {}
+
+export interface Commit extends
+  Op<OpCodes.OP_COMMIT, {
+    commit(): Effect.Effect<unknown, unknown, unknown>
+  }>
+{}
+
+/** @internal */
+export interface OnFailure extends
+  Op<OpCodes.OP_ON_FAILURE, {
+    readonly i0: EffectPrimitive
+    readonly i1: (a: Cause.Cause<unknown>) => EffectPrimitive
+  }>
+{}
+
+/** @internal */
+export interface OnSuccess extends
+  Op<OpCodes.OP_ON_SUCCESS, {
+    readonly i0: EffectPrimitive
+    readonly i1: (a: unknown) => EffectPrimitive
+  }>
+{}
+
+/** @internal */
+export interface OnStep extends
+  Op<OpCodes.OP_ON_STEP, {
+    readonly i0: EffectPrimitive
+    readonly i1: (result: Exit.Exit<any, any> | Blocked) => EffectPrimitive
+  }>
+{}
+
+/** @internal */
+export interface OnSuccessAndFailure extends
+  Op<OpCodes.OP_ON_SUCCESS_AND_FAILURE, {
+    readonly i0: EffectPrimitive
+    readonly i1: (a: Cause.Cause<unknown>) => EffectPrimitive
+    readonly i2: (a: unknown) => EffectPrimitive
+  }>
+{}
+
+/** @internal */
+export interface Success extends
+  Op<OpCodes.OP_SUCCESS, {
+    readonly i0: unknown
+  }>
+{}
+
+/** @internal */
+export interface Sync extends
+  Op<OpCodes.OP_SYNC, {
+    readonly i0: LazyArg<unknown>
+  }>
+{}
+
+/** @internal */
+export interface UpdateRuntimeFlags extends
+  Op<OpCodes.OP_UPDATE_RUNTIME_FLAGS, {
+    readonly i0: RuntimeFlagsPatch.RuntimeFlagsPatch
+    readonly i1?: (oldRuntimeFlags: RuntimeFlags.RuntimeFlags) => EffectPrimitive
+  }>
+{}
+
+/** @internal */
+export interface While extends
+  Op<OpCodes.OP_WHILE, {
+    readonly i0: () => boolean
+    readonly i1: () => EffectPrimitive
+    readonly i2: (a: unknown) => void
+  }>
+{}
+
+/** @internal */
+export interface WithRuntime extends
+  Op<OpCodes.OP_WITH_RUNTIME, {
+    readonly i0: (fiber: Fiber.RuntimeFiber<unknown, unknown>, status: FiberStatus.Running) => EffectPrimitive
+  }>
+{}
+
+/** @internal */
+export interface Yield extends Op<OpCodes.OP_YIELD> {}
+
+/**
+ * @internal
+ */
+export function matchEffectPrimitive<B>(
+  effect: InternalEffect,
+  matchers: {
+    readonly Success: (succes: Success) => B
+    readonly Failure: (failure: Failure) => B
+    readonly Sync: (sync: Sync) => B
+    readonly Left: (left: Either.Left<any, any>) => B
+    readonly Right: (right: Either.Right<any, any>) => B
+    readonly Some: (some: Option.Some<any>) => B
+    readonly None: (none: Option.None<any>) => B
+    // We really only care about matching against types we can convert directly into Fx workflows
+    readonly Otherwise: (effect: InternalEffect) => B
+  }
+): B {
+  if (effect._tag in matchers) {
+    return matchers[effect._tag as keyof typeof matchers](effect as any)
+  } else {
+    return matchers.Otherwise(effect)
+  }
+}

package/src/internal/fx-effect-proto.ts

@@ -0,0 +1,56 @@
+import * as Effect from "effect/Effect"
+import type { Fx } from "../Fx"
+import type { Versioned } from "../Versioned"
+import { succeed } from "./core"
+import { FxEffectBase } from "./protos"
+
+/**
+ * Construct a Versioned type.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function makeVersioned<R0, E0, R, E, A, R2, E2, B>(
+  { effect, fx, version }: {
+    version: Effect.Effect<R0, E0, number>
+    fx: Fx<R, E, A>
+    effect: Effect.Effect<R2, E2, B>
+  }
+): Versioned<R0, E0, R, E, A, R2, E2, B> {
+  return new VersionedImpl(version, fx, effect) as any
+}
+
+/**
+ * Construct a Versioned type from a static value.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function versionedOf<A>(value: A): Versioned<never, never, never, never, A, never, never, A> {
+  return makeVersioned({
+    effect: Effect.succeed(value),
+    fx: succeed(value),
+    version: Effect.succeed(1)
+  })
+}
+
+export class VersionedImpl<R0, E0, R, E, A, R2, E2, B> extends FxEffectBase<R, E, A, R2, E2, B>
+  implements Versioned<R0, E0, R, E, A, R2, E2, B>
+{
+  version: Effect.Effect<R0, E0, number>
+
+  constructor(
+    readonly i0: Effect.Effect<R0, E0, number>,
+    readonly i1: Fx<R, E, A>,
+    readonly i2: Effect.Effect<R2, E2, B>
+  ) {
+    super()
+    this.version = i0
+  }
+
+  protected toFx(): Fx<R, E, A> {
+    return this.i1
+  }
+
+  protected toEffect(): Effect.Effect<R2, E2, B> {
+    return this.i2
+  }
+}