Is it OK to cast undefined to void in TS?

Question

TLDR;

Is this OK? Or is it bad practice?

function isUndefined (payload: any): payload is undefined | void {
  return payload === undefined
}

Context

In TypeScript, I have a function that can return either something or undefined or void.

Something like an event handler that can return a modified payload or the dev can choose to return nothing or undefined in case they won't modify the payload:

function eventHandler <T extends {[key: string]: any}> (payload: T): Modified<T> | undefined | void {
  // ... implementation
}

Then I have a type checker that needs to check if it's returning something other than void or undefined:

const result = eventHandler(payload)

if (result !== undefined) {
  // we have a modified payload!
}

However, is the above snippet I get an error because it says that even though result !== undefined it can still be void?

In my opinion, I think it's peculiar because void should be the same as undefined.

So I made this type checker that solves it:

function isUndefined (payload: any): payload is undefined | void {
  return payload === undefined
}

This solves my issue, but my question is:

Is this OK? Or is it bad practice?

Answer 1

void is not undefined. void means the absence of a return value. undefined is the type of the value undefined at runtime.

it is true that a function that returns no value at run time returns undefined, but in the TS type system we chose to make the absence of a return value special.

For example assigning (a) => void to (a) => number | undefined is likely an error, though it is safe at run-time.

In general do not use void except in the return type of functions. for everything else, use undefined.

So, yes we will need to use different check for undefined and void.

Answer 2

I think you're making this more complicated that it needs to be. A function that returns void can:

1. Have no return statement
2. Have a return; statement with no value specified.
3. Have a return undefined; statement.

In pure javascript, all of the above would have a return value of undefined. If you say a function returns undefined, then you can only do #2 and #3 from the above list.

So you can just have a function type that unions void with whatever something you want.

function foo(): string | void {
    return Math.random() > 0.5 ? 'abc' : 123
}

const val = foo()
if (val === undefined) {
    console.log('is undefined', val)
} else {
    console.log('is some value', val)
}

---

This means that you could create a generic function type that modifies payloads like so:

type PayloadModifier<T extends {[key: string]: any}> = (payload: T) => T | void

const setMaxAsTen: PayloadModifier<{a: number}> = (payload) => {
    if (payload.a > 10) {
        return { a: 10 }
    }
    return undefined // required unless noImplicitReturns is false
}

const val = setMaxAsTen({a: 5})
if (val === undefined) {
    console.log('is undefined', val)
} else {
    console.log('is some value', val)
}

Playground

Last thing to note is that there is a compiler option that is good to leave on called noImplicitReturns. if a function declares a return value in any execution branch, then a return value must be declared in every execution branch. So because the above sometimes returns a value, you must explicitly return undefined if you don't to return a payload. You can toggle off that option, allowing you to omit that line, but it's not recommended as it does help you catch some bugs.