使用 fp-tsequenceT 时如何“拓宽”阅读器类型？

Question

我想知道使用sequenceT 时是否可以“拓宽”我的最终Reader 类型？当使用 chainW 等顺序链接操作时，这是可能的，但看起来在使用 sequenceT 时，您会遇到每个项目都必须使用相同的 Reader 类型的问题。我想这样做，以便我能够在适当的情况下并行执行某些任务，但仍然能够通过 Reader 使用依赖项注入。

例子：

import { sequenceT } from 'fp-ts/lib/Apply'
import { log } from 'fp-ts/lib/Console'
import { pipe } from 'fp-ts/lib/function'
import * as RT from 'fp-ts/ReaderTask'

interface Person {
  name: string
}

const getMe = (name: string) => (deps: { api: any }) => async (): Promise<Person> => {
  const person = {
    name,
  }
  return person
}

const getMum = (child: Person) => (deps: { api2: any }) => async (): Promise<Person> => {
  const person = {
    name: child.name + "'s mum",
  }
  return person
}

const getDad = (child: Person) => (deps: { api2: any }) => async (): Promise<Person> => {
  const person = {
    name: child.name + "'s dad",
  }
  return person
}

const getFamily = (name: string) => 
  pipe(
    getMe(name),
    RT.chainW(me => 
      sequenceT(RT.readerTask)(
        getMum(me), 
        getDad(me))
    ))

getFamily('John')({ api: 'x', api2: 'y' })().then(
  ([mum, dad]) => {
    log(mum)()
    log(dad)()
  })

编译良好并输出：

$ node dist/src/index.js
{ name: "John's mum" }
{ name: "John's dad" }

现在假设 getDad 依赖于不同的 api，例如 api3。如果我更新代码，它将不再编译，因为 getMum 和 getDad 不使用相同的 Reader 类型。

示例（无法编译）：

import { sequenceT } from 'fp-ts/lib/Apply'
import { log } from 'fp-ts/lib/Console'
import { pipe } from 'fp-ts/lib/function'
import * as RT from 'fp-ts/ReaderTask'

interface Person {
  name: string
}

const getMe = (name: string) => (deps: { api: any }) => async (): Promise<Person> => {
  const person = {
    name,
  }
  return person
}

const getMum = (child: Person) => (deps: { api2: any }) => async (): Promise<Person> => {
  const person = {
    name: child.name + "'s mum",
  }
  return person
}

const getDad = (child: Person) => (deps: { api3: any }) => async (): Promise<Person> => {
  const person = {
    name: child.name + "'s dad",
  }
  return person
}

const getFamily = (name: string) => 
  pipe(
    getMe(name),
    RT.chainW(me => 
      sequenceT(RT.readerTask)(
        getMum(me), // compiler complains here
        getDad(me))
    ))

getFamily('John')({ api: 'x', api2: 'y', api3: 'z' })().then( // compiler complains here, on api3
  ([mum, dad]) => {
    log(mum)()
    log(dad)()
  })

我实际上是用 StateReaderTaskEither 尝试这个，但在这个例子中将其简化为使用 ReaderTask - 然而，sequenceT 也表现出相同的限制。

有什么想法如何解决吗？

Answer 1

这正是目的Reader/ReaderTask/ReaderTaskEither.local！我经常使用这个。例如，如果您并行对 API 进行 HTTP 调用，其中某些 API 需要身份验证令牌 + 基本 URL，而另一些仅需要基本 URL（因此有些interface Auth { token:string, baseUrl: string }使用interface NoAuth { baseUrl: string }.

  interface Apis {
    java: JavaRepository,
    db: DbRepository,
    redis: RedisRepository,
  }
  interface DomainError {}

  declare const javaApiCall: RTE<JavaRepository, DomainError, JavaResult>
  declare const dbApiCall: RTE<DbRepository, DomainError, DbResult>
  declare const redisApiCall: RTE<RedisRepository, DomainError, RedisResult>
  declare const apis: Apis

  const getJava = (apis:Apis) => apis.java
  const getDb = (apis:Apis) => apis.db
  const getRedis = (apis:Apis) => apis.redis

  sequenceT(readerTaskEither)(
    RTE.local(getJava)(javaApiCall),
    RTE.local(getDb)(dbApiCall),
    RTE.local(getRedix)(redisApiCall),
  )(apis) // TaskEither<DomainError, [JavaResult,DbResult,RedisResult]>