Removal of Placeholder / __ support for curried functions

[Harris-Miller]

The Problem

Over the last 6 months of revamping the type definitions for ramda, the support for Placeholder/__ has been one of the single most challenging parts

There are 3 things in particular that have been of major hindrance

• Support for 3+ arity function
• When Placeholder satisfies the argument type
• Type error feedback

Support for 3+ arity function

This is the most obvious. Just look at the type definition for this PR. Supporting these are just difficult. They also make the intellisense extremely confusing

Using the PR for assoc above as an example, there are 7 overloads with support for Placeholder, and only 3 if I were to remove them

Support when Placeholder satisfies the argument type

This one is less obvious but quite annoying. Placeholder can satisfy the argument type sometimes, particularly PropertyKey which is used a lot. Also any

This means that you have to disclude Placeholder in some types of definitions and it gets very messy

declare function prop<K extends PropertyKey>(prop: K): <U extends Record<K, any>>(obj: U) => U[K];
const obj: Record<string, number> = {};
prop(__)(obj); // this does not throw an error!

// fix by disallowing `Placeholder`
declare function prop<K extends PropertyKey>(prop: K extends Placeholder ? never : K): <U extends Record<K, any>>(obj: U) => U[K];
const obj: Record<string, number> = {};
prop(__)(obj); // type error: Argument of type 'Placeholder' is not assignable to parameter of type 'never'

I'm not actually sure how many places the above example is true for with the current type definitions we have, but I'm willing to be it is a lot. It's not great to have

Type error feedback
This one is also less obvious, but very annoying. When you have a function that includes an overload with a Placeholder, if you call that function and get a type error, the error that gets displayed is for the first overload, even if the one you were trying to use was the second.

This is because the Placeholder overload needs to come first

declare function prop<U>(__: Placeholder, obj: U): <K extends keyof U>(prop: K) => U[K];
declare function prop<U, K extends keyof U>(prop: K, obj: U): U[K];

const obj = { foo: 1, bar: 2 };
prop('unknownKey', obj); // type error

The error you see for this situation displays as

It is difficult to make out what is going on because you are getting an error display for both overloads, and the Placeholder one comes first. This can be especially challenging for less experienced Typescript developers

If I were to remove the Placeholder overload you would get this instead

The error here is very clear and to the point

The Solution

Removing typescript support for Placeholder/__` overloads for all curried types I think will be beneficial in the long run for ramda's typings.

First, so it is very clear, I have no intention of removing curried types, just those with the Placeholder type

import { Placeholder } from './util/tools';

export function divide(a: number): (b: number) => number;
export function divide(__: Placeholder, b: number): (a: number) => number;
export function divide(a: number, b: number): number;

Will become

export function divide(a: number): (b: number) => number;
export function divide(a: number, b: number): number;

This will, for the most part, remove 2 general use-cases, however both can be remedied with the use of arrow functions

The first use-case being creating stand-alone functions from ramda functions

// no longer be allowed
const half = divide(__, 2);
// remedy with arrow function
const half = (x: number) => divide(x, 2);

The major drawback for this is you will have to type x yourself there

The second is usage in pipe/compose

// extremely contrived example

// no longer allowed
const add3Div2 = pipe(
  add(3),
  divide(__, 2)
);
// remedy with arrow function
const add3Div2 = pipe(
  add(3),
  x => divide(x, 2)
);

Unlike the stand-alone-function example, you get the type of x for free, because pipe knows that add() returns a number, so x must be a number

IMHO this is a small and acceptable concession to make in how we use ramda with typescript to better overall support ramda with typescript.

Additionally, although I cannot seem to find these discussions over at ramda/ramda, I know they exist... There has been an argument for removing support for Placeholder/__` in the javascript code itself as well. I believe @adispring can speak to that.

The poll I have created is a simple Yes/No response. Please leave a comment if you disagree with this assessment or have an alternative solution.

[kedashoe]

Yes there have definitely been discussions about removing the placeholder. I could go either way there, but whatever ramda decides, I think it is fair for it to be removed from types-ramda

[adispring]

Here's the discussion about removing placeholder‘s type before: DefinitelyTyped/DefinitelyTyped#59579