Typing improvement for `letrec` combinator

🚀 Feature Request

Improve typing of tie function in letrec combinator by expanding the type signature with the following, allowing it to read from the generic T.

tie: {
    <K extends keyof T>(key: K): Arbitrary<T[K]>;
    (key: string): Arbitrary<unknown>;
}

// so the full signature becomes:
export declare function letrec<T>(
  builder: (tie: {
    <K extends keyof T>(key: K): Arbitrary<T[K]>;
    (key: string): Arbitrary<unknown>;
  }) => { [K in keyof T]: Arbitrary<T[K]> },
): { [K in keyof T]: Arbitrary<T[K]> };

Motivation

The way how tie function of letrec combinator is typed means that we have to explicitly cast result of each call to that function. This way it is only needed to specify all return types of all arbitraries in T.

Example

For example, reusing letrec tree from docs.

import * as fc from 'fast-check';

const fst = fc.letrec((tie) => ({
  tree: fc.oneof(tie('node'), tie('leaf'), tie('leaf')),
  node: fc.record({
    left: tie('tree'),
    right: tie('tree'),
  }),
  leaf: fc.nat(),
}));

type Tree = number | { left: Tree; right: Tree };
const snd = fc.letrec<{
  tree: Tree;
  node: { left: Tree; right: Tree };
  leaf: number;
}>((tie) => ({
  tree: fc.oneof(tie('node'), tie('leaf'), tie('leaf')),
  node: fc.record({
    left: tie('tree'),
    right: tie('tree'),
  }),
  leaf: fc.nat(),
}));

In the first example, without explicit type specification, it all still defaults to unknown. However, in the second example with explicit type specification, everything becomes well typed.

[dubzzz]

Released in v3! Once again thanks a lot for the help on those typings

[dubzzz]

See comment on #1572, but I may have found a way to make it real for v3 🤞