Switch to variadic generics for property and tuple

Recent addition of “Extracting and spreading parameter lists with tuples” in TypeScript - https://blogs.msdn.microsoft.com/typescript/2018/07/12/announcing-typescript-3-0-rc/

It might be used to simplify multiple prebuild scripts.

Unfortunately it might impact the signatures provided for fc.property as rest parameters have to be at the end.

// OK
function call<TS extends any[], R>(fn: (...args: TS) => R, ...args: TS): R {
    return fn(...args);
}
// Not OK
function call2<TS extends any[], R>(...args: TS, fn: (...args: TS) => R): R {
    return fn(...args);
}

[nth-commit]

You can replicate the existing API with the new variadic tuple feature in TS 4.0.

(approximated the existing types, Property and Arbitrary)

type Property<T> = {}

type Arbitrary<T> = {};

type UnwrapArbitrary<T extends Arbitrary<any>> = T extends Arbitrary<infer U> ? U : never;

type UnwrapArbitraries<T extends Array<Arbitrary<unknown>>> = { [P in keyof T]: UnwrapArbitrary<T[P]> };

type PropertyFunction<T extends Array<Arbitrary<unknown>>> = (...args: UnwrapArbitraries<T>) => (boolean | void);

declare function property<T extends Array<Arbitrary<unknown>>>(...args: [...T, PropertyFunction<T>]): Property<UnwrapArbitraries<T>>;

// Examples:

declare const arb0: Arbitrary<number>;
const p0: Property<[number]> = property(arb0, (x0) => {
  const _x0: number = x0;
  return true;
});

declare const arb1: Arbitrary<string>;
const p1: Property<[number, string]> = property(arb0, arb1, (x0, x1) => {
  const _x0: number = x0;
  const _x1: string = x1;
  return true;
});

declare const arb2: Arbitrary<{ foo: string }>;
const p2: Property<[number, string, { foo: string }]> = property(arb0, arb1, arb2, (x0, x1, x2) => {
  const _x0: number = x0;
  const _x1: string = x1;
  const _x2: { foo: string } = x2;
  return true;
});

[dubzzz]

In order to use this new TypeScript feature for fast-check code and get rid of all the unnecessary prebuild scripts, I see two potential alternatives for the signature of property:

• fc.property([arb1, arb2,...], predicate) - not sure it is feasible
• fc.property(predicate, arb1, arb2,...)

I’m not sure I will be able to keep today’s signature and use this feature.