TypeScript Add Extract Kind

Question

TypeScript Add Extract Kind

I am currently working on implementing a function called sumPluck. This function will allow the user to specify a property of type number from an object in an array, and then calculate the sum of all those properties.

For example:

type A = { prop: number }

const arr: A[] = [{prop: 1}, {prop: 2}];

pluckSum("prop", arr); // 3

I have a basic idea of how to extract the specified property, but I'm having trouble ensuring that the property is definitely a number. Here's what I have so far:

type PropertiesOfTypeNames<T, U> = { [K in keyof T]: T[K] extends U ? K : never }[keyof T];
    type PropertiesOfType<T, U> = Pick<T, PropertiesOfTypeNames<T, U>>;

    type NumberProperties<T> = PropertiesOfType<T, number>;

    const pluckSum = <T, K extends keyof NumberProperties<T>>(arr: T[], k: K) =>
        pipe(
            arr,
            R.map(v => v[k]),
            R.sum
        );

An error is being displayed under the map function stating: Type 'T[string]' cannot be assigned to type 'number'

It seems like the mapped type does not properly indicate that v[k] is indeed a number property. I might be missing something in my approach here.

typescript functional-programming

Answer 1

Answer №1

Irrespective of Typescript, I would like to introduce you to an alternative method involving loop fusion, which eliminates redundant array traversal. This technique involves utilizing a unique combinator of type

(b -> c) -> (a -> c -> d) -> a -> b -> d

(written in Hindley-Milner notation) called contramap2nd, as it contra-maps the second argument of a binary function.

The gist of it:

// (b -> c) -> (a -> c -> d) -> a -> b -> d
const contramap2nd = g => f => x => y =>
  f(x) (g(y));

const arrFold = f => init => xs =>
  xs.reduce((acc, x) => f(acc) (x), init);
  
const add = x => y => x + y;
const prop = k => o => o[k];

const pluckSum = k =>
  arrFold(
    contramap2nd(
      prop(k))
        (add)) (0);

console.log(
  pluckSum("foo") ([{foo: 1}, {foo: 2}, {foo: 3}]));

If you prefer, you can manually perform the contra-mapping on the second argument of add, instead of using contramap2nd.

Keep in mind that achieving loop fusion is possible with both map, contramap, and similar techniques.

Answer 2

Irrespective of Typescript, I would like to introduce you to an alternative method involving loop fusion, which eliminates redundant array traversal. This technique involves utilizing a unique combinator of type

(b -> c) -> (a -> c -> d) -> a -> b -> d

(written in Hindley-Milner notation) called contramap2nd, as it contra-maps the second argument of a binary function.

The gist of it:

// (b -> c) -> (a -> c -> d) -> a -> b -> d
const contramap2nd = g => f => x => y =>
  f(x) (g(y));

const arrFold = f => init => xs =>
  xs.reduce((acc, x) => f(acc) (x), init);
  
const add = x => y => x + y;
const prop = k => o => o[k];

const pluckSum = k =>
  arrFold(
    contramap2nd(
      prop(k))
        (add)) (0);

console.log(
  pluckSum("foo") ([{foo: 1}, {foo: 2}, {foo: 3}]));

If you prefer, you can manually perform the contra-mapping on the second argument of add, instead of using contramap2nd.

Keep in mind that achieving loop fusion is possible with both map, contramap, and similar techniques.

Answer 3

Answer №2

Managed to figure it out by adding a Record as shown below:

const pluckSum = <T extends Record<K, number>, K extends keyof NumberProperties<T>>(arr: T[], k: K) =>
    pipe(
        arr,
        R.map(v => v[k]),
        R.sum
    );

Update 1 Realized I can simplify it even more by removing the mapped type "NumberProperties" because Record already achieves what I intended. So the final version looks like this:

const pluckSum = <T extends Record<K, number>, K extends keyof T>(k: K, arr: T[]) =>
    pipe(
        arr,
        R.map(v => v[k]),
        R.sum
    );

Answer 4

Managed to figure it out by adding a Record as shown below:

const pluckSum = <T extends Record<K, number>, K extends keyof NumberProperties<T>>(arr: T[], k: K) =>
    pipe(
        arr,
        R.map(v => v[k]),
        R.sum
    );

Update 1 Realized I can simplify it even more by removing the mapped type "NumberProperties" because Record already achieves what I intended. So the final version looks like this:

const pluckSum = <T extends Record<K, number>, K extends keyof T>(k: K, arr: T[]) =>
    pipe(
        arr,
        R.map(v => v[k]),
        R.sum
    );

TypeScript Add Extract Kind

Answer №1

Answer №2

Similar questions

Requesting Next Page via Angular GET Method for Paginated API

Cache for JSON Schema in VS Code

`mat chip component in Angular Material is malfunctioning`

The error with removing the form field control in Angular 7 persists

Converting CommonJS default exports into named exports / Unable to load ES module

Console.log is displaying array as [object Object] when utilizing Typescript

The implementation of conditional parameter types in TypeScript

Having difficulty constructing a full stack application using Express

JavaScript - Assigning the same value to 2 properties but console log displays them as distinct values

Trouble arises when attempting to transfer cookies between server in Fastify and application in Svelte Kit

Tips for adding an item to an array within a Map using functional programming in TypeScript/JavaScript

Encountering type errors in NextJS with TypeScript

A guide on effectively utilizing the Map datatype in JavaScript

Is it possible for a typed function to access object properties recursively?

Challenges with exporting dynamically generated divs using jspdf in an Angular 2 project

Creating a JSX.Element as a prop within a TypeScript interface

Trouble with Jest when trying to use route alias in Next.js with Typescript

Ionic: Automatically empty input field upon page rendering

Incorporate matTooltip dynamically into text for targeted keywords

Error TS2304: Unable to locate identifier 'RTCErrorEvent'