Is there a way to determine if a tuple is of infinite or finite length?

Question

Is there a way to determine if a tuple is of infinite or finite length?

Is there a way to determine if a tuple is finite or infinite?

I've been working on a solution, but it doesn't cover all cases:

type IsFinite<T extends any[], Finite = true, Infinite = false> = T extends []
  ? Finite
  : T extends (infer Element)[]
  ? Element[] extends T
    ? Infinite
    : T extends [any, ...infer Rest]
    ? IsFinite<Rest, Finite, Infinite>
    : never
  : never

 type Foo1 = IsFinite<[string]>                          // true
 type Foo2 = IsFinite<[]>                                // true
 type Foo3 = IsFinite<string[]>                          // false
 type Foo4 = IsFinite<[arg1: string, ...args: string[]]> // false

 type Foo5 = IsFinite<[string, ...[string, number], ...string[], string]> // never <- doesn't handle this case

Try it out

typescript

Answer 1

Answer №1

When referring to an "infinite" array/tuple, it denotes an array type with no specified maximum length in TypeScript. In this case, the length property of the array type would be of type number, as opposed to a "finite" array/tuple where the length property is a numeric literal type or union of such literals:

type Length<T extends any[]> = T['length'];

type L1 = Length<[string]>                          // 1
type L2 = Length<[]>                                // 0
type L3 = Length<string[]>                          // number
type L4 = Length<[arg1: string, ...args: string[]]> // number
type L5 = Length<[string, ...[string, number], ...string[], string]> // number
type L6 = Length<[string, string?]> //  1 | 2

To define IsFinite<T>, you can use a conditional type that checks the type of the length property:

type IsFinite<T extends any[], F = true, I = false> =
    number extends T['length'] ? I : F

type Foo1 = IsFinite<[string]>                          // true
type Foo2 = IsFinite<[]>                                // true
type Foo3 = IsFinite<string[]>                          // false
type Foo4 = IsFinite<[arg1: string, ...args: string[]]> // false
type Foo5 = IsFinite<[string, ...[string, number], ...string[], string]> // false
type Foo6 = IsFinite<[string, string?]> //  true

Link to Playground for code testing

Answer 2

When referring to an "infinite" array/tuple, it denotes an array type with no specified maximum length in TypeScript. In this case, the length property of the array type would be of type number, as opposed to a "finite" array/tuple where the length property is a numeric literal type or union of such literals:

type Length<T extends any[]> = T['length'];

type L1 = Length<[string]>                          // 1
type L2 = Length<[]>                                // 0
type L3 = Length<string[]>                          // number
type L4 = Length<[arg1: string, ...args: string[]]> // number
type L5 = Length<[string, ...[string, number], ...string[], string]> // number
type L6 = Length<[string, string?]> //  1 | 2

To define IsFinite<T>, you can use a conditional type that checks the type of the length property:

type IsFinite<T extends any[], F = true, I = false> =
    number extends T['length'] ? I : F

type Foo1 = IsFinite<[string]>                          // true
type Foo2 = IsFinite<[]>                                // true
type Foo3 = IsFinite<string[]>                          // false
type Foo4 = IsFinite<[arg1: string, ...args: string[]]> // false
type Foo5 = IsFinite<[string, ...[string, number], ...string[], string]> // false
type Foo6 = IsFinite<[string, string?]> //  true

Link to Playground for code testing

Is there a way to determine if a tuple is of infinite or finite length?

Answer №1

Similar questions

Angular Toaster Notification - There are currently no toaster containers set up to display notifications

Is there a way to exclusively view references of a method override in a JS/TS derived class without any mentions of the base class method or other overrides in VS Code?

Include module A in module B, even though module A has already included module B's Angular

Issue with type narrowing and `Extract` helper unexpectedly causing type error in a generic type interaction

Anticipate that the function parameter will correspond to a key within an object containing variable properties

Implementing Angular 2 reactive forms checkbox validation in an Ionic application

Issue with Angular reactive forms when assigning values to the form inputs, causing type mismatch

Is it possible to access the attributes of an interface in TypeScript without relying on external libraries?

TypeScript 1.6 warning: Component XXX cannot be instantiated or called as a JSX element

How can I organize an array in JavaScript by date for presentation on a webpage?

Issue: The code is throwing an error "TypeError: Cannot read property 'push' of undefined" in the JavaScript engine "Hermes

What steps are involved in generating a Typescript module definition for a directory containing a babel-plugin-content-transformer?

Is there a way to dynamically adjust the size of mat dialog content to match the size of the mat dialog in

Is there a way to set the submitted variable to true when the form group is submitted, then revert it to false when the user makes changes to the form?

When incorporating pinia with Vue, encountering an error with the decorator that says "Error: Unable to access 'useCoreStore' before initialization" may happen

Keeping track of important dates is ineffective using the calendar

Exploring the wonders of accessing POST request body in an Express server using TypeScript and Webpack

How can I ensure my function waits for a promise to be resolved using Async / Await?

Acquire information from an Angular service and output it to the console

What could be the rationale behind the optional chaining operator not being fully compatible with a union of classes in TypeScript?