feat(partition): stricter types, add test

[GerkinDev]

No description provided.

[Harris-Miller]

The fn: (a: T) => a is U support is a great addition.

Thank you for removing the string specific overload as well. That was copy/pasted from the original definition over in @types/ramda. I'm not sure why it was needed as the generic overload covers that case as well

Couple things:

The order of the overloads is important, you need to have partition(fn)(list) defined before partition(fn, list). When passing partition to another function, eg flip(partition), typescript asumes the last overload as the most general and uses that

export function partition<T, U extends T>(fn: (a: T) => a is U): {
  <L extends T = T>(list: readonly L[]): [(L & U)[], Exclude<L, U>[]];
  (list: readonly T[]): [(T & U)[], Exclude<T, U>[]];
};

I don't understand the 2 overloads in the middle

• <L extends T = T>(list: readonly L[]): [(L & U)[], Exclude<L, U>[]];
  • What is the generic L accomplishing here?
• (list: readonly T[]): [(T & U)[], Exclude<T, U>[]];
  • The intersection T & U seems extranious. U is already defied to extend T, and therefore is a subset of T. So by definition T & U === T.

[GerkinDev]

• the first overload is required for this test:

  types/test/partition.test.ts

  Line 12 in 8e6cae9

  expectType<[true[], false[]]>(partition((v): v is true => !!v)([true, false]));

  I also added another test with list type resolved at call-time here:

  types/test/partition.test.ts

  Lines 15 to 17 in 8e6cae9

  	const isBool = (v: any): v is boolean => typeof v === 'boolean';
  	const extractBool = partition(isBool);
  	expectType<[boolean[], number[]]>(extractBool([1, true]));

• I removed the useless intersection

[Harris-Miller]

Ah ok, the <L extends T= T> generic makes sense to me now, here is an example that uses an isNumber function: https://tsplay.dev/mpz56w

We actually don't need both of these then:

  <L extends T = T>(list: readonly L[]): [(L & U)[], Exclude<L, U>[]];
  (list: readonly T[]): [(T & U)[], Exclude<T, U>[]];

Just have it be

  <L extends T = T>(list: readonly L[]): [(L & U)[], Exclude<L, U>[]];

I'm glad to know about this trick, there should be many other places where we can apply it

[Harris-Miller]

Turns out that's how filter works, so at least we're consistent now!

[GerkinDev]

FYI, types of rxjs, which have a great implementation of a pipe pattern, are almost all functions retuning generic functions just like this

[Harris-Miller]

re: pipe
rxjs: https://github.com/ReactiveX/rxjs/blob/c66657469dc17fbed992e273d7d121e51c00d671/packages/rxjs/src/internal/util/pipe.ts
ramda: https://github.com/ramda/types/blob/develop/types/pipe.d.ts

They're very close

[GerkinDev]

For pipe, yes, but I was thinking about operators

[Harris-Miller]

Which operators?

[Harris-Miller]

Sorry one last thing, the overloads, both (fn)(arr)s need to be before (fn, arr)
so this:

partition(fn: val is T)(arr)
partition(fn: boolean)(arr)
partition(fn: val is T, arr)
partition(fn: boolean, arr)

The rule is "specific first, general last", and while it doesn't exactly explain it here: https://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html#function-overloads, that does include for currying

[GerkinDev]

partition, map, filter, etc. Almost all of them returns generic unbound unary functions

[Harris-Miller]

While testing this, I discovered a very interesting edge case for isNil: https://tsplay.dev/m3Kpjm

For partition to work correctly with isNil, that will need to be fixed first: #90

[GerkinDev]

What do you need from me to consider this PR as mergeable ?

[Harris-Miller]

What do you need from me to consider this PR as mergeable?

@GerkinDev I merged #90, so

• Rebase on develop
• Re-order the overloads
  • The full signature always needs to come last

[Harris-Miller]

Sorry one last thing, the overloads, both (fn)(arr)s need to be before (fn, arr)
so this:

partition(fn: val is T)(arr)
partition(fn: boolean)(arr)
partition(fn: val is T, arr)
partition(fn: boolean, arr)

The rule is "specific first, general last", and while it doesn't exactly explain it here: https://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html#function-overloads, that does include for currying

[Harris-Miller]

Looks good