What is the proper way to define a tuple type with a specific size N for the vector class in C++?

Question

What is the proper way to define a tuple type with a specific size N for the vector class in C++?

I am seeking to create a tuple type with a fixed size N, allowing for functionality such as:

let tuple: Tuple<string, 2> = ["a","b"]

In this scenario, "number" represents the type T, and "2" denotes the size N. Subsequently, I aim to develop a mathematical Vector class that not only embodies the tuple but also integrates additional methods like vector addition:

class Vector<N extends number> implements Tuple<number, N> {...}

While exploring various solutions for implementing the tuple type, I encountered several challenges. The simplest approach I came across (referenced here) entailed utilizing an interface structured as follows:

interface Tuple<T, N extends number> extends ArrayLike<T> //or Array<T> {
   0: T
   length: N
}

However, this particular implementation permits access to elements at invalid indices without triggering compiler errors:

let tuple: Tuple<number, 2> = [1,2]
tuple[4] //Compiler does not flag the out-of-bounds index.

An alternative implementation, found here, utilizes recursive conditional types:

type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : _TupleOf<T, N, []> : never;
type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;

While resolving the index issue, this method poses challenges when integrating into the Vector class due to it being a type union, resulting in the following error:

A class can only implement an object type or intersection of the object types with statically known members.ts(2422)

Is there any viable approach to define a tuple type as intended?

Additional query: Is it possible to implement the tuple type sans the array class's inherent methods? Eliminating unrelated methods like filter and sort, especially those impacting the tuple's size, would be advantageous. Using ArrayLike in place of Array could address this concern, while Omit is another potential workaround albeit involving manual specification of each undesired method.

typescript typescript-generics

Answer 1

Answer №1

It's clear that when dealing with TypeScript, certain limitations arise in terms of extending or implementing interfaces and classes due to statically known keys. This pertains specifically to situations where deferred generics are involved.

The compiler only supports static keys for objects like classes and interfaces. Therefore, trying to extend or implement types with deferred generic keys will result in errors:

class Foo<K extends string> implements Record<K, string> { } // Error!
interface Bar<K extends string> extends Record<K, string> { } // Error!

For a type such as Vector<N>, which requires numeric-like keys from 0 up to N-1, defining these keys statically becomes challenging due to the generality of N within Vector<N>. As a result, creating a class or interface for Vector<N> proves difficult.

If every possible number-valued key needs to exist, an index signature can be used. However, excluding properties at keys greater than or equal to N introduces complications that negate the use of an index signature.

A viable solution involves describing Vector<N> instances as a type alias rather than an interface or class. By defining a construct signature under a value called Vector, it's possible to create objects that meet runtime requirements while circumventing the need for strictly known keys.

To put this into practice:

Type Descriptions:

Begin by setting up a recursive conditional definition for a tuple of length N:

type Tuple<T, N extends number> = N extends N ? 
  number extends N ? T[] : { length: N } & _TupleOf<T, N, []> : never;
  
type _TupleOf<T, N extends number, R extends unknown[]> = 
  R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;

// Define Vector<N> based on the above:

type Vector<N extends number> =
  Omit<Tuple<number, N>, keyof any[]> &
  {
    length: N;
    vectorMethod(): void;
};

Additionally, describe the constructor like so:

interface VectorConstructor {
  new <N extends number>(...init: Tuple<number, N>): Vector<N>;
}

Runtime-Compatible Class:

Create a class named _Vector that includes an index signature for desired functionality:

class _Vector {
  [k: number]: number | undefined;
  length: number;
  constructor(...init: number[]) {
     // Implementation logic
  }
  vectorMethod() {
    console.log("Functionality here");
  }
}

Ensure Compatibility:

Assert that _Vector constructs instances compatible with the desired type:

const Vector = _Vector as VectorConstructor;

Testing our setup:

const v = new Vector(0, 1, 4, 9, 16, 25); // Vector<6>
/* Expected Output:
{
    length: 6;
    0: number;
    1: number;
    2: number;
    3: number;
    4: number;
    5: number;
    vectorMethod: () => void;
} */

v[3]++; // Okay
v.vectorMethod();
v[10]; // Error

In conclusion, through this approach, we've managed to work around the restrictions imposed by TypeScript without compromising runtime objectives. While this method is effective, it comes with its own set of considerations and maintenance efforts if expansion or implementation scenarios emerge.

Answer 2

It's clear that when dealing with TypeScript, certain limitations arise in terms of extending or implementing interfaces and classes due to statically known keys. This pertains specifically to situations where deferred generics are involved.

The compiler only supports static keys for objects like classes and interfaces. Therefore, trying to extend or implement types with deferred generic keys will result in errors:

class Foo<K extends string> implements Record<K, string> { } // Error!
interface Bar<K extends string> extends Record<K, string> { } // Error!

For a type such as Vector<N>, which requires numeric-like keys from 0 up to N-1, defining these keys statically becomes challenging due to the generality of N within Vector<N>. As a result, creating a class or interface for Vector<N> proves difficult.

If every possible number-valued key needs to exist, an index signature can be used. However, excluding properties at keys greater than or equal to N introduces complications that negate the use of an index signature.

A viable solution involves describing Vector<N> instances as a type alias rather than an interface or class. By defining a construct signature under a value called Vector, it's possible to create objects that meet runtime requirements while circumventing the need for strictly known keys.

To put this into practice:

Type Descriptions:

Begin by setting up a recursive conditional definition for a tuple of length N:

type Tuple<T, N extends number> = N extends N ? 
  number extends N ? T[] : { length: N } & _TupleOf<T, N, []> : never;
  
type _TupleOf<T, N extends number, R extends unknown[]> = 
  R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;

// Define Vector<N> based on the above:

type Vector<N extends number> =
  Omit<Tuple<number, N>, keyof any[]> &
  {
    length: N;
    vectorMethod(): void;
};

Additionally, describe the constructor like so:

interface VectorConstructor {
  new <N extends number>(...init: Tuple<number, N>): Vector<N>;
}

Runtime-Compatible Class:

Create a class named _Vector that includes an index signature for desired functionality:

class _Vector {
  [k: number]: number | undefined;
  length: number;
  constructor(...init: number[]) {
     // Implementation logic
  }
  vectorMethod() {
    console.log("Functionality here");
  }
}

Ensure Compatibility:

Assert that _Vector constructs instances compatible with the desired type:

const Vector = _Vector as VectorConstructor;

Testing our setup:

const v = new Vector(0, 1, 4, 9, 16, 25); // Vector<6>
/* Expected Output:
{
    length: 6;
    0: number;
    1: number;
    2: number;
    3: number;
    4: number;
    5: number;
    vectorMethod: () => void;
} */

v[3]++; // Okay
v.vectorMethod();
v[10]; // Error

In conclusion, through this approach, we've managed to work around the restrictions imposed by TypeScript without compromising runtime objectives. While this method is effective, it comes with its own set of considerations and maintenance efforts if expansion or implementation scenarios emerge.

What is the proper way to define a tuple type with a specific size N for the vector class in C++?

Answer №1

Similar questions

Selecting any of the bar chart labels will reveal just a two-day timeframe

Template for typed variable - `ng-template`

Testing a click event in Angular that triggers only the navigateByUrl function, utilizing Jasmin and Karma

What is the best way to decouple the data layer from Next.js API routes?

Calling a typed function with conditional types in Typescript from within another function

Using FIND to search an array object results in an error: Type 'undefined' is not compatible with type ''

Creating synchronous behavior using promises in Javascript

Using TypeScript to consolidate numerous interfaces into a single interface

The issue encountered during a POST request in Postman is a SyntaxError where a number is missing after the minus sign in a JSON object at position 1 (line 1

Currency symbol display option "narrowSymbol" is not compatible with Next.Js 9.4.4 when using Intl.NumberFormat

How to extract and compare elements from an array using Typescript in Angular 6

Type Vue does not contain the specified property

Is it advisable to encapsulate my entire Express server within a TypeScript class?

Issue with retrieving the positions of two numbers in an array

Disable the default animation

Angular 7 ESRI loader search widget focus out bug: finding a solution

What is the reason behind typescript making it necessary for me to find a way to set a value of type

Modifying an Angular Component Template following an API Response

Encountering a duplication issue when redirecting components in Angular2/TypeScript using navigateByUrl

Issue of displaying buttons based on sibling's height under certain conditions