Writing a function to calculate object properties whereas the object includes optional properties

Question

I have a record of data (object-literal), and I need to calculate the average of several of its properties. For example, consider that each record reflects a sample of dog breeds and their weights. We have one representative for each breed, but two specific breeds may not appear in the data:

// typescript

type dogSample = {
    // 5 core breeds that always appear
    bulldog: number,
    poodle: number,
    pug: number,
    chihuahua: number,
    boxer: number,
    // 2 additional that sometimes appear
    dalmatian?: number,
    rottweiler?: number, // rottweiler could appear only if dalmatian appears, but not vice versa
    // other irrelevant properties
    foo: string,
    bar: boolean,
    baz: number
    // and potentially hundreds of unrelated properties
}

My goal is to calculate the average of dogs weights. So I target those properties directly with three functions:

const calcMeanCoreFive = (obj: dogSample) =>
  (obj.bulldog + obj.poodle + obj.pug + obj.chihuahua + obj.boxer) / 5;

const calcMeanCoreFivePlusDalmatian = (obj: Required<dogSample>) => // using `Required` solves type problem
  (obj.bulldog +
    obj.poodle +
    obj.pug +
    obj.chihuahua +
    obj.boxer +
    obj.dalmatian) /
  6;

const calcMeanCoreFivePlusDalmatianPlusRottw = (obj: Required<dogSample>) =>
  (obj.bulldog +
    obj.poodle +
    obj.pug +
    obj.chihuahua +
    obj.boxer +
    obj.dalmatian +
    obj.rottweiler) /
  7;

Finally I want to add a wrapper around all three versions such that:

const calcMeanDogSample = (obj: dogSample, nBreeds: 5 | 6 | 7) =>
  nBreeds === 5
    ? calcMeanCoreFive(obj)
    : nBreeds === 6
    ? calcMeanCoreFivePlusDalmatian(obj)
//                                   ^
    : calcMeanCoreFivePlusDalmatianPlusRottw(obj);
//                                            ^
// argument of type 'dogSample' is not assignable to parameter of type 'Required<dogSample>'

My attempt to work around this

I tried to type calcMeanDogSample() with Required<dogSample>:

const calcMeanDogSample2 = (obj: Required<dogSample>, nBreeds: 5 | 6 | 7) =>
  nBreeds === 5
    ? calcMeanCoreFive(obj)
    : nBreeds === 6
    ? calcMeanCoreFivePlusDalmatian(obj)
    : calcMeanCoreFivePlusDalmatianPlusRottw(obj);

This solves the error as far as the function's definition. However, calling calcMeanDogSample2() and passing an object of type dogSample wouldn't work:

const someDogSample = {
  bulldog: 24,
  poodle: 33,
  pug: 21.3,
  chihuahua: 7,
  boxer: 24,
  dalmatian: 20,
  foo: "abcd",
  bar: false,
  baz: 123,
} as dogSample;

calcMeanDogSample2(someDogSample, 6);
//                     ^
// Argument of type 'dogSample' is not assignable to parameter of type // 'Required<dogSample>'.
//   Types of property 'dalmatian' are incompatible.
//     Type 'number | undefined' is not assignable to type 'number'.
//       Type 'undefined' is not assignable to type 'number'.ts(2345)

My question

Is there a way to type calcMeanDogSample() differently and solve this problem?

Reproducible code at TS playground

Does [this approach](https://tsplay.dev/w8EOrN) meet your needs? If so I could write up the answer; if not, what am I missing? — jcalz, Aug 04 '22 at 15:27
@jcalz, it's a very nice solution indeed! Thank you! However, I'm unsure why you added the test `if (typeof v === "number")`. The properties `dalmatian` and `rottweiler` are already defined as `number` in the `dogSample` type. — Emman, Aug 04 '22 at 15:36
? If they are not present then the type will be `undefined` and not `number`. You could test it yourself; remove `if (typeof v === "number")` and watch as `NaN` comes out. Shall I write up an answer? — jcalz, Aug 04 '22 at 15:42
I see. But in that case, can't we more succinctly write `if (v) {...}`? — Emman, Aug 04 '22 at 15:46
No, `if (v)` will not distinguish `undefined` from `0`. If you want `0` to be treated as if it's missing (i.e., that `nBreeds` doesn't increment) then sure, but that's a different algorithm from the one you provided. I will write up the answer when I get a chance. — jcalz, Aug 04 '22 at 15:49

jsejcksn · Answer 1 · 2022-08-04T16:03:40.900

The problem is that there's no correlation between nBreeds and the input obj in the type system.

However, TypeScript offers you a feature to inform the compiler that these properties do actually exist within your data if they can pass a conditional check: it's called a user-defined type guard and its return type is called a type predicate. Here's an example of how to use it with your data, and — when you do — you no longer need to provide the nBreeds argument!

See also the utility types Required<Type> and Pick<Type, Keys>

TS Playground

type DogSample = {
  bulldog: number;
  poodle: number;
  pug: number;
  chihuahua: number;
  boxer: number;
  dalmatian?: number;
  rottweiler?: number;
  // other irrelevant properties
  foo: string;
  bar: boolean;
  baz: number;
};

// This is called a user-defined type guard (and the return type is called a type predicate)
function sampleIncludesBreed <T extends DogSample, K extends keyof DogSample>(
  obj: T,
  breed: K,
): obj is T & Required<Pick<DogSample, K>> {
  return typeof (obj as Required<DogSample>)[breed] === 'number';
}

const calcMeanCoreFive = (obj: DogSample) =>
  (obj.bulldog + obj.poodle + obj.pug + obj.chihuahua + obj.boxer) / 5;

const calcMeanCoreFivePlusDalmatian = (obj: (
  DogSample
  & Required<Pick<DogSample, 'dalmatian'>>
)) =>
  (obj.bulldog +
    obj.poodle +
    obj.pug +
    obj.chihuahua +
    obj.boxer +
    obj.dalmatian) /
  6;

const calcMeanCoreFivePlusDalmatianPlusRottw = (obj: (
  DogSample
  & Required<Pick<DogSample, 'dalmatian'>>
  & Required<Pick<DogSample, 'rottweiler'>>
)) =>
  (obj.bulldog +
    obj.poodle +
    obj.pug +
    obj.chihuahua +
    obj.boxer +
    obj.dalmatian +
    obj.rottweiler) /
  7;

const calcMeanDogSample = (obj: DogSample) => {
  if (sampleIncludesBreed(obj, 'dalmatian')) {
    return sampleIncludesBreed(obj, 'rottweiler')
      ? calcMeanCoreFivePlusDalmatianPlusRottw(obj) /*
                                               ^^^
      This type is: (parameter) obj: DogSample & Required<Pick<DogSample, "dalmatian">> & Required<Pick<DogSample, "rottweiler">> */
      : calcMeanCoreFivePlusDalmatian(obj); /*
                                      ^^^
      This type is: (parameter) obj: DogSample & Required<Pick<DogSample, "dalmatian">> */
  }
  return calcMeanCoreFive(obj); /*
                          ^^^
  This type is: (parameter) obj: DogSample */
};

const someDogSample = {
  bulldog: 24,
  poodle: 33,
  pug: 21.3,
  chihuahua: 7,
  boxer: 24,
  dalmatian: 20,
  foo: "abcd",
  bar: false,
  baz: 123,
} as DogSample;

calcMeanDogSample(someDogSample);

Completely unrelated to your question, but related to dogs and data: You might like the API at dog.ceo.

score 1 · Accepted Answer · answered Aug 04 '22 at 17:45

While one could implement your existing algorithm in a way the TypeScript compiler would recognize as type safe, my approach here would be to refactor the algorithm to something a bit more general:

const calcMeanDogSample = (obj: DogSample) => {
  let sum = obj.bulldog + obj.poodle + obj.pug + obj.chihuahua + obj.boxer;
  let nBreeds = 5;
  for (let v of [obj.dalmatian, obj.rottweiler]) {
    if (typeof v === "number") {
      sum += v; nBreeds++;
    }
  }
  return sum / nBreeds;
}

To get the mean, we need to divide the sum of the relevant properties by how many there are (nBreeds). We can do the "core five" without worry because they are required properties. For the optionanl dalmatian and rottweiler properties, we only want to contribute to sum and nBreeds if they are actually present.

You can verify that this behaves as expected:

const someDogSample = {
  bulldog: 24,
  poodle: 33,
  pug: 21.3,
  chihuahua: 7,
  boxer: 24,
  dalmatian: 20,
  foo: "abcd",
  bar: false,
  baz: 123,
};

console.log(calcMeanDogSample(someDogSample)); // 21.55

You could even refactor this more by transforming the list of keys to a list of possibly-defined numbers, filtering out the undefined values, and computing the mean of that:

const mean = (x: number[]) => x.reduce((a, v) => a + v, 0) / x.length;
const calcMeanDogSample2 = (obj: DogSample) => mean(
  (["bulldog", "poodle", "pug", "chihuahua", "boxer", "dalmatian", "rottweiler"] as const)
    .map(k => obj[k])
    .filter((v): v is number => typeof v === "number")
);
console.log(calcMeanDogSample2(someDogSample)); // 21.55

Playground link to code

Writing a function to calculate object properties whereas the object includes optional properties

2 Answers2