Refine nothings

[mjgpy3]

I don't really know if this is possible in TypeScript so I'm throwing it here to start discussion.

Background

In flow we tended to use ?Foo which ends up being Foo | null | undefined in TypeScript. Having two values for nothing (e.g. null and undefined) is unnecessary and yields a lot of unnecessary checks.

In many places we've started to remove | undefined in favor of exclusively using null to mean "no value".

Desired behavior

Combinators should not add extra types but should preserve the fidelity of the input types.

E.g. the following should compile

let a: number | null = getA()
let b: number | undefined = getB()
let c: number | null | undefined = getC()

const add1 = (v: number) => v+1;

a = mmap(add1, a)
b = mmap(add1, b)
c = mmap(add1, c)

Actual Behavior

Re-definitions of a and b won't compile because mmap returns number | null | undefined.

[stackptr]

This seems to be possible when using function overloads in an example Playground:

declare function mmap<I extends any, O>(f: (v: I) => O, v?: I): O
declare function mmap<I extends any, O>(f: (v: I) => O, v?: I | null): O | null

[stackptr]

It appears the existing mmap implementation can be overloaded:

function mmap<I extends any, O>(f: (v: I) => O, v?: I): O
function mmap<I extends any, O>(f: (v: I) => O, v?: I | null): O | null
function mmap<I extends any, O>(f: (v: I) => O, v?: I | undefined): O | undefined
function mmap<I extends any, O>(f: (v: I) => O, v?: I | null | undefined): O | null | undefined {
  return v === undefined ? undefined : v === null ? null : f(v)
}

[StevenXL]

It appears the existing mmap implementation can be overloaded:

function mmap<I extends any, O>(f: (v: I) => O, v?: I): O
function mmap<I extends any, O>(f: (v: I) => O, v?: I | null): O | null
function mmap<I extends any, O>(f: (v: I) => O, v?: I | undefined): O | undefined
function mmap<I extends any, O>(f: (v: I) => O, v?: I | null | undefined): O | null | undefined {
  return v === undefined ? undefined : v === null ? null : f(v)
}

I don't think that overloading is the path I'd take here. Doesn't the code above mean that we are going to end up returning I | null | undefined for some I, which is the problem we want to get rid of? We are now able to call the function in more ways, but we still end up with the same return type of the implementation signature.

On a tangential point, but while we are here, why do we have v? instead of v? I don't think I'd like to call mmap with only a function from I to O?