Agfdhyk

I have a set of attributes, all calculable from each other:

 A = B * C

 B = A / C

 C = A / B

A, B, and C are all attributes of my model, so there is a function which takes a model that is missing one of them and returns a model which has all three specified.

Thus, there is a type-concept of a "solvable" model, which is one that is missing 0 or 1 attributes, and an "unsolvable" model, which is missing 2 or more. That is, a solvable model is one that can be converted, via one of the above functions (or without making any change), into a complete model.

How can I model these concepts in my type system? So far, I've tried using Partial or Pick to create individual types for each of these, but it was incredibly verbose and I couldn't get other parts of my app which consumed these functions to correctly compile.

I'm not sure if the following counts as "incredibly verbose" (it uses Pick<> internally, so maybe?) or if it runs into the same compilation problems you saw, but:

type MissingOneProperty<O extends object> = {

  [K in keyof O]: Pick<O, Exclude<keyof O, K>>

}[keyof O];

type MissingAtMostOneProperty<O extends object> =

  O | MissingOneProperty<O>;

The idea is that MissingAtMostOneProperty<O> is either O or it is missing exactly one property from O. This probably only works for object types without index signatures (do you care?).

So if I define your model like this:

interface Model {

  a: number,

  b: number,

  c: number

}

I can declare a function that only accepts models missing at most one property:

declare function solveModel(

  solvableModel: MissingAtMostOneProperty<Model>

): Model;

solveModel({ a: 1, b: 2 }); // okay

solveModel({ b: 2, c: 0.5 }); // okay

solveModel({ a: 1, c: 0.5 }); // okay

solveModel({ a: 1, b: 2, c: 0.5 }); // okay

solveModel({ a: 1 }); // error, property "b" is missing

solveModel({ b: 2 }); // error, property "a" is missing

solveModel({ c: 0.5 }); // error, property "a" is missing

solveModel({}); // error, property "a" is missing

Looks reasonable to me.

To understand how that works, let's walk through what MissingAtMostOneProperty<Model> gets evaluated to:

MissingAtMostOneProperty<Model> 

becomes, by the definition of MissingAtMostOneProperty:

Model | MissingOneProperty<Model>

which is, by the definition of MissingOneProperty:

Model | {[K in keyof Model]: Pick<Model, Exclude<keyof Model, K>>}[keyof Model]

which is, by mapping over the 'a', 'b', and 'c' properties of Model:

Model | {

  a: Pick<Model, Exclude<keyof Model, 'a'>,

  b: Pick<Model, Exclude<keyof Model, 'b'>,

  c: Pick<Model, Exclude<keyof Model, 'c'>

}[keyof Model]

which is, by noting that keyof Model is 'a'|'b'|'c' and that Exclude<T, U> is a conditional type that removes elements from unions:

Model | {

  a: Pick<Model, 'b'|'c'>,

  b: Pick<Model, 'a'|'c'>,

  c: Pick<Model, 'a'|'b'>

}['a'|'b'|'c']

which, by noting how Pick<> works, becomes:

Model | {

  a: { b: number, c: number },

  b: { a: number, c: number },

  c: { a: number, b: number }

}['a'|'b'|'c']

which, finally, by noting that looking up a union of property keys in a type is the same as the union of the types of the properties, and by the definition of Model, turns into:

{a: number, b: number, c: number} 

  | { b: number, c: number }

  | { a: number, c: number }

  | { a: number, b: number }

Done! You can see how you end up with a union of Model and all ways of removing one property from Model.

Hope that gives you some direction. Good luck!