如何在TypeScript中添加编译时？

Question

How can I do addition in the type system in TypeScript?

I can get successor (add 1) and predecessor (subtract 1) but haven't figured out how to get the recursion needed in order to add two numbers generally:

type Z = 0                           // zero
type S<T> = { item: T }              // successor
type P<T extends S<any>> = T['item'] // predecessor
type N = S<any> | Z                  // number, not exactly right because S<boolean> isn't a number

const zero = 0
const one: S<Z> = { item: 0 }
const two: S<S<Z>> = { item: { item: 0} }
const three: S<S<S<Z>>> = { item: { item: { item: 0 } } }

const predPred3: P<P<typeof three>> = one; // OK

The problem I'm hitting is with recursive type definitions:

// Error: Type alias 'Plus' circularly references itself
type Plus<T1, T2> = T2 extends Z ? T1 : Plus<T1, P<T2>>

I tried to hack around the problem by using ReturnType but the syntax isn't even correct:

function plus<T1 extends N, T2 extends N>(t1: T1, t2: T2) : T2 extends Z ? T1 : ReturnType<typeof plus<T1, P<T2>>> {
    return t2 === 0? t1 : plus({item: t1}, (t2 as S<any>).item);
}

Is there a way to do addition in the type system?

Answer 1

To evade "Type alias 'Plus' circularly references itself" restriction, you have to reference recursive type in the object member type, then select appropriate member type using [] as indexed type access operator :

type Plus<T1, T2> = {
    z: T1;
    s: T2 extends S<any> ? S<Plus<T1, P<T2>>> : never 
       // conditional type necessary because compiler can't figure out
       // that T2 always extends S here, "never" branch is never taken
}[T2 extends Z ? 'z' : 's']


const p12: Plus<typeof one, typeof two> = three; // typechecks

However, be warned by this comment

unless someone like @ahejlsberg can tell us if we can expect things like that to keep working or not

It's clever, but it definitely pushes things well beyond their intended use. While it may work for small examples, it will scale horribly. Resolving those deeply recursive types consumes a lot of time and resources and might in the future run afoul of the recursion governors we have in the checker.

Don't do it!