basic.ts

type MyA = {}

type SomeF<A, B> = (a: A) => [A, B]
type MyF = SomeF<MyA, boolean>

declare const f1: MyF
declare const f2: MyF
declare const f3: MyF

function imperative() {
  const a: MyA = {}

  const [newA1, B1] = f1(a)
  const [newA2, B2] = f2(newA1)
  const [newA3, B3] = f3(newA2)
  // ...N any arbitrary amount

  return [newA3, B1 || B2 || B3]
}

// Desired outcome:
const [AResult, BResult] = magic(f1, f2, f3)(a)

with-effect.ts

type SomeFEff<S, R, E, A, B> = (a: A) => T.Effect<S, R, E, [A, B]>
type MyFEff = SomeFEff<
  unknown,
  unknown,
  unknown,
  MyA,
  boolean
>

declare const f1e: MyFEff
declare const f2e: MyFEff
declare const f3e: MyFEff

function imperativeWithEffect() {
  const a: MyA = {}

  return T.effect.chain(f1e(a), ([newA1, B1]) =>
    T.effect.chain(f2e(newA1), ([newA2, B2]) =>
      T.effect.map(f3e(newA2), ([newA3, B3]) =>
        // ...N any arbitrary amount
        [newA3, B1 || B2 || B3]
      )
    )
  )
}

// Desired outcome:
T.effect.map(magic(f1, f2, f3)(a), ([AResult, BResult]) => ...)