Request for guidance: CancellableTaskEither

[andrewreineke]

I should start by saying that I know approximately zero Category Theory, and this whole thing may be fundamentally misguided.

Intuitively, it seems like what I'm after could be possible given the nature of chain/flatMap/bind, but that is about where my comprehension tapers off.

Ideally, I would like something like this:

import { pipe } from 'fp-ts/lib/function'
import * as IO from 'fp-ts/lib/IO'
import * as TE from 'fp-ts/lib/TaskEither'
import * as CTE from './fp-ts-extensions/CancellableTaskEither'

type User = {}

declare const getUser: (id: string) => TE.TaskEither<'API_ERROR', User>
declare const saveUser: (user: User) => TE.TaskEither<'DB_ERROR', void>

interface Request {
  userId: string
  isCancelled: IO.IO<boolean>
}

type HandleRequestWithCancellation = (
  req: Request
) => TE.TaskEither<'API_ERROR' | 'DB_ERROR' | 'REQUEST_CANCELLED', void>

/**
 * 
 * I would like this to return Left<'REQUEST_CANCELLED'> if the bit flips while
 * `getUser()` is in-flight, without attempting `saveUser()`.
 */
export const handleRequestWithCancellation: HandleRequestWithCancellation = ({
  userId,
  isCancelled,
}) =>
  pipe(
    userId,
    getUser,
    TE.chainW(saveUser),
    CTE.asCancellable(isCancelled, () => 'REQUEST_CANCELLED')
  )

I'm at a bit of a loss for where to start, and wondering if this is even possible. Is there a way to do this and lift an arbitrary TaskEither into something like a CancellableTaskEither with a modified implementation of chain that checks the cancellation predicate first?

We have a large code-base that deals in TaskEither's, and it would be great to opt-in to cancellation in certain contexts. Thanks for any and all guidance!

[waynevanson]

Look into fluture and the bindings called fp-ts-fluture

Flutures look like they can be cancelled.

[gcanti]

@andrewreineke you can check isCancelled before calling saveUser

const REQUEST_CANCELLED = 'REQUEST_CANCELLED' as const

export const handleRequestWithCancellation: HandleRequestWithCancellation = ({ userId, isCancelled }) =>
  pipe(
    getUser(userId),
    TE.chainW((user) =>
      pipe(
        TE.rightIO(isCancelled),
        TE.chainW((b) => (b ? TE.left(REQUEST_CANCELLED) : saveUser(user)))
      )
    )
  )

or using "do notation"

export const handleRequestWithCancellation2: HandleRequestWithCancellation = ({ userId, isCancelled }) =>
  pipe(
    TE.Do,
    TE.bind('user', () => getUser(userId)),
    TE.bind('isCancelled', () => TE.rightIO(isCancelled)),
    TE.chainW(({ isCancelled, user }) => (isCancelled ? TE.left(REQUEST_CANCELLED) : saveUser(user)))
  )

[andrewreineke]

Thanks for the response @gcanti, that makes sense.

I'm wondering if there's a way to accomplish the same but in a black-box fashion (i.e. without touching the implementation of a particular TaskEither)?

For example:

type BigErrorUnion = 'ERR1' | 'ERR2' | 'ERR3' | 'ERR4'
/**
 * An existing function that I don't control the implementation of.
 */
declare const getComplicatedResult: (id: string) => TE.TaskEither<BigErrorUnion, number>

/**
 * Voodoo that's perhaps impossible...
 * Wrap a TaskEither such that any internal calls to `TE.chain{W}` first
 * check `cancelPredicate` and potentially short-circuit with `TE.leftIO(onLeft)`
 */
type WithCancellation = <E2>(
  cancelPredicate: IO.IO<boolean>,
  onLeft: IO.IO<E2>
) => <E, A>(ma: TE.TaskEither<E, A>) => TE.TaskEither<E | E2, A>

const withCancellation: WithCancellation = (cancelPredicate, onLeft) => ma => {
  // Can this function be implemented?
  // I guess the answer is "probably not", since `ma` has already been composed
  // and there's no obvious way to side-load a replacement for
  // internal `TE.chain{W}` calls.

  // But I'm secretly hoping there is some secret Category Theory
  // or FP-wizardry that makes this feasible.

  throw 'NOT_IMPLEMENTED'
}

// (Contextual)
const shouldStop = () => true

// Usage
const cancellableComplicatedResult = pipe(
  'object.123',
  getComplicatedResult,
  withCancellation(shouldStop, () => 'CANCELLED' as const)
)

I think I know the answer, but figured I'd ask here to officially rule out the possibility!

[gcanti]

I guess the answer is "probably not", since ma has already been composed and there's no obvious way to side-load a replacement for internal TE.chain{W} calls.

That's right, unless you control somehow getComplicatedResult.