Typescript：为类似 reducer 的函数键入组合器

Question

Consider the following types

type Reducer<S, A> = Red<S, A, A>
type Red<S, C, A> = (s: S) => (c: C) => A

and the following function

// The type intended for `reds` is
//     `{ [k in keyof P]: Red<S, P, P[k]> }`
// for fixed `S` and `P`

const combinator: ??? = reds =>
  step => acc =>
    {
      const result = {}

      for (const key in reds) {
        result[key] = reds[key](step)(acc)
      }

      return result
    }

Now consider the following application (in ts) of this function:

const reducer = combinator({
  first: (s: "S") => ({ first, second }) => {
    // *1
    return "whatever"
  },
  second: (s: "S") => ({ first, second }) => {
    // *1
    return 5
  },
})

Question: How can we define a type for the function combinator in typescript such that

1. The const reducer has type Reducer<"S", { first: "whatever", second: 5 }>
2. In the scope of the lines marked with // *1 the types of first and second are correctly inferred as first: "whatever" and second: 5

In short: What should we put in the following code in place of ???

const combinator: ??? = reds => { ... }

[Remark]: I posted a partial solution. Maybe it helps as a starting point?

---

edit:

The motivation for the combinator is to allow for parallel reducing with mutually referencing reducers. The use case I have in mind is compiling an AST. But to keep it simpler: Here's a contrived example :

const combinator = reds =>
  step => acc =>
    {
      const result = {}

      for (const key in reds) {
        result[key] = reds[key](step)(acc)
      }

      return result
    }

const reduce = arr => ({ init, red }) =>
  {
    let acc = init

    for (const step of arr) {
      acc = red(step)(acc)
    }

    return acc
  }

const exampleInput = [
  "some line",
  "some other line",
  "yet another line",
]

const exampleReducer = combinator({
  textWithLengths:
    line => ({ textWithLengths, totalLength }) =>
      textWithLengths + "\n" + `${totalLength} -- ${line}`,
  totalLength:
    line => ({ totalLength }) =>
      totalLength + line.length,
  startsWithSame:
    line => ({ startsWithSame, previousLine }) =>
      [...startsWithSame, previousLine.charAt(0) === line.charAt(0)],
  previousLine:
    line => _ =>
      line
})

const exampleInit = {
  textWithLengths: "",
  totalLength: 0,
  startsWithSame: [],
  previousLine: "",
}

const exampleResult = reduce(exampleInput)({
  init: exampleInit,
  red: exampleReducer
})

console.log(exampleResult.textWithLengths)
console.log(exampleResult.startsWithSame)

The output will be

// console.log(exampleResult.textWithLengths)

0 -- some line
9 -- some other line
24 -- yet another line
[ false, true, false ]

// console.log(exampleResult.startsWithSame)
[ false, true, false ]

Answer 1

I think the definition of types is a little bit convoluted. I don't know if you have "collateral" requirements, given the other code, but, evaluated in a vacuum, something like this could work (untested, except for type coercion):

const exampleInput = [
    "some line",
    "some other line",
    "yet another line",
]

interface Aggr {
    textWithLengths: string;
    totalLength: number;
    startsWithSame: boolean[];
    previousLine: string;
}

const exampleInit: Aggr = {
    textWithLengths: "",
    totalLength: 0,
    startsWithSame: [],
    previousLine: "",
}

type Reducers<TInput, TOutput> = {
    [k in keyof TOutput]: (input: TInput, aggr: TOutput) => TOutput[k];
};

const reduce = function <TInput, TOutput>(
    input: TInput[],
    init: TOutput,
    reducers: Reducers<TInput, TOutput>
) {
    let acc = init;
    const reducerNames = Object.keys(reducers);
    for (const item of input) {
        const newAcc: any = {};

        for (const reducerName of reducerNames) {
            const red = (reducers as any)[reducerName];
            newAcc[reducerName] = red(item, acc);
        }

        acc = newAcc as TOutput;
    }

    return acc;
};

// types can be implicitly checked
const result = reduce<string, Aggr>(exampleInput, exampleInit, {
    textWithLengths: (line, aggr) =>
        aggr.textWithLengths + "\n" + `${aggr.totalLength} -- ${line}`,
    totalLength: (line, aggr) => aggr.totalLength + line.length,
    startsWithSame: (line, aggr) => [
        ...aggr.startsWithSame,
        aggr.previousLine.charAt(0) === line.charAt(0),
    ],
    previousLine: (line) => line,
});

console.log(result.textWithLengths)
console.log(result.startsWithSame)

Instead of TInput[] , you could use another interface, like Iterator<TInput> .

Edit: I updated the code fixing some type mismatches inside reduce and tested it here . Seems fine to me.

Answer 2

Here's a partial solution . But it's not the full answer: The problem is that at the marked places in the code (at *1 , *2 ), the types of first and second are not inferred correctly. We only get first: any and second: any while it should be first: 1 and second: 2 .

type Red<S, C, A> = (s: S) => (c: C) => A
type Reducer<S, A> = Red<S, A, A>


type Target<R extends Red<any, any, any>> = 
    R extends Red<any, any, infer S>
        ? S
        : ["this should not happen: could not infer target type of reducer", R]


type CombinedTarget<Reds extends { [k: string]: Red<any, any, any> }> =
    { [k in keyof Reds]: Target<Reds[k]> }


const combinator = <S, Reds extends { [k: string]: Red<S, any, any> }>(
    reds: Reds
    ): Reducer<S, CombinedTarget<Reds>> =>
        (s: S) => (p: CombinedTarget<Reds>) =>
            {
                const result: Partial<CombinedTarget<Reds>> = {}

                for (const key in reds) {
                    result[key] = reds[key](s)(p)
                }

                return result as CombinedTarget<Reds>
            }


const result = combinator({
    first: (s: "S") => ({ first, second }) => {
        // *1
        return 1 as 1
    },
    second: (s: "S") => ({ first, second }) => {
        // *2
        return 2 as 2
    },
})