Add type safety for purry

[somnicattus]

How do you think about this?

Lazy is ignored because I don't know much about it.

concerns

It seems work well with non-generic function types, but not with generic function types... :(

implementations

/** Parameters type when the given Function type is purried. */
export type PurriedParameters<
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    F extends (...args: readonly any[]) => unknown,
> =
    Parameters<F> extends readonly [unknown, ...infer R extends unknown[]]
        ? Parameters<F> | R
        : never;
/** ReturnType when the given Function type is purried and called with the given Parameters type.*/
export type PurriedReturnType<
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    F extends (...args: readonly any[]) => unknown,
    P extends PurriedParameters<F>,
> =
    Parameters<F> extends readonly [infer T, ...unknown[]]
        ? P extends Parameters<F>
            ? ReturnType<F>
            : (value: T) => ReturnType<F>
        : never;

export function purry<
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    F extends (...args: readonly any[]) => ReturnType<F>,
    P extends PurriedParameters<F>,
>(fn: F, args: P): PurriedReturnType<F, P>

usage

function pow<P extends PurriedParameters<typeof Math.pow>>(
    ...args: P
): PurriedReturnType<typeof Math.pow, P> {
    return purry(Math.pow, args);
}

[eranhirsch]

We don't really need a return type for purry because we instead rely on function overloads to define the purried overloaded type (which means purry is only used as an "implementation detail").

For external usage, purry as a tool, I'd still recommend people implement helper functions the same way we do.

So this brings me up to the question of whether a typed purry replaces the way we implement our functions substantially, removing the need to declare overloads to begin with and only typing the dataFirst impl and getting everything else inferred automatically. To answer that question, I think the main problem would be how do we handle generic functions, those that take a <T> for a param. Can you test to see if, for example, this purried type would work with map or filter? Does it still maintain the generic throughout the type?

e.g.

declare function map<T, S>(array: T[], mapper: (item: T) => S): S[];

function purriedMap(...args: PurriedParameters<typeof map>): PurriedReturnType<typeof map> {
  return purry(map, args);
}

// Is x typed properly here?
const result = purriedMap([1,2,3], (x) => x + 1);

// what about here?
const result = pipe([1,2,3], purriedMap((x) => x + 1));

[somnicattus]

But purry is exported and user can optionally use purry for their own functions.

[somnicattus]

I updated the code on the top. How about this?

Maybe no overload is needed with this.

[eranhirsch]

I appreciate your intent, but it just doesn't work for generic functions (and can't as far as my experience with typescript goes).

Here's a playground: https://www.typescriptlang.org/play?#code/JYWwDg9gTgLgBAbzmYYCmcC+cBmUIhwBEUaIaAJgIZEDcAUPWgB6SxwwCe6cACgK5QowSrypQq5GGigBnADz04cAPQq4aWQBtgAOxgBaCsFlUARlrQHdLQzptwAAl3SyAxsLCHN9mCt0QBixgOm7AhlS6nEpwAGIazNK6FLJwABQAdFniAOayAFxwpFQUELpanHCRnADaALoAlHAAvAB8cPy6ANYBAO66ADT07c184pJo0nLyse22aMmpxaXllTWdPRD9A3BZGXo4MnAASglJKR3dfbr1dTEA-GMSUjIKs3AAPicxhTYAbjIGExWNB4C4MAIhCIKMdJoJdAAVbhoRTKNQabR6QzGUwWKw2RIGewYZzI9yebyY-T+QLBULhAzVGLxeaLdJ7XIFIpoEplCpVKL1JptS6bbYxXhnBYXSHCUTjF7TWZDEZPCZTN5zRLSpY8lb8moHI4InZ7DbXW4PPhStliZ6TV4zVoxZSPWEweFI9BOl1wQppP5ULT8NCFBHC9ruz3In3KX5oAFQIEUNBuLTiDA4TpuGDAMrIQRQTio1TqHxYowmcyWay2Il6Eng8moSm+GlBVj0iJRZk2i6ZbJQPKFZZ8yrVIUtSNwqCImPKiV91Ky6F29WOhetNI4XSFWI7TmFXgNI+F6FR2delH7vitZOp9OkXDZ3P5kBUMDyE1wADKW-EEicGG9Q7O+YDoFA-rhGQYYRr+J6-vUQJZroOZ5roBZQpQACyH7yJKrIyme8r2hq8jghAOBwGBrRbjEHJDlyvD0AhK6UBec7ehRVFgTsvDtAgMSkB6s6YUWaS8VUjENAwmCMOiACSqTMBwyIUMg+AQfyAAWMhoPc9BuGUsjwKQsj8Fo8CjGAxEULhYBpDE6JwAAegZyg1AAjDsABMOwAMx1EMyhpMwcEqQA1HA3lOeoyjKG5LFAuivTaVQ8DmBA-DwLppAGUZugmdy5mWT5LTIKgaCOWicWJR53lwH5cCBcFYnQvZaSheFcBRZ5DStc58VDcNCUGTJ9BAA

[somnicattus]

For generic functions, type parameters are needed.

Sorry it had little impact......

https://www.typescriptlang.org/play?ssl=49&ssc=1&pln=28&pc=1#code/JYWwDg9gTgLgBAbzmYYCmcC+cBmUIhwBEUaIaAJgIZEDcAUPWgB6SxwwCe6cACgK5QowSrypQq5GGigBnADz04cAPQq4aWQBtgAOxgBaCsFlUARlrQHdLQzptwAAl3SyAxsLCHN9mCt0QBixgOm7AhlS6nEpwAGIazNK6FLJwABQAdFniAOayAFxwpFQUELpanHCRnADaALoAlHAAvAB8cPy6ANYBAO66ADT07c184pJo0nLyse22aMmpxaXllTWdPRD9A3BZGXo4MnAASglJKR3dfbr1dTEA-GMSUjIKs3AAPicxhTYAbjIGExWNB4C4MAIhCIKMdJoJdAAVbhoRTKNQabR6QzGUwWKw2RIGewYZzI9yebyY-T+QLBULhAzVGLxeaLdJ7XIFIpoEplCpVKL1JptS6bbYxXhnBYXSHCUTjF7TWZDEZPCZTN5zRLSpY8lb8moHI4InZ7DbXW4PPhStliZ6TV4zVoxZSPWEweFI9BOl1wQppP5ULT8NCFBHC9ruz3In3KX5oAFQIEUNBuLTiDA4TpuGDAMrIQRQTio1TqHxYowmcyWay2Il6Eng8moSm+GlBVj0iJRZk2i6ZbJQPKFZZ8yrVIUtSNwqCImPKiV91Ky6F29WOhetNI4XSFWI7TmFXgNI+F6FR2delH7vitZOp9OkXDZ3P5kBUMDyE1wADKW-EEicGG9Q7O+YDoFA-rhGQYYRr+J6-vUQJZroOZ5roBZQpQACyH7yJKrIyme8r2hq8jghAOBwGBX47H+rQ7N+f5pDEHJDlyvD0AhK6UBec7ehRVE0Saf47Lw7QIDEpAerOmFFmkwl0QxVTsQ0DCYIw6IAJKpMwHDIhQyD4BB-IABYyGg9z0G4ZSyPApCyPwWjwKMYDERQuFgCxaLqHAAB6VnKDUACMOwAEw7AAzHUQzKGkzBwXpADUcChTE6LKMoAVcUC6K9KZVDwOYED8PA5mkFZNm6HZ3KOc5YUtMgqBoN5pZZYFcAheFUUxTEblYR5H5pPFiVwClwUNLFbWZTNs2Zdlan0EAA

[somnicattus]

I think PurriedReturnType is somehow not working as PurriedParameters generic with generic function types.

But it would be still useful to support type checking for overloading even if PurriedReturnType was just union type.

export type PurriedReturnType<
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    F extends (...args: readonly any[]) => unknown,
> =
    Parameters<F> extends readonly [infer T, ...unknown[]]
        ? ReturnType<F> | (value: T) => ReturnType<F>
        : never;

[somnicattus]

Hello.

I published remeda-compatible npm package rotery, which expands remeda with Iterators and AsyncIterators support.

https://github.com/somnicattus/rotery/tree/master/src/compositions

In this package I suggested type safe curry and purry.

Can you see how worth it is?

• purry rejects optional parameters and rest parameters by type.
• purry is type safe for overloading.
• overloading is easy with Curried and Purried type.