@typed/fx 1.22.2 → 1.24.0

package/src/Form.ts

@@ -56,24 +56,24 @@ export namespace Form {
    * @since 1.18.0
    */
   export interface Base<out R, out E, in out I, in out O, in out Entries extends Form.AnyEntries>
-    extends Versioned.Versioned<R, never, R | Scope.Scope, E | ParseError, I, R, E | ParseError, I>
+    extends Versioned.Versioned<R, never, I, E | ParseError, R | Scope.Scope, I, E | ParseError, R>
   {
     readonly [FormTypeId]: FormTypeId
 
     readonly entries: Entries
 
     readonly schema: S.Schema<
-      R,
+      O,
       I,
-      O
+      R
     >
 
     readonly get: <K extends keyof Entries>(key: K) => Entries[K]
 
     readonly decoded: RefSubject.Computed<
-      R,
+      O,
       E | ParseError,
-      O
+      R
     >
   }
 
@@ -139,9 +139,9 @@ export namespace Form {
    */
   export interface Derived<R, R2, Entries extends AnyEntries> extends Form<R, Entries> {
     readonly persist: Effect.Effect<
-      R2,
+      Output<Entries>,
       Error<Entries>,
-      Output<Entries>
+      R2
     >
   }
 }
@@ -161,17 +161,21 @@ export type MakeForm<
   I extends AnyObject,
   O extends AnyObjectWithKeys<keyof I>
 > = {
-  <R, E>(fx: RefSubject.RefSubject<R, E, O>): Effect.Effect<
-    R | Scope.Scope,
-    never,
+  <E, R>(
+    fx: RefSubject.RefSubject<O, E, R>
+  ): Effect.Effect<
     [DerivedFromIO<R, never, E, I, O>] extends [Form.Derived<infer R, never, infer R2>] ? Form.Derived<R, never, R2>
-      : never
+      : never,
+    never,
+    R | Scope.Scope
   >
 
-  <R, E>(fx: Fx<R, E, O> | Effect.Effect<R, E, O>): Effect.Effect<
-    R | Scope.Scope,
+  <E, R>(
+    fx: Fx<O, E, R> | Effect.Effect<O, E, R>
+  ): Effect.Effect<
+    [FormFromIO<R0, E, I, O>] extends [Form<infer R1, infer R2>] ? Form<R1, R2> : never,
     never,
-    [FormFromIO<R0, E, I, O>] extends [Form<infer R1, infer R2>] ? Form<R1, R2> : never
+    R | Scope.Scope
   >
 }
 
@@ -183,17 +187,21 @@ export type MakeInputForm<
   I extends AnyObject,
   O extends AnyObjectWithKeys<keyof I>
 > = {
-  <R, E>(fx: RefSubject.RefSubject<R, E, I>): Effect.Effect<
-    R | Scope.Scope,
-    never,
+  <E, R>(
+    fx: RefSubject.RefSubject<I, E, R>
+  ): Effect.Effect<
     [DerivedFromIO<R0 | R, never, E, I, O>] extends [Form.Derived<infer R, infer _, infer R2>] ? Form.Derived<R, _, R2>
-      : never
+      : never,
+    never,
+    R | Scope.Scope
   >
 
-  <R, E>(fx: Fx<R, E, I> | Effect.Effect<R, E, I>): Effect.Effect<
-    R | Scope.Scope,
+  <E, R>(
+    fx: Fx<I, E, R> | Effect.Effect<I, E, R>
+  ): Effect.Effect<
+    [FormFromIO<R0, E, I, O>] extends [Form<infer R1, infer R2>] ? Form<R1, R2> : never,
     never,
-    [FormFromIO<R0, E, I, O>] extends [Form<infer R1, infer R2>] ? Form<R1, R2> : never
+    R | Scope.Scope
   >
 }
 
@@ -249,7 +257,7 @@ export function derive<
   R0,
   I extends Partial<Readonly<Record<PropertyKey, any>>>,
   O extends Partial<{ readonly [K in keyof I]: any }>
->(schema: S.Schema<R0, I, O>): MakeForm<R0, I, O> {
+>(schema: S.Schema<O, I, R0>): MakeForm<R0, I, O> {
   return (input) =>
     Effect.map(deriveMakeEntries(input, schema.ast), (entries) => {
       const form = (Form as any)(entries)
@@ -275,8 +283,8 @@ export function deriveInput<
   R0,
   I extends Partial<Readonly<Record<PropertyKey, any>>>,
   O extends Partial<AnyObjectWithKeys<keyof I>>
->(schema: S.Schema<R0, I, O>): MakeInputForm<R0, I, O> {
-  return <R, E>(input: RefSubject.RefSubject<R, E, I> | Fx<R, E, I> | Effect.Effect<R, E, I>) =>
+>(schema: S.Schema<O, I, R0>): MakeInputForm<R0, I, O> {
+  return <E, R>(input: RefSubject.RefSubject<I, E, R> | Fx<I, E, R> | Effect.Effect<I, E, R>) =>
     Effect.map(deriveMakeInputEntries(input, schema.ast), (entries) => {
       const form = (Form as any)(entries)
 
@@ -301,16 +309,16 @@ function isParseError(u: unknown): u is ParseError {
 const parseOptions: ParseOptions = { errors: "all", onExcessProperty: "ignore" }
 
 class FormImpl<Entries extends Form.AnyEntries> extends FxEffectBase<
-  Form.Context<Entries> | Scope.Scope,
+  Form.Input<Entries>,
   Form.Error<Entries> | ParseError,
+  Form.Context<Entries> | Scope.Scope,
   Form.Input<Entries>,
-  Form.Context<Entries>,
   Form.Error<Entries> | ParseError,
-  Form.Input<Entries>
+  Form.Context<Entries>
 > implements Form<Form.Context<Entries>, Entries> {
   readonly [FormTypeId]: FormTypeId = FormTypeId
-  private _fx: Fx<Scope.Scope, ParseError | Form.Error<Entries>, Form.Input<Entries>>
-  readonly version: Effect.Effect<never, never, number>
+  private _fx: Fx<Form.Input<Entries>, ParseError | Form.Error<Entries>, Scope.Scope>
+  readonly version: Effect.Effect<number>
 
   constructor(readonly entries: Entries) {
     super()
@@ -318,17 +326,13 @@ class FormImpl<Entries extends Form.AnyEntries> extends FxEffectBase<
     this.schema = buildSchema(entries)
     this.version = Effect.map(
       // @ts-ignore Infinite type instantiation
-      Effect.all(Object.values(entries).map((e) => e.version)) as Effect.Effect<
-        never,
-        never,
-        ReadonlyArray<number>
-      >,
+      Effect.all(Object.values(entries).map((e) => e.version)) as Effect.Effect<ReadonlyArray<number>>,
       (versions) => versions.reduce((a, b) => a + b, 0)
     )
 
     this._fx = hold(
       core.skipRepeatsWith(
-        core.struct(this.entries as any) as Fx<never, Form.Error<Entries> | ParseError, Form.Input<Entries>>,
+        core.struct(this.entries as any) as Fx<Form.Input<Entries>, Form.Error<Entries> | ParseError>,
         make(S.from(this.schema))
       )
     )
@@ -339,16 +343,12 @@ class FormImpl<Entries extends Form.AnyEntries> extends FxEffectBase<
   schema: Form<Form.Context<Entries>, Entries>["schema"]
 
   run<R3>(
-    sink: Sink.Sink<R3, Form.Error<Entries> | ParseError, Form.Input<Entries>>
-  ): Effect.Effect<R3 | Scope.Scope, never, unknown> {
+    sink: Sink.Sink<Form.Input<Entries>, Form.Error<Entries> | ParseError, R3>
+  ): Effect.Effect<unknown, never, R3 | Scope.Scope> {
     return this._fx.run(sink)
   }
 
-  toEffect(): Effect.Effect<
-    never,
-    Form.Error<Entries> | ParseError,
-    Form.Input<Entries>
-  > {
+  toEffect(): Effect.Effect<Form.Input<Entries>, Form.Error<Entries> | ParseError> {
     return (
       Effect.all(this.entries, { concurrency: "unbounded" }) as any
     )
@@ -362,7 +362,7 @@ class FormImpl<Entries extends Form.AnyEntries> extends FxEffectBase<
 
 function buildSchema<Entries extends Form.AnyEntries>(
   entries: Entries
-): S.Schema<Form.Context<Entries>, Form.Input<Entries>, Form.Output<Entries>> {
+): S.Schema<Form.Output<Entries>, Form.Input<Entries>, Form.Context<Entries>> {
   const schemas: any = {}
 
   for (const key of Reflect.ownKeys(entries)) {
@@ -389,9 +389,9 @@ const deriveMakeEntries = <
   I extends Readonly<Record<PropertyKey, any>>,
   O extends Readonly<Record<keyof I, any>>
 >(
-  input: RefSubject.RefSubject<R, E, O> | Fx<R, E, O> | Effect.Effect<R, E, O>,
+  input: RefSubject.RefSubject<O, E, R> | Fx<O, E, R> | Effect.Effect<O, E, R>,
   ast: AST.AST
-): Effect.Effect<R | Scope.Scope, never, DeriveEntries<R, E, I, O>> =>
+): Effect.Effect<DeriveEntries<R, E, I, O>, never, R | Scope.Scope> =>
   Effect.suspend(() => {
     switch (ast._tag) {
       case "TypeLiteral": {
@@ -418,7 +418,7 @@ const deriveMakeEntries = <
                 FormEntry.derive<any, any, any>({
                   name: prop.name,
                   schema: S.make(ast)
-                })(nested as Fx<R, E, any>)
+                })(nested as Fx<any, E, R>)
               )
             }
           }
@@ -439,9 +439,9 @@ const deriveMakeInputEntries = <
   I extends Readonly<Record<PropertyKey, any>>,
   O extends Readonly<Record<keyof I, any>>
 >(
-  input: RefSubject.RefSubject<R, E, I> | Fx<R, E, I> | Effect.Effect<R, E, I>,
+  input: RefSubject.RefSubject<I, E, R> | Fx<I, E, R> | Effect.Effect<I, E, R>,
   ast: AST.AST
-): Effect.Effect<R | Scope.Scope, never, DeriveEntries<R, E, I, O>> =>
+): Effect.Effect<DeriveEntries<R, E, I, O>, never, R | Scope.Scope> =>
   Effect.suspend(() => {
     switch (ast._tag) {
       case "TypeLiteral": {
@@ -468,7 +468,7 @@ const deriveMakeInputEntries = <
                 FormEntry.deriveInput<any, any, any>({
                   name: prop.name,
                   schema: S.make(ast)
-                })(nested as Fx<R, E, any>)
+                })(nested as Fx<any, E, R>)
               )
             }
           }
@@ -483,13 +483,13 @@ const deriveMakeInputEntries = <
     }
   })
 
-const propOf = <R, E, O>(
+const propOf = <O, E, R>(
   input:
-    | RefSubject.RefSubject<R, E, O>
-    | RefSubject.Computed<R, E, O>
-    | RefSubject.Filtered<R, E, O>
-    | Fx<R, E, O>
-    | Effect.Effect<R, E, O>,
+    | RefSubject.RefSubject<O, E, R>
+    | RefSubject.Computed<O, E, R>
+    | RefSubject.Filtered<O, E, R>
+    | Fx<O, E, R>
+    | Effect.Effect<O, E, R>,
   key: keyof O
 ) => {
   if (TypeId in input) return core.map(input, (o) => o[key])

package/src/FormEntry.ts

@@ -16,10 +16,10 @@ import { ComputedTypeId, RefSubjectTypeId } from "./TypeId.js"
 /**
  * @since 1.18.0
  */
-export interface FormEntry<out R, in out E, in out I, in out O> extends RefSubject.RefSubject<R, E | ParseError, I> {
+export interface FormEntry<out R, in out E, in out I, in out O> extends RefSubject.RefSubject<I, E | ParseError, R> {
   readonly name: PropertyKey
-  readonly schema: Schema.Schema<R, I, O>
-  readonly decoded: RefSubject.Computed<R, E | ParseError, O>
+  readonly schema: Schema.Schema<O, I, R>
+  readonly decoded: RefSubject.Computed<O, E | ParseError, R>
 }
 
 /**
@@ -30,7 +30,7 @@ export namespace FormEntry {
    * @since 1.18.0
    */
   export interface Derived<R, R2, E, I, O> extends FormEntry<R, E, I, O> {
-    readonly persist: Effect.Effect<R2, E | ParseError, O>
+    readonly persist: Effect.Effect<O, E | ParseError, R2>
   }
 }
 
@@ -39,7 +39,7 @@ export namespace FormEntry {
  */
 export interface FormEntryOptions<R, I, O> {
   readonly name: PropertyKey
-  readonly schema: Schema.Schema<R, I, O>
+  readonly schema: Schema.Schema<O, I, R>
 }
 
 /**
@@ -50,11 +50,11 @@ export interface FormEntryOptions<R, I, O> {
  * @since 1.18.0
  */
 export type MakeFormEntry<R0, I, O> = {
-  <R, E>(
-    ref: RefSubject.RefSubject<R, E, O>
-  ): Effect.Effect<R0 | R | Scope.Scope, never, FormEntry.Derived<never, R, E, I, O>>
-  <R, E>(fx: Fx.Fx<R, E, O>): Effect.Effect<R0 | R | Scope.Scope, never, FormEntry<never, E, I, O>>
-  <R, E>(effect: Effect.Effect<R, E, O>): Effect.Effect<R0 | R | Scope.Scope, never, FormEntry<never, E, I, O>>
+  <E, R>(
+    ref: RefSubject.RefSubject<O, E, R>
+  ): Effect.Effect<FormEntry.Derived<never, R, E, I, O>, never, R0 | R | Scope.Scope>
+  <E, R>(fx: Fx.Fx<O, E, R>): Effect.Effect<FormEntry<never, E, I, O>, never, R0 | R | Scope.Scope>
+  <E, R>(effect: Effect.Effect<O, E, R>): Effect.Effect<FormEntry<never, E, I, O>, never, R0 | R | Scope.Scope>
 }
 
 /**
@@ -62,11 +62,11 @@ export type MakeFormEntry<R0, I, O> = {
  * @since 1.20.0
  */
 export type MakeInputFormEntry<R0, I, O> = {
-  <R, E>(
-    ref: RefSubject.RefSubject<R, E, I>
-  ): Effect.Effect<R | Scope.Scope, never, FormEntry.Derived<R0, R, E, I, O>>
-  <R, E>(fx: Fx.Fx<R, E, I>): Effect.Effect<R | Scope.Scope, never, FormEntry<R0, E, I, O>>
-  <R, E>(effect: Effect.Effect<R, E, I>): Effect.Effect<R | Scope.Scope, never, FormEntry<R0, E, I, O>>
+  <E, R>(
+    ref: RefSubject.RefSubject<I, E, R>
+  ): Effect.Effect<FormEntry.Derived<R0, R, E, I, O>, never, R | Scope.Scope>
+  <E, R>(fx: Fx.Fx<I, E, R>): Effect.Effect<FormEntry<R0, E, I, O>, never, R | Scope.Scope>
+  <E, R>(effect: Effect.Effect<I, E, R>): Effect.Effect<FormEntry<R0, E, I, O>, never, R | Scope.Scope>
 }
 
 /**
@@ -75,7 +75,7 @@ export type MakeInputFormEntry<R0, I, O> = {
 export function derive<R, I, O>(options: FormEntryOptions<R, I, O>): MakeFormEntry<R, I, O> {
   const encode = Schema.encode(options.schema)
   const decode = Schema.decode(options.schema)
-  const makeFormEntry = <R2, E>(input: RefSubject.RefSubject<R2, E, O> | Fx.Fx<R2, E, O> | Effect.Effect<R2, E, O>) => {
+  const makeFormEntry = <R2, E>(input: RefSubject.RefSubject<O, E, R2> | Fx.Fx<O, E, R2> | Effect.Effect<O, E, R2>) => {
     const initial = Fx.mapEffect(Effect.isEffect(input) ? Fx.fromEffect(input) : input, (o) => encode(o, parseOptions))
 
     return Effect.map(
@@ -83,8 +83,8 @@ export function derive<R, I, O>(options: FormEntryOptions<R, I, O>): MakeFormEnt
         eq: Equivalence.make(Schema.from(options.schema))
       }),
       (inputRef): FormEntry<R, E, I, O> | FormEntry.Derived<R, R2, E, I, O> => {
-        if (RefSubject.isRefSubject<R2, E, O>(input)) {
-          const persist: Effect.Effect<R | R2, ParseError | E, O> = Effect.flatMap(
+        if (RefSubject.isRefSubject<O, E, R2>(input)) {
+          const persist: Effect.Effect<O, ParseError | E, R | R2> = Effect.flatMap(
             Effect.flatMap(
               inputRef,
               (i) => decode(i, parseOptions)
@@ -113,17 +113,17 @@ export function derive<R, I, O>(options: FormEntryOptions<R, I, O>): MakeFormEnt
  */
 export function deriveInput<R, I, O>(options: FormEntryOptions<R, I, O>): MakeInputFormEntry<R, I, O> {
   const decode = Schema.decode(options.schema)
-  const makeFormEntry = <R2, E>(input: RefSubject.RefSubject<R2, E, I> | Fx.Fx<R2, E, I> | Effect.Effect<R2, E, I>) => {
-    const initial: Fx.Fx<R2, E | ParseError, I> = Effect.isEffect(input) ? Fx.fromEffect(input) : input
+  const makeFormEntry = <R2, E>(input: RefSubject.RefSubject<I, E, R2> | Fx.Fx<I, E, R2> | Effect.Effect<I, E, R2>) => {
+    const initial: Fx.Fx<I, E | ParseError, R2> = Effect.isEffect(input) ? Fx.fromEffect(input) : input
 
     return Effect.map(
       RefSubject.make(initial, { eq: Equivalence.make(Schema.from(options.schema)) }),
       (inputRef): FormEntry<R, E, I, O> | FormEntry.Derived<R, R2, E, I, O> => {
         if (RefSubject.isRefSubject<R2, E, O>(input)) {
-          const persist: Effect.Effect<R | R2, ParseError | E, O> = Effect.flatMap(
+          const persist: Effect.Effect<O, ParseError | E, R | R2> = Effect.flatMap(
             Effect.flatMap(
               inputRef,
-              (i) => RefSubject.set(input as RefSubject.RefSubject<R2, E, I>, i)
+              (i) => RefSubject.set(input as RefSubject.RefSubject<I, E, R2>, i)
             ),
             (i) => decode(i, parseOptions)
           )
@@ -149,21 +149,21 @@ const parseOptions: ParseOptions = {
   onExcessProperty: "ignore"
 }
 
-class FromEntryImpl<R, E, I, O> extends FxEffectBase<R | Scope.Scope, E | ParseError, I, R, ParseError | E, I>
+class FromEntryImpl<R, E, I, O> extends FxEffectBase<I, E | ParseError, R | Scope.Scope, I, ParseError | E, R>
   implements FormEntry<R, E, I, O>
 {
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
 
-  readonly decoded: RefSubject.Computed<R, ParseError | E, O>
-  readonly version: Effect.Effect<never, ParseError | E, number>
-  readonly subscriberCount: Effect.Effect<never, never, number>
-  readonly interrupt: Effect.Effect<never, never, void>
+  readonly decoded: RefSubject.Computed<O, ParseError | E, R>
+  readonly version: Effect.Effect<number, ParseError | E, R>
+  readonly subscriberCount: Effect.Effect<number, never, R>
+  readonly interrupt: Effect.Effect<void, never, R>
 
   constructor(
-    readonly ref: RefSubject.RefSubject<never, E | ParseError, I>,
+    readonly ref: RefSubject.RefSubject<I, E | ParseError, R>,
     readonly name: PropertyKey,
-    readonly schema: Schema.Schema<R, I, O>
+    readonly schema: Schema.Schema<O, I, R>
   ) {
     super()
 
@@ -174,25 +174,25 @@ class FromEntryImpl<R, E, I, O> extends FxEffectBase<R | Scope.Scope, E | ParseE
     this.interrupt = ref.interrupt
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | ParseError, I>): Effect.Effect<R3 | Scope.Scope, never, unknown> {
+  run<R3>(sink: Sink.Sink<I, E | ParseError, R3>): Effect.Effect<unknown, never, R | R3 | Scope.Scope> {
     return this.ref.run(sink)
   }
 
-  toEffect(): Effect.Effect<never, E | ParseError, I> {
+  toEffect(): Effect.Effect<I, E | ParseError, R> {
     return this.ref
   }
 
-  runUpdates<R2, E2, B>(
-    f: (ref: RefSubject.GetSetDelete<never, E | ParseError, I>) => Effect.Effect<R2, E2, B>
-  ): Effect.Effect<R2, E2, B> {
+  runUpdates<B, E2, R2>(
+    f: (ref: RefSubject.GetSetDelete<I, E | ParseError, R>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<B, E2, R | R2> {
     return this.ref.runUpdates(f)
   }
 
-  onFailure(cause: Cause<E | ParseError>): Effect.Effect<never, never, unknown> {
+  onFailure(cause: Cause<E | ParseError>): Effect.Effect<unknown, never, R> {
     return this.ref.onFailure(cause)
   }
 
-  onSuccess(value: I): Effect.Effect<never, never, unknown> {
+  onSuccess(value: I): Effect.Effect<unknown, never, R> {
     return this.ref.onSuccess(value)
   }
 }
@@ -201,10 +201,10 @@ class DerivedFormEntryImpl<R, R2, E, I, O> extends FromEntryImpl<R, E, I, O>
   implements FormEntry.Derived<R, R2, E, I, O>
 {
   constructor(
-    ref: RefSubject.RefSubject<never, E | ParseError, I>,
+    ref: RefSubject.RefSubject<I, E | ParseError>,
     name: PropertyKey,
-    schema: Schema.Schema<R, I, O>,
-    readonly persist: Effect.Effect<R2, E | ParseError, O>
+    schema: Schema.Schema<O, I, R>,
+    readonly persist: Effect.Effect<O, E | ParseError, R2>
   ) {
     super(ref, name, schema)
   }