Referência Rápida de TaskEither

TaskEither = operação assíncrona que pode falhar. Sua forma é () => Promise<Either<E, A>>: a construção é preguiçosa.

Quando Usar

• Você precisa de uma referência rápida de fp-ts para operações assíncronas que podem falhar.
• A tarefa envolve chamadas de API, encapsulamento de Promise, ou composição de pipelines assíncronos de tratamento de erros.
• Você quer uma folha de cola concisa para operadores e padrões TaskEither.

Criar

import * as TE from 'fp-ts/TaskEither'
import * as T from 'fp-ts/Task'

TE.right(value)          // Async success
TE.left(error)           // Async failure
TE.tryCatch(asyncFn, toError)  // Promise → TaskEither
TE.fromEither(either)    // Either → TaskEither

Transformar

TE.map(fn)               // Transform success value
TE.mapLeft(fn)           // Transform error
TE.flatMap(fn)           // Chain (fn returns TaskEither)
TE.orElse(fn)            // Recover from error

Executar

// TaskEither is lazy - must call () to run
const result = await myTaskEither()  // Either<E, A>

// Or pattern match
await pipe(
  myTaskEither,
  TE.match(
    (err) => console.error(err),
    (val) => console.log(val)
  )
)()

Padrões Comuns

import { pipe } from 'fp-ts/function'
import * as TE from 'fp-ts/TaskEither'
import * as T from 'fp-ts/Task'

// Wrap fetch
const fetchUser = (id: string, signal: AbortSignal) => TE.tryCatch(
  async () => {
    const response = await fetch(`/api/users/${encodeURIComponent(id)}`, { signal })
    if (!response.ok) throw new Error(`HTTP ${response.status}`)
    const body: unknown = await response.json()
    return validateUser(body) // Application schema validator; throws on invalid data
  },
  (e) => ({ type: 'NETWORK_ERROR', message: String(e) })
)

// Chain async calls
pipe(
  fetchUser('123', signal),
  TE.flatMap(user => fetchPosts(user.id)),
  TE.map(posts => posts.length)
)

// Parallel calls
import { sequenceT } from 'fp-ts/Apply'
sequenceT(TE.ApplyPar)(
  fetchUser('1', signal),
  fetchPosts('1'),
  fetchComments('1')
)

// With recovery
pipe(
  fetchUser('123', signal),
  TE.orElse(() => TE.right(defaultUser)),
  TE.getOrElse(() => T.of(defaultUser))
)

vs async/await

// ❌ async/await - errors hidden
async function getUser(id: string) {
  try {
    const res = await fetch(`/api/users/${id}`)
    return await res.json()
  } catch (e) {
    return null  // Error info lost
  }
}

// ✅ TaskEither - errors typed and composable
const getUser = (id: string, signal: AbortSignal) => pipe(
  TE.tryCatch(() => fetch(`/api/users/${encodeURIComponent(id)}`, { signal }), toNetworkError),
  TE.flatMap(res => TE.tryCatch(async () => {
    if (!res.ok) throw new Error(`HTTP ${res.status}`)
    return validateUser(await res.json())
  }, toParseError))
)

Use TaskEither quando você precisar de erros tipados para operações assíncronas.

Limitações

• Use esta habilidade apenas quando a tarefa corresponder claramente ao escopo descrito acima.
• Não trate a saída como substituta para validação específica do ambiente, testes ou revisão de especialistas.
• Pare e peça esclarecimentos se faltarem entradas necessárias, permissões, limites de segurança ou critérios de sucesso.

Escopo de Referência

Estes são fragmentos de fp-ts 2.x. Forneça variáveis de aplicação, tipos, validadores e importações, e verifique a versão instalada. map não captura exceções lançadas. Task não tem um canal de erro tipado; uma promise incorretamente encapsulada ainda pode rejeitar. Use tryCatch em limites falíveis.

Forneça um timeout/sinal de abortamento de propriedade do chamador e valide esquemas de resposta. Chamadas de aplicação paralelas precisam de concorrência limitada e autorização para seus dados, custos e efeitos; ApplyPar não cancela o trabalho automaticamente em caso de falha. Callbacks de erro devem redigir segredos e payloads privados.

API Oficial: Módulos fp-ts.