@typed/fx 1.18.4 → 1.20.0

package/src/internal/run.ts

@@ -1,51 +0,0 @@
-import * as Effect from "effect/Effect"
-
-import * as Sink from "../Sink.js"
-import { compileCauseEffectOperatorSink, compileEffectOperatorSink } from "./effect-operator.js"
-import * as helpers from "./helpers.js"
-import { compileSyncOperatorFailureSink, compileSyncOperatorSink } from "./sync-operator.js"
-
-import type { Fx } from "../Fx.js"
-import { matchFxPrimitive } from "./matchers.js"
-
-const constUnit = () => Effect.unit
-
-/**
- * Run an Fx to completion with the provided Sink.
- */
-export function run<R, E, A, R2>(
-  fx: Fx<R, E, A>,
-  sink: Sink.WithContext<R2, E, A>
-): Effect.Effect<R | R2, never, unknown> {
-  return runFx(fx, sink)
-}
-
-const runFx = matchFxPrimitive<Effect.Effect<any, never, unknown>>({
-  Empty: constUnit,
-  Fail: (fx, sink) => sink.onFailure(fx.i0),
-  FromIterable: (fx, sink) => Effect.forEach(fx.i0, sink.onSuccess),
-  FromSink: (fx, sink) => Effect.contextWithEffect((ctx) => fx.i0(Sink.provide(sink, ctx))),
-  Never: () => Effect.never,
-  Succeed: (fx, sink) => sink.onSuccess(fx.i0),
-  Suspend: (fx, sink) => Effect.suspend(() => run(fx.i0(), sink)),
-  Sync: (fx, sink) => Effect.suspend(() => sink.onSuccess(fx.i0())),
-  ToFx: ({ fx }, sink) => run(fx, sink),
-  WithEarlyExit: (fx, sink) =>
-    Effect.contextWithEffect((ctx) =>
-      helpers.withScopedFork((fork, scope) =>
-        helpers.withEarlyExit(Sink.provide(sink, ctx), (sink) => fx.i0({ sink, fork, scope }))
-      )
-    ),
-  WithScopedFork: (fx, sink) =>
-    Effect.contextWithEffect((ctx) =>
-      helpers.withScopedFork((fork, scope) => fx.i0({ sink: Sink.provide(sink, ctx), fork, scope }))
-    ),
-  WithFlattenStrategy: (fx, sink) =>
-    Effect.contextWithEffect((ctx) =>
-      helpers.withFlattenStrategy(fx.i1)((fork, scope) => fx.i0({ sink: Sink.provide(sink, ctx), fork, scope }))
-    ),
-  Transformer: (fx, sink) => run(fx.i0, compileSyncOperatorSink(fx.i1, sink)),
-  TransformerEffect: (fx, sink) => run(fx.i0, compileEffectOperatorSink(fx.i1, sink)),
-  TransformerCause: (fx, sink) => run(fx.i0, compileSyncOperatorFailureSink(fx.i1, sink)),
-  TransformerCauseEffect: (fx, sink) => run(fx.i0, compileCauseEffectOperatorSink(fx.i1, sink))
-})

package/src/internal/schema-ref-subject.ts

@@ -1,163 +0,0 @@
-import type { AST } from "@effect/schema"
-import * as SchemaEquivalence from "@effect/schema/Equivalence"
-import * as Schema from "@effect/schema/Schema"
-import { Option } from "effect"
-import * as Effect from "effect/Effect"
-import type * as Equivalence from "effect/Equivalence"
-import type * as Scope from "effect/Scope"
-import type { Fx, FxInput } from "../Fx.js"
-import type { MakeRefSubject, RefSubject, ToRefSubject } from "../RefSubject.js"
-import { ComputedTypeId, FilteredTypeId, RefSubjectTypeId } from "../TypeId.js"
-import { make, struct } from "./core-ref-subject.js"
-import { map } from "./core.js"
-import { matchFxInput } from "./matchers.js"
-
-const makeSchema = <O>(
-  f: <R, E>(
-    input: FxInput<R, E, O>,
-    eq?: Equivalence.Equivalence<O>
-  ) => Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, any> | ToRefSubject<E, O>>
-): MakeRefSubject<O> => f as any as MakeRefSubject<O>
-
-const memoizeThunk = <A>(f: () => A) => {
-  let memoized: Option.Option<A> = Option.none()
-
-  return () => {
-    if (Option.isNone(memoized)) {
-      memoized = Option.some(f()) as Option.Some<A>
-    }
-
-    return memoized.value
-  }
-}
-
-const defaultSchema = <O>(defaultEq?: Equivalence.Equivalence<O>) =>
-  makeSchema(<R, E>(input: FxInput<R, E, O>, eq?: Equivalence.Equivalence<O>) => make(input, eq || defaultEq))
-
-const go = <O>(
-  ast: AST.AST,
-  getDefaultEq: (ast: AST.AST) => Equivalence.Equivalence<O>
-): MakeRefSubject<O> => {
-  switch (ast._tag) {
-    case "AnyKeyword":
-    case "BigIntKeyword":
-    case "BooleanKeyword":
-    case "Literal":
-    case "Enums":
-    case "NeverKeyword":
-    case "NumberKeyword":
-    case "ObjectKeyword":
-    case "StringKeyword":
-    case "SymbolKeyword":
-    case "TemplateLiteral":
-    case "Tuple":
-    case "UndefinedKeyword":
-    case "UniqueSymbol":
-    case "UnknownKeyword":
-    case "VoidKeyword":
-    case "Union": // TODO: Union should probably be better somehow
-      return defaultSchema<O>(getDefaultEq(ast))
-    case "Lazy": {
-      const get = memoizeThunk(() => go<O>(ast.f(), getDefaultEq))
-
-      return makeSchema((input, eq) => get()(input, eq))
-    }
-    case "Refinement":
-      return go(ast.from, getDefaultEq)
-    case "Transform":
-      return go(ast.to, getDefaultEq)
-    case "Declaration":
-      return go(ast.type, getDefaultEq)
-    case "TypeLiteral": {
-      if (ast.propertySignatures.length === 0) {
-        return defaultSchema<O>(getDefaultEq(ast))
-      }
-
-      const propertySignaturesTypes = ast.propertySignatures.map((propertySignature) =>
-        [propertySignature.name, go<any>(propertySignature.type, getDefaultEq)] as const
-      )
-
-      const makeSubjects = <R, E>(inputs: Record<PropertyKey, FxInput<R, E, any>>) =>
-        Effect.gen(function*(_) {
-          const subjects: any = {}
-          for (const [name, make] of propertySignaturesTypes) {
-            subjects[name] = yield* _(make(inputs[name]))
-          }
-
-          return subjects
-        })
-
-      const makeFxInputs = <R, E>(input: Fx<R, E, O>) => {
-        const types: Record<PropertyKey, FxInput<R, E, any>> = {}
-
-        if (RefSubjectTypeId in input || ComputedTypeId in input || FilteredTypeId in input) {
-          for (const [name] of propertySignaturesTypes) {
-            types[name] = (input as RefSubject<R, E, O>).map((o) => o[name as keyof typeof o])
-          }
-        } else {
-          for (const [name] of propertySignaturesTypes) {
-            types[name] = map(input, (o) => o[name as keyof typeof o])
-          }
-        }
-
-        return types
-      }
-
-      const makeEffectInputs = <R, E>(input: Effect.Effect<R, E, O>) => {
-        const types: Record<PropertyKey, FxInput<R, E, any>> = {}
-
-        for (const [name] of propertySignaturesTypes) {
-          types[name] = Effect.map(input, (o) => o[name as keyof typeof o])
-        }
-
-        return types
-      }
-
-      return makeSchema((input, eq) =>
-        matchFxInput(input, {
-          RefSubject: (source) => {
-            return Effect.map(makeSubjects(makeFxInputs(source)), (subjects) => {
-              const ref = rebuild(subjects) as typeof source
-
-              return Object.assign(subjects, {
-                persist: Effect.tap(Effect.matchCauseEffect(ref, source), () =>
-                  "persist" in source ? (source as RefSubject.Derived<any, any, any, any>).persist : Effect.unit)
-              })
-            })
-          }, // TODO: Expand
-          Fx: (fx) =>
-            makeSubjects(makeFxInputs(fx)),
-          Effect: (effect) => makeSubjects(makeEffectInputs(effect)),
-          Cause: (cause) => makeSubjects(makeEffectInputs(Effect.failCause(cause))),
-          // Shouldn't really happen, but just in case fallback to default Schema
-          Iterable: () => defaultSchema<O>()(input, eq),
-          Otherwise: () => defaultSchema<O>()(input, eq)
-        })
-      )
-    }
-  }
-}
-
-export function fromRefSubject<I, O>(source: Schema.Schema<I, O>): MakeRefSubject<I> {
-  return go<I>(Schema.from(source).ast, (ast) => SchemaEquivalence.from(Schema.make(ast)))
-}
-
-export function toRefSubject<I, O>(source: Schema.Schema<I, O>): MakeRefSubject<O> {
-  return go<O>(Schema.to(source).ast, (ast) => SchemaEquivalence.to(Schema.make(ast)))
-}
-
-const rebuild = (subjects: Record<PropertyKey, any>) => {
-  const output: any = {}
-
-  for (const key of Reflect.ownKeys(subjects)) {
-    const value = subjects[key]
-
-    if (RefSubjectTypeId in value) {
-      output[key] = value
-    } else {
-      output[key] = rebuild(value)
-    }
-  }
-
-  return struct(output)
-}

package/src/internal/versioned-transform.ts

@@ -1,48 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import type { Fx } from "../Fx.js"
-import type { Versioned } from "../Versioned.js"
-import { MulticastEffect } from "./helpers.js"
-import { FxEffectBase } from "./protos.js"
-
-export class VersionedTransform<R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>
-  extends FxEffectBase<R3, E3, C, R0 | R4, E0 | E4, D>
-  implements Versioned<never, never, R3, E3, C, R0 | R4, E0 | E4, D>
-{
-  private _version = 0
-  protected _currentValue: Option.Option<D> = Option.none()
-
-  constructor(
-    readonly input: Versioned<R0, E0, R, E, A, R2, E2, B>,
-    private _transformFx: (fx: Fx<R, E, A>) => Fx<R3, E3, C>,
-    private _transformGet: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R4, E4, D>
-  ) {
-    super()
-  }
-
-  readonly version = Effect.sync(() => this._version)
-
-  toFx() {
-    return this._transformFx(this.input)
-  }
-
-  toEffect(): Effect.Effect<R0 | R4, E0 | E4, D> {
-    // Use MulticastEffect to ensure at most 1 effect is running at a time
-    const update = new MulticastEffect(Effect.gen(this, function*(_) {
-      const x = yield* _(this._transformGet(this.input as any as Effect.Effect<R2, E2, B>))
-
-      this._currentValue = Option.some(x)
-      this._version = yield* _(this.input.version)
-
-      return x
-    }))
-
-    return Effect.gen(this, function*(_) {
-      if (Option.isSome(this._currentValue) && (yield* _(this.input.version)) === this._version) {
-        return this._currentValue.value
-      }
-
-      return yield* _(update)
-    })
-  }
-}