Initially, the context of this question only holds significance if the type for list allows null or undefined. Assuming you intended to include those options.
Your objective seems to be having the function return an array with the same type as the input. Therefore, your function should be generic on the array itself rather than just its member type. This distinction is crucial because the readonly characteristic resides in the array type, not its members.
A potential implementation could resemble the following:
export function catchUndefinedList<
T extends readonly unknown[]
> (list: T | null | undefined): T {
return (
nullOrUndefined(list) ||
!list?.length
? [] // Type 'T | never[]' is not assignable to type 'T'.
: list
)
}
// mutable
const list1 = ['foo']
const list2 = catchUndefinedList(list1)
list2.push('bar')
// immutable
const immlist1: readonly string[] = ['foo']
const immlist2 = catchUndefinedList(immlist1)
immlist2.push('bar') // Property 'push' does not exist on type 'readonly string[]'.(2339)
The code snippet demonstrates that pushing to a mutable array is permitted while attempting to do so on an immutable array results in an error, which is desired behavior.
However, there arises an issue with tuples. This is the reason behind the type error present in the above code excerpt. Imagine invoking the function like this:
const tuple2 = catchUndefinedList<[string, number, boolean]>(undefined)
tuple2[0].split('') // no type error, instead there is a runtime error
The problem stems from your function returning [] in the undefined scenario, which is not valid for a tuple.
You might manage to silence the error by using [] as unknown as T, but such an approach is discouraged as it might lead to runtime errors in unexpected situations.
It's challenging to properly constrain this situation since all tuples are subtypes of unbounded arrays.
Playground
Despite that, this complexity may seem excessive for a simple null check. Are you certain this is the direction you wish to pursue?
In essence, the provided code performs the following tasks:
- If
list is null or undefined, it returns a new empty array
- If
list is an empty array, it returns a new empty array
- If
list contains one or more items, it returns list.
This functionality appears similar to utilizing the Nullish coalescing operator ??:
list ?? []
The primary distinction between your code and this line is that when list is empty, it returns list instead of creating a new empty array. However, since both cases result in an empty array, this divergence most likely won't be significant.
Nonetheless, the Nullish coalescing operator behaves sensibly across scenarios:
// mutable
const list1 = ['foo'] as string[] | undefined
const list2 = list1 ?? []
list2.push('bar')
// immutable
const immlist1 = ['foo'] as readonly string[] | undefined
const immlist2 = immlist1 ?? []
immlist2.push('bar') // type error
// tuple
const tuple1 = ['a', 1] as [string, number] | undefined
const tuple2 = tuple1 ?? []
tuple2.push('c') // type error
Playground