Do you accept changes that make types more precise (more precise than @types/ramda?)

[fnimick]

For example, groupBy can be made more precise to indicate that every element is a non-empty array:
before:

export function groupBy<T>(groupFn: (x: T) => string, list: T[]): { [index: string]: T[] };

after:

export function groupBy<T>(groupFn: (x: T) => string, list: T[]): { [index: string]: [T, ...T[]] };

This matches the runtime behavior and allows easy usage with functions that require non-empty array inputs.

[selfrefactor]

sure, I try to improve @types/ramda if possible. In this particular case, I'd say that we should use NonEmptyArray generic as it makes intend of developer more obvious. I will test it out and comment back.

[selfrefactor]

I try to make it work, but I couldn't in a way that is easy to understand what the actual use case is.
If you can provide some example a real use case, where you are using non-empty array feature in the result of R.groupBy, it would help me test out the solution.

[fnimick]

Here's a simple example:

import { groupBy, mapObjIndexed, type NonEmptyArray } from "rambda";

interface Sample {
  _tag: string;
  name: string;
  value: number;
}

const samples: Sample[] = [
  { _tag: "A", name: "foo", value: 1 },
  { _tag: "A", name: "bar", value: 2 },
  { _tag: "B", name: "baz", value: 3 },
  { _tag: "B", name: "qux", value: 4 },
];

const groupedSamples = groupBy((sample) => sample._tag, samples);

function processSamples(samples: NonEmptyArray<Sample>): string {
  // some function that doesn't have to check to see if its input is empty
  return "foobar";
}

const processedGroups = mapObjIndexed(
  (sampleArray) => processSamples(sampleArray as NonEmptyArray<Sample>),
  groupedSamples,
);

// if groupBy returned a Dictionary<NonEmptyArray<T>>, this would work
const processedGroupsWithError = mapObjIndexed(processSamples, groupedSamples);

Having groupBy return only non-empty arrays as values (matching the implementation) means that we can reliably call functions on those values which require non-empty array inputs.

[selfrefactor]

Thanks for response, but I will need also what is inside processSamples as this will make testing easier. Now, I still cannot imagine what possible body this function could have.

[fnimick]

I'm confused - what do you mean by 'testing'? This is a type-only change, there should be no runtime effects.

For me, this is analogous to a function taking X vs X | null - where either it has one item or zero items. Writing a function which takes a NonEmptyArray is similar to writing a function which takes X, in which case we can be guaranteed that it is one or more items, not zero or more items.

There's business logic I've written that operates on a collection of one or more items, and throws an error if handed zero items as there is no fallback case that makes sense. It would be great to type-check inputs to this function.

[selfrefactor]

I mean typing test. Also, if we have actual logic inside processSamples in TS test, it will make it easier for readers to understand the benefit.

[fnimick]

I'm still quite confused - but here's a trivial example.

import { groupBy, mapObjIndexed, type NonEmptyArray } from "rambda";

interface Sample {
  _tag: string;
  name: string;
  value: number;
}

const samples: Sample[] = [
  { _tag: "A", name: "foo", value: 1 },
  { _tag: "A", name: "bar", value: 2 },
  { _tag: "B", name: "baz", value: 3 },
  { _tag: "B", name: "qux", value: 4 },
];

const groupedSamples = groupBy((sample) => sample._tag, samples);

function getSampleGroupMax(samples: Array<Sample>): number {
  if (samples.length === 0) {
    throw new Error("Empty array");
  }
  return Math.max(...samples.map((sample) => sample.value));
}

const processedGroups = mapObjIndexed(getSampleGroupMax, groupedSamples);

Having groupBy return NonEmptyArray as the dictionary value would allow eliminating the error / fallback case from mapping functions such as getSampleGroupMax.

[selfrefactor]

Thanks, that helps me. Let me try changing the types and I will get back to you.

[selfrefactor]

Sorry, but I need more definite example of getSampleGroupMax function.

I changed definitions to

export function groupBy<T>(groupFn: (x: T) => string, list: T[]): { [index: string]: NonEmptyArray<T> };
export function groupBy<T>(groupFn: (x: T) => string): (list: T[]) => { [index: string]: NonEmptyArray<T> };

and then indeed your example works. My issue is this:

function getSampleGroupMax(samples: NonEmptyArray<Sample>): number {
	if (samples.length === 0) {
		samples // I expect this to be never
	}
	return Math.max(...samples.map((sample) => sample.value));
}

for me this part is important:

if (samples.length === 0) {
   samples // I expect this to be never
}

Regarding TS definitions of Rambda - now that I read some really detailed learning sources, I realize that there are corner-cases that most people don't realize. Because of that, I will be doing the opposite - I want Rambda types to be closes to that of Ramda as these typings are regularly updated and have more eyes on them.