Typing a classic JS one-liner

One line to rule them all

Often we have a list of things and would like to know how many there are of each thing in the list. This is one of those handy one-liners that will give you an object mapping an item to the number of occurrences for a given list of things.

const getFreqMap = (list) => 
  list.reduce((acc, cur) => 
    ({ ...acc, [cur]: (acc[cur] ?? 0) + 1 }), {})

getFreqMap(['a', 'a', 'c', 'b', 'd', 'd', 'd'])   
// {a: 2, c: 1, b: 1, d: 3}
getFreqMap([0, 1, 2, 2, 6, 2, 1, 0, 6])           
// {0: 2, 1: 2, 2: 3, 6: 2}

Okay so maybe its not just one line.
But that's because I formatted it nicely!
At least its not as bad as this:

const getFreqMap = (list) => {
  const res = {}
  for (let i = 0; i < list.length; i++) {
    if (res[list[i]] !== undefined){
      res[list[i]]++
    }
    else{
      res[list[i]] = 1
    }
  }
  return res
}

Wow, what a waste of lines...
Anyway, lets rewrite our one-liner in typescript because its better.

So lets just change the file type to .ts.
...And immediately we get a bollocking like so:

const getFreqMap = (1list) =>
  list.reduce((2acc,3cur) => 
    ({ ...acc, [cur]: (acc[cur] ?? 0) + 1 }), {})

So lets add a type annotation.

const getFreqMap = (list: 1string[]) =>
  list.reduce((acc,cur) => 
    ({ ...acc, [cur]: (2acc[cur] ?? 0) + 1 }), {})

Looks like we need to tell typescript that the type of the second argument of reduce is a an object mapping type string to type number.
We can do this using as .

const getFreqMap = (list: string[]) =>
  list.reduce(
    (acc, cur) => ({ ...acc, [cur]: (acc[cur] ?? 0) + 1 }),
    {} 1as { [key: string]: number }
  )

And this works just fine.
But.. Wouldn't it be nice if it worked for any kind of list?
So lets do that then...
Using generics of course.

const getFreqMap = <1A>(list: A[]) =>
  list.reduce(
    (acc, cur) => ({ ...acc, 3[cur]: (4acc[cur] ?? 0) + 1 }),
    {} as { [2key: A]: number }
  )

So we just replaced string with a generic type A.
But alas this is not correct...
We get an error saying we can't use something with type A as an index on {}.
So lets see about the Record type instead.

const getFreqMap = <A>(list: A[]) =>
  list.reduce(
    (acc, cur) => ({ ...acc, 2[cur]: (acc[cur] ?? 0) + 1 }),
    {} as1Record<A, number>
  )

Omfg another error, srsly???

Oh. Looks like our generic type is a little too generic..
Lets take a look at the type definition for the Record type.

type Record<K extends keyof any, T> = {
  [P in K]: T;
};

It says that the type of K (the key of the Record) must be a key of something.
Which gets reduced to string, number, symbol or any as stated by the error message above.
Ok. So lets just add that type constraint to A.

const getFreqMap = <A 1extends keyof any>(list: A[]) =>
  list.reduce(
    (acc, cur) => ({ ...acc, [cur]: (acc[cur] ?? 0) + 1 }),
    {} as Record<A, number>
  )

And here is the finished product!
How beautiful!

But wait, what if we had a list of something more complicated, like a list of objects?
An exercise for the reader perhaps...

Webmentions

revilotom2023/12/06 17:19

🔖 Bookmarked: https://www.tomoliver.net/posts/counting-occurrences