Recently, Ben Newhouse released a TypeScript-based implementation of GPT called potatogpt. Although the performance may be slow, it contains a very interesting approach to type-checking tensor arithmetic. This approach eliminates the need to run your code to verify whether operations are allowed or to keep track of the sizes of tensors in your head.

The implementation is quite complex, employing several advanced TypeScript techniques. In order to make it more accessible and easier to understand, I’ve attempted to simplify and explain the implementation with clarifying comments below.

Finally, I show how this approach allows us to easily create type-safe versions of functions like zip and matmul.

Exact dimensions

In order that Tensors can have exact dimensions we need to support only numeric literals (e.g. 16, 768, etc) for sizes known at compile time, and “branded types” for sizes only known at runtime. We must disallow non-literal number types or unions of numbers (e.g. 16 | 768) as if these get introduced into an application, data produced using these would also lack exact dimensions.

// We check whether `T` is a numeric literal by checking that `number`
// does not extend from `T` but that `T` does extend from `number`.
type type IsNumericLiteral<T> = number extends T ? false : T extends number ? true : falseIsNumericLiteral<function (type parameter) T in type IsNumericLiteral<T>T> = number extends function (type parameter) T in type IsNumericLiteral<T>T ? false : function (type parameter) T in type IsNumericLiteral<T>T extends number ? true : false;

// In order to support runtime-determined sizes we use a "branded type"
// to give these dimensions labels that they can be type-checked with
// and a function `Var` to generate values with this type.
export type 
type Var<Label extends string> = number & {
    label: Label;
}Var<function (type parameter) Label in type Var<Label extends string>Label extends string> = number & { label: Label extends stringlabel: function (type parameter) Label in type Var<Label extends string>Label };
export const const Var: <Label extends string>(size: number, label: Label) => Var<Label>Var = <function (type parameter) Label in <Label extends string>(size: number, label: Label): Var<Label>Label extends string>(size: numbersize: number, label: Label extends stringlabel: function (type parameter) Label in <Label extends string>(size: number, label: Label): Var<Label>Label) => {
  return size: numbersize as 
type Var<Label extends string> = number & {
    label: Label;
}Var<function (type parameter) Label in <Label extends string>(size: number, label: Label): Var<Label>Label>;
};
type type IsVar<T> = T extends Var<string> ? true : falseIsVar<function (type parameter) T in type IsVar<T>T> = function (type parameter) T in type IsVar<T>T extends 
type Var<Label extends string> = number & {
    label: Label;
}Var<string> ? true : false;

// For type-checking of tensors to work they must only ever be
// created using numeric literals (e.g. `5`)  or `Var<string>`
// and never from types like `number` or `1 | 2 | 3`.
type type IsNumericLiteralOrVar<T extends number | Var<string>> = Not<IsUnion<T>> extends true ? Or<IsNumericLiteral<T>, IsVar<T>> extends true ? true : false : falseIsNumericLiteralOrVar<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T extends number | 
type Var<Label extends string> = number & {
    label: Label;
}Var<string>> = type And<A, B> = A extends true ? B extends true ? true : false : falseAnd<
  // We disallow `T` to be a union of types.
  type Not<A> = A extends true ? false : trueNot<type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : trueIsUnion<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T>>,
  type Or<A, B> = A extends true ? true : B extends true ? true : falseOr<
    // We allow `T` to be a numeric literal but not a number.
    type IsNumericLiteral<T> = number extends T ? false : T extends number ? true : falseIsNumericLiteral<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T>,
    // We allow `T` to be a `Var`.
    type IsVar<T> = T extends Var<string> ? true : falseIsVar<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T>
  >
>;

// Utilities
type type And<A, B> = A extends true ? B extends true ? true : false : falseAnd<function (type parameter) A in type And<A, B>A, function (type parameter) B in type And<A, B>B> = function (type parameter) A in type And<A, B>A extends true ? (function (type parameter) B in type And<A, B>B extends true ? true : false) : false;
type type Or<A, B> = A extends true ? true : B extends true ? true : falseOr<function (type parameter) A in type Or<A, B>A, function (type parameter) B in type Or<A, B>B> = function (type parameter) A in type Or<A, B>A extends true ? true : function (type parameter) B in type Or<A, B>B extends true ? true : false;
type type Not<A> = A extends true ? false : trueNot<function (type parameter) A in type Not<A>A> = function (type parameter) A in type Not<A>A extends true ? false : true;

// `IsUnion` is based on the principle that a union like `A | B` does not
// extend an intersection like `A & B`. The conditional type uses a
// "tuple trick" technique that avoids distributing the type `T` over
// `UnionToIntersection` by wrapping the type into a one-element tuple.
// This means that if `T` is `'A' | 'B'` the expression is evaluated
// as `['A' | 'B'] extends [UnionToIntersection<'A' | 'B'>]` instead of
// `'A' | 'B' extends UnionToIntersection<'A'> | UnionToIntersection<'B'>`.
type type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : trueIsUnion<function (type parameter) T in type IsUnion<T>T> = [function (type parameter) T in type IsUnion<T>T] extends [type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection : neverUnionToIntersection<function (type parameter) T in type IsUnion<T>T>] ? false : true;

// `UnionToIntersection` takes a union type and uses a "distributive
// conditional type" to map over each element of the union and create a
// series of function types with each element as their argument. It then
// infers the first argument of each of these functions to create a new
// type that is the intersection of all the types in the original union.
type type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection : neverUnionToIntersection<function (type parameter) Union in type UnionToIntersection<Union>Union> = (
  function (type parameter) Union in type UnionToIntersection<Union>Union extends unknown ? (distributedUnion: UniondistributedUnion: function (type parameter) Union in type UnionToIntersection<Union>Union) => void : never
) extends (mergedIntersection: IntersectionmergedIntersection: infer function (type parameter) IntersectionIntersection) => void
  ? function (type parameter) IntersectionIntersection
  : never;

If you need to, you can read further on the more advanced TypeScript techniques here:

• IsUnion
• UnionToIntersection
• “distributive conditional types”

Tensor

We can then implement a type-safe Tensor with a unique constraint: the dimensions must be specified using numeric literals or “branded types”. This approach pushes the limits of TypeScript’s standard type-checking capabilities and requires a non-idiomatic usage of conditional types to represent these errors. Note that, we diverged from Ben’s original implementation by enforcing this dimensional constraint at the argument-level instead of doing so at the return-level with a conditional return type that produces an invalid tensor. The downside of this is that you must use as const on the shape argument to prevent TypeScript from widening the literal types to number.

type type IsNumericLiteral<T> = number extends T ? false : T extends number ? true : falseIsNumericLiteral<function (type parameter) T in type IsNumericLiteral<T>T> = number extends function (type parameter) T in type IsNumericLiteral<T>T ? false : function (type parameter) T in type IsNumericLiteral<T>T extends number ? true : false;

export type 
type Var<Label extends string> = number & {
    label: Label;
}Var<function (type parameter) Label in type Var<Label extends string>Label extends string> = number & { label: Label extends stringlabel: function (type parameter) Label in type Var<Label extends string>Label };
export const const Var: <Label extends string>(size: number, label: Label) => Var<Label>Var = <function (type parameter) Label in <Label extends string>(size: number, label: Label): Var<Label>Label extends string>(size: numbersize: number, label: Label extends stringlabel: function (type parameter) Label in <Label extends string>(size: number, label: Label): Var<Label>Label) => {
  return size: numbersize as 
type Var<Label extends string> = number & {
    label: Label;
}Var<function (type parameter) Label in <Label extends string>(size: number, label: Label): Var<Label>Label>;
};
type type IsVar<T> = T extends Var<string> ? true : falseIsVar<function (type parameter) T in type IsVar<T>T> = function (type parameter) T in type IsVar<T>T extends 
type Var<Label extends string> = number & {
    label: Label;
}Var<string> ? true : false;

type type IsNumericLiteralOrVar<T extends number | Var<string>> = Not<IsUnion<T>> extends true ? Or<IsNumericLiteral<T>, IsVar<T>> extends true ? true : false : falseIsNumericLiteralOrVar<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T extends number | 
type Var<Label extends string> = number & {
    label: Label;
}Var<string>> = type And<A, B> = A extends true ? B extends true ? true : false : falseAnd<
  // We disallow `T` to be a union of types.
  type Not<A> = A extends true ? false : trueNot<type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : trueIsUnion<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T>>,
  type Or<A, B> = A extends true ? true : B extends true ? true : falseOr<
    // We allow `T` to be a numeric literal but not a number.
    type IsNumericLiteral<T> = number extends T ? false : T extends number ? true : falseIsNumericLiteral<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T>,
    // We allow `T` to be a `Var`.
    type IsVar<T> = T extends Var<string> ? true : falseIsVar<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T>
  >
>;

type type And<A, B> = A extends true ? B extends true ? true : false : falseAnd<function (type parameter) A in type And<A, B>A, function (type parameter) B in type And<A, B>B> = function (type parameter) A in type And<A, B>A extends true ? (function (type parameter) B in type And<A, B>B extends true ? true : false) : false;
type type Or<A, B> = A extends true ? true : B extends true ? true : falseOr<function (type parameter) A in type Or<A, B>A, function (type parameter) B in type Or<A, B>B> = function (type parameter) A in type Or<A, B>A extends true ? true : function (type parameter) B in type Or<A, B>B extends true ? true : false;
type type Not<A> = A extends true ? false : trueNot<function (type parameter) A in type Not<A>A> = function (type parameter) A in type Not<A>A extends true ? false : true;

type type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : trueIsUnion<function (type parameter) T in type IsUnion<T>T> = [function (type parameter) T in type IsUnion<T>T] extends [type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection : neverUnionToIntersection<function (type parameter) T in type IsUnion<T>T>] ? false : true;
type type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection : neverUnionToIntersection<function (type parameter) Union in type UnionToIntersection<Union>Union> = (
  function (type parameter) Union in type UnionToIntersection<Union>Union extends unknown ? (distributedUnion: UniondistributedUnion: function (type parameter) Union in type UnionToIntersection<Union>Union) => void : never
) extends (mergedIntersection: IntersectionmergedIntersection: infer function (type parameter) IntersectionIntersection) => void
  ? function (type parameter) IntersectionIntersection
  : never;

/// ---cut---

export type type Dimension = number | Var<string>Dimension = number | 
type Var<Label extends string> = number & {
    label: Label;
}Var<string>;
export type 
type Tensor<Shape extends readonly Dimension[]> = {
    data: Float32Array;
    shape: Shape;
}Tensor<function (type parameter) Shape in type Tensor<Shape extends readonly Dimension[]>Shape extends readonly type Dimension = number | Var<string>Dimension[]> = {
  data: Float32Array<ArrayBufferLike>data: interface Float32Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>
A typed array of 32-bit float values. The contents are initialized to 0. If the requested number
of bytes could not be allocated an exception is raised.Float32Array;
  shape: Shape extends readonly Dimension[]shape: function (type parameter) Shape in type Tensor<Shape extends readonly Dimension[]>Shape;
};
export function function tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>tensor<const function (type parameter) Shape in tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>Shape extends readonly type Dimension = number | Var<string>Dimension[]>(
  shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>shape: type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>> = true extends ArrayEveryElementIsNumericLiteralOrVar<T> ? T : readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[]AssertShapeEveryElementIsNumericLiteralOrVar<function (type parameter) Shape in tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>Shape>,
  init: number[] | undefinedinit?: number[],
): 
type Tensor<Shape extends readonly Dimension[]> = {
    data: Float32Array;
    shape: Shape;
}Tensor<function (type parameter) Shape in tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>Shape> {
  return {
    data: Float32Array<ArrayBufferLike>data: init: number[] | undefinedinit
      ? new 
var Float32Array: Float32ArrayConstructor
new (elements: Iterable<number>) => Float32Array<ArrayBuffer> (+6 overloads)Float32Array(init: number[]init)
      : new 
var Float32Array: Float32ArrayConstructor
new (length: number) => Float32Array<ArrayBuffer> (+6 overloads)Float32Array((shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>shape as function (type parameter) Shape in tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>Shape).ReadonlyArray<Dimension>.reduce(callbackfn: (previousValue: Dimension, currentValue: Dimension, currentIndex: number, array: readonly Dimension[]) => Dimension, initialValue: Dimension): Dimension (+2 overloads)
Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
@paramcallbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.@paraminitialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.reduce((a: Dimensiona, b: Dimensionb) => a: Dimensiona * b: Dimensionb, 1)),
    shape: const Shape extends readonly Dimension[]shape: shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>shape as function (type parameter) Shape in tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>Shape,
  };
}

// `ArrayEveryElementIsNumericLiteralOrVar` is similar to JavaScript's
// `Array#every` in that it checks that a particular condition is true of
// every element in an array and returns `true` if this is the case. In
// TypeScript we have to hardcode our condition (`IsNumericLiteralOrVar`)
// as we do not yet have higher-kinded generic types that can take in
// other generic types and apply these.
//
// In the code below we create a "mapped object type" from an array type
// and then apply the condition to each value in the mapped object type.
// We then use a conditional type to check whether the type outputted
// extends from a type in which the value at every key is `true`.
type type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>> = T extends readonly unknown[] ? { [K in keyof T]: And<Not<IsUnion<T[K]>>, Or<IsNumericLiteral<T[K]>, IsVar<T[K]>>>; } extends { [K in keyof T]: true; } ? true : false : falseArrayEveryElementIsNumericLiteralOrVar<function (type parameter) T in type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T extends interface ReadonlyArray<T>ReadonlyArray<number | 
type Var<Label extends string> = number & {
    label: Label;
}Var<string>>> =
  function (type parameter) T in type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T extends interface ReadonlyArray<T>ReadonlyArray<unknown>
    ? { [function (type parameter) KK in keyof function (type parameter) T in type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T]: type IsNumericLiteralOrVar<T extends number | Var<string>> = Not<IsUnion<T>> extends true ? Or<IsNumericLiteral<T>, IsVar<T>> extends true ? true : false : falseIsNumericLiteralOrVar<function (type parameter) T in type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T[function (type parameter) KK]> } extends {
        [function (type parameter) KK in keyof function (type parameter) T in type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T]: true;
      }
      ? true
      : false
    : false;

type type InvalidArgument<T> = readonly [never, T]InvalidArgument<function (type parameter) T in type InvalidArgument<T>T> = readonly [never, function (type parameter) T in type InvalidArgument<T>T];
type type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>> = true extends ArrayEveryElementIsNumericLiteralOrVar<T> ? T : readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[]AssertShapeEveryElementIsNumericLiteralOrVar<function (type parameter) T in type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T extends interface ReadonlyArray<T>ReadonlyArray<number | 
type Var<Label extends string> = number & {
    label: Label;
}Var<string>>> =
  true extends type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>> = T extends readonly unknown[] ? { [K in keyof T]: And<Not<IsUnion<T[K]>>, Or<IsNumericLiteral<T[K]>, IsVar<T[K]>>>; } extends { [K in keyof T]: true; } ? true : false : falseArrayEveryElementIsNumericLiteralOrVar<function (type parameter) T in type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T>
    ? function (type parameter) T in type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T
    : interface ReadonlyArray<T>ReadonlyArray<
        type InvalidArgument<T> = readonly [never, T]InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">
      >;

// Tests
const const fourDimensionalTensorWithStaticSizes: Tensor<readonly [10, 100, 1000, 10000]>fourDimensionalTensorWithStaticSizes = function tensor<readonly [10, 100, 1000, 10000]>(shape: readonly [10, 100, 1000, 10000], init?: number[]): Tensor<readonly [10, 100, 1000, 10000]>tensor([10, 100, 1000, 10000] as type const = readonly [10, 100, 1000, 10000]const);
const const threeDimensionalTensorWithRuntimeSize: Tensor<readonly [5, Var<"dim">, 10]>threeDimensionalTensorWithRuntimeSize = function tensor<readonly [5, Var<"dim">, 10]>(shape: readonly [5, Var<"dim">, 10], init?: number[]): Tensor<readonly [5, Var<"dim">, 10]>tensor([5, const Var: <"dim">(size: number, label: "dim") => Var<"dim">Var(3, "dim"), 10] as type const = readonly [5, Var<"dim">, 10]const);

const const invalidTensor1: Tensor<readonly [10, 100, 1000, 10000]>invalidTensor1 = function tensor<readonly [10, 100, 1000, 10000]>(shape: readonly [10, 100, 1000, 10000], init?: number[]): Tensor<readonly [10, 100, 1000, 10000]>tensor([10, 100, 1000, 10000]);
const const invalidTensor2: Tensor<readonly [number, 100, 1000, 10000]>invalidTensor2 = function tensor<readonly [number, 100, 1000, 10000]>(shape: readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[], init?: number[]): Tensor<readonly [number, 100, 1000, 10000]>tensor([10 as number, 100, 1000, 10000] as type const = readonly [number, 100, 1000, 10000]const);
Type 'number' is not assignable to type 'InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">'.
Type 'number' is not assignable to type 'InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">'.
Type 'number' is not assignable to type 'InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">'.
Type 'number' is not assignable to type 'InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">'.
const const invalidTensor3: Tensor<readonly [5, 3 | 6 | 9, 10]>invalidTensor3 = function tensor<readonly [5, 3 | 6 | 9, 10]>(shape: readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[], init?: number[]): Tensor<readonly [5, 3 | 6 | 9, 10]>tensor([5, 3 as 3 | 6 | 9, 10] as type const = readonly [5, 3 | 6 | 9, 10]const);
Type 'number' is not assignable to type 'InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">'.
Type 'number' is not assignable to type 'InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">'.
  Type 'number' is not assignable to type 'readonly [never, "The `shape` argument must be marked `as const` and only contain number literals or branded types."]'.
Type 'number' is not assignable to type 'InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">'.

If you need to, you can read further on the more advanced TypeScript techniques here:

• “mapped types”
• “conditional types”
• “branded types”

Matrix

type type IsNumericLiteral<T> = number extends T ? false : T extends number ? true : falseIsNumericLiteral<function (type parameter) T in type IsNumericLiteral<T>T> = number extends function (type parameter) T in type IsNumericLiteral<T>T ? false : function (type parameter) T in type IsNumericLiteral<T>T extends number ? true : false;

export type 
type Var<Label extends string> = number & {
    label: Label;
}Var<function (type parameter) Label in type Var<Label extends string>Label extends string> = number & { label: Label extends stringlabel: function (type parameter) Label in type Var<Label extends string>Label };
export const const Var: <Label extends string>(size: number, label: Label) => Var<Label>Var = <function (type parameter) Label in <Label extends string>(size: number, label: Label): Var<Label>Label extends string>(size: numbersize: number, label: Label extends stringlabel: function (type parameter) Label in <Label extends string>(size: number, label: Label): Var<Label>Label) => {
  return size: numbersize as 
type Var<Label extends string> = number & {
    label: Label;
}Var<function (type parameter) Label in <Label extends string>(size: number, label: Label): Var<Label>Label>;
};
type type IsVar<T> = T extends Var<string> ? true : falseIsVar<function (type parameter) T in type IsVar<T>T> = function (type parameter) T in type IsVar<T>T extends 
type Var<Label extends string> = number & {
    label: Label;
}Var<string> ? true : false;

type type IsNumericLiteralOrVar<T extends number | Var<string>> = Not<IsUnion<T>> extends true ? Or<IsNumericLiteral<T>, IsVar<T>> extends true ? true : false : falseIsNumericLiteralOrVar<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T extends number | 
type Var<Label extends string> = number & {
    label: Label;
}Var<string>> = type And<A, B> = A extends true ? B extends true ? true : false : falseAnd<
  // We disallow `T` to be a union of types.
  type Not<A> = A extends true ? false : trueNot<type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : trueIsUnion<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T>>,
  type Or<A, B> = A extends true ? true : B extends true ? true : falseOr<
    // We allow `T` to be a numeric literal but not a number.
    type IsNumericLiteral<T> = number extends T ? false : T extends number ? true : falseIsNumericLiteral<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T>,
    // We allow `T` to be a `Var`.
    type IsVar<T> = T extends Var<string> ? true : falseIsVar<function (type parameter) T in type IsNumericLiteralOrVar<T extends number | Var<string>>T>
  >
>;

type type And<A, B> = A extends true ? B extends true ? true : false : falseAnd<function (type parameter) A in type And<A, B>A, function (type parameter) B in type And<A, B>B> = function (type parameter) A in type And<A, B>A extends true ? (function (type parameter) B in type And<A, B>B extends true ? true : false) : false;
type type Or<A, B> = A extends true ? true : B extends true ? true : falseOr<function (type parameter) A in type Or<A, B>A, function (type parameter) B in type Or<A, B>B> = function (type parameter) A in type Or<A, B>A extends true ? true : function (type parameter) B in type Or<A, B>B extends true ? true : false;
type type Not<A> = A extends true ? false : trueNot<function (type parameter) A in type Not<A>A> = function (type parameter) A in type Not<A>A extends true ? false : true;

type type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : trueIsUnion<function (type parameter) T in type IsUnion<T>T> = [function (type parameter) T in type IsUnion<T>T] extends [type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection : neverUnionToIntersection<function (type parameter) T in type IsUnion<T>T>] ? false : true;
type type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection : neverUnionToIntersection<function (type parameter) Union in type UnionToIntersection<Union>Union> = (
  function (type parameter) Union in type UnionToIntersection<Union>Union extends unknown ? (distributedUnion: UniondistributedUnion: function (type parameter) Union in type UnionToIntersection<Union>Union) => void : never
) extends (mergedIntersection: IntersectionmergedIntersection: infer function (type parameter) IntersectionIntersection) => void
  ? function (type parameter) IntersectionIntersection
  : never;

export type type Dimension = number | Var<string>Dimension = number | 
type Var<Label extends string> = number & {
    label: Label;
}Var<string>;
export type 
type Tensor<Shape extends readonly Dimension[]> = {
    data: Float32Array;
    shape: Shape;
}Tensor<function (type parameter) Shape in type Tensor<Shape extends readonly Dimension[]>Shape extends readonly type Dimension = number | Var<string>Dimension[]> = {
  data: Float32Array<ArrayBufferLike>data: interface Float32Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>
A typed array of 32-bit float values. The contents are initialized to 0. If the requested number
of bytes could not be allocated an exception is raised.Float32Array;
  shape: Shape extends readonly Dimension[]shape: function (type parameter) Shape in type Tensor<Shape extends readonly Dimension[]>Shape;
};
export function function tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>tensor<const function (type parameter) Shape in tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>Shape extends readonly type Dimension = number | Var<string>Dimension[]>(
  shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>shape: type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>> = true extends ArrayEveryElementIsNumericLiteralOrVar<T> ? T : readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[]AssertShapeEveryElementIsNumericLiteralOrVar<function (type parameter) Shape in tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>Shape>,
  init: number[] | undefinedinit?: number[],
): 
type Tensor<Shape extends readonly Dimension[]> = {
    data: Float32Array;
    shape: Shape;
}Tensor<function (type parameter) Shape in tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>Shape> {
  return {
    data: Float32Array<ArrayBufferLike>data: init: number[] | undefinedinit
      ? new 
var Float32Array: Float32ArrayConstructor
new (elements: Iterable<number>) => Float32Array<ArrayBuffer> (+6 overloads)Float32Array(init: number[]init)
      : new 
var Float32Array: Float32ArrayConstructor
new (length: number) => Float32Array<ArrayBuffer> (+6 overloads)Float32Array((shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>shape as function (type parameter) Shape in tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>Shape).ReadonlyArray<Dimension>.reduce(callbackfn: (previousValue: Dimension, currentValue: Dimension, currentIndex: number, array: readonly Dimension[]) => Dimension, initialValue: Dimension): Dimension (+2 overloads)
Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
@paramcallbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.@paraminitialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.reduce((a: Dimensiona, b: Dimensionb) => a: Dimensiona * b: Dimensionb, 1)),
    shape: const Shape extends readonly Dimension[]shape: shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>shape as function (type parameter) Shape in tensor<const Shape extends readonly Dimension[]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Tensor<Shape>Shape,
  };
}

type type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>> = T extends readonly unknown[] ? { [K in keyof T]: And<Not<IsUnion<T[K]>>, Or<IsNumericLiteral<T[K]>, IsVar<T[K]>>>; } extends { [K in keyof T]: true; } ? true : false : falseArrayEveryElementIsNumericLiteralOrVar<function (type parameter) T in type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T extends interface ReadonlyArray<T>ReadonlyArray<number | 
type Var<Label extends string> = number & {
    label: Label;
}Var<string>>> =
  function (type parameter) T in type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T extends interface ReadonlyArray<T>ReadonlyArray<unknown>
    ? { [function (type parameter) KK in keyof function (type parameter) T in type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T]: type IsNumericLiteralOrVar<T extends number | Var<string>> = Not<IsUnion<T>> extends true ? Or<IsNumericLiteral<T>, IsVar<T>> extends true ? true : false : falseIsNumericLiteralOrVar<function (type parameter) T in type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T[function (type parameter) KK]> } extends {
        [function (type parameter) KK in keyof function (type parameter) T in type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T]: true;
      }
      ? true
      : false
    : false;

type type InvalidArgument<T> = readonly [never, T]InvalidArgument<function (type parameter) T in type InvalidArgument<T>T> = readonly [never, function (type parameter) T in type InvalidArgument<T>T];
type type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>> = true extends ArrayEveryElementIsNumericLiteralOrVar<T> ? T : readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[]AssertShapeEveryElementIsNumericLiteralOrVar<function (type parameter) T in type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T extends interface ReadonlyArray<T>ReadonlyArray<number | 
type Var<Label extends string> = number & {
    label: Label;
}Var<string>>> =
  true extends type ArrayEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>> = T extends readonly unknown[] ? { [K in keyof T]: And<Not<IsUnion<T[K]>>, Or<IsNumericLiteral<T[K]>, IsVar<T[K]>>>; } extends { [K in keyof T]: true; } ? true : false : falseArrayEveryElementIsNumericLiteralOrVar<function (type parameter) T in type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T>
    ? function (type parameter) T in type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>>T
    : interface ReadonlyArray<T>ReadonlyArray<
        type InvalidArgument<T> = readonly [never, T]InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">
      >;

/// ---cut---

function function isDimensionArray(maybeDimensionArray: any): maybeDimensionArray is readonly Dimension[]isDimensionArray(maybeDimensionArray: anymaybeDimensionArray: any): maybeDimensionArray: anymaybeDimensionArray is readonly type Dimension = number | Var<string>Dimension[] {
  return (
    var Array: ArrayConstructorArray.ArrayConstructor.isArray(arg: any): arg is any[]isArray(maybeDimensionArray: anymaybeDimensionArray) && maybeDimensionArray: any[]maybeDimensionArray.Array<any>.some(predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): boolean
Determines whether the specified callback function returns true for any element of an array.
@parampredicate A function that accepts up to three arguments. The some method calls
the predicate function for each element in the array until the predicate returns a value
which is coercible to the Boolean value true, or until the end of the array.@paramthisArg An object to which the this keyword can refer in the predicate function.
If thisArg is omitted, undefined is used as the this value.some((d: anyd) => typeof d: anyd === "number")
  );
}
function function is2DArray(maybe2DArray: any): maybe2DArray is number[][]is2DArray(maybe2DArray: anymaybe2DArray: any): maybe2DArray: anymaybe2DArray is number[][] {
  return var Array: ArrayConstructorArray.ArrayConstructor.isArray(arg: any): arg is any[]isArray(maybe2DArray: anymaybe2DArray) && maybe2DArray: any[]maybe2DArray.Array<any>.some(predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): boolean
Determines whether the specified callback function returns true for any element of an array.
@parampredicate A function that accepts up to three arguments. The some method calls
the predicate function for each element in the array until the predicate returns a value
which is coercible to the Boolean value true, or until the end of the array.@paramthisArg An object to which the this keyword can refer in the predicate function.
If thisArg is omitted, undefined is used as the this value.some((row: anyrow) => var Array: ArrayConstructorArray.ArrayConstructor.isArray(arg: any): arg is any[]isArray(row: anyrow));
}
function function flat<T>(arr: T[][]): T[]flat<function (type parameter) T in flat<T>(arr: T[][]): T[]T>(arr: T[][]arr: function (type parameter) T in flat<T>(arr: T[][]): T[]T[][]): function (type parameter) T in flat<T>(arr: T[][]): T[]T[] {
  let let result: T[]result: function (type parameter) T in flat<T>(arr: T[][]): T[]T[] = [];
  for (let let i: numberi = 0; let i: numberi < arr: T[][]arr.Array<T[]>.length: number
Gets or sets the length of the array. This is a number one higher than the highest index in the array.length; let i: numberi++) {
    let result: T[]result.Array<T>.push(...items: T[]): number
Appends new elements to the end of an array, and returns the new length of the array.
@paramitems New elements to add to the array.push.CallableFunction.apply<T[], T[], number>(this: (this: T[], ...args: T[]) => number, thisArg: T[], args: T[]): number (+1 overload)
Calls the function with the specified object as the this value and the elements of specified array as the arguments.
@paramthisArg The object to be used as the this object.@paramargs An array of argument values to be passed to the function.apply(let result: T[]result, arr: T[][]arr[let i: numberi]);
  }
  return let result: T[]result;
}

export type 
type Matrix<Rows extends Dimension, Columns extends Dimension> = {
    data: Float32Array;
    shape: readonly [Rows, Columns];
}Matrix<function (type parameter) Rows in type Matrix<Rows extends Dimension, Columns extends Dimension>Rows extends type Dimension = number | Var<string>Dimension, function (type parameter) Columns in type Matrix<Rows extends Dimension, Columns extends Dimension>Columns extends type Dimension = number | Var<string>Dimension> = 
type Tensor<Shape extends readonly Dimension[]> = {
    data: Float32Array;
    shape: Shape;
}Tensor<
  readonly [function (type parameter) Rows in type Matrix<Rows extends Dimension, Columns extends Dimension>Rows, function (type parameter) Columns in type Matrix<Rows extends Dimension, Columns extends Dimension>Columns]
>;
export function function matrix<const TwoDArray extends ReadonlyArray<ReadonlyArray<number>>>(init: TwoDArray): Matrix<TwoDArray["length"], TwoDArray[0]["length"]> (+1 overload)matrix<const function (type parameter) TwoDArray in matrix<const TwoDArray extends ReadonlyArray<ReadonlyArray<number>>>(init: TwoDArray): Matrix<TwoDArray["length"], TwoDArray[0]["length"]>TwoDArray extends interface ReadonlyArray<T>ReadonlyArray<interface ReadonlyArray<T>ReadonlyArray<number>>>(
  init: const TwoDArray extends ReadonlyArray<ReadonlyArray<number>>init: function (type parameter) TwoDArray in matrix<const TwoDArray extends ReadonlyArray<ReadonlyArray<number>>>(init: TwoDArray): Matrix<TwoDArray["length"], TwoDArray[0]["length"]>TwoDArray,
): 
type Matrix<Rows extends Dimension, Columns extends Dimension> = {
    data: Float32Array;
    shape: readonly [Rows, Columns];
}Matrix<function (type parameter) TwoDArray in matrix<const TwoDArray extends ReadonlyArray<ReadonlyArray<number>>>(init: TwoDArray): Matrix<TwoDArray["length"], TwoDArray[0]["length"]>TwoDArray["length"], function (type parameter) TwoDArray in matrix<const TwoDArray extends ReadonlyArray<ReadonlyArray<number>>>(init: TwoDArray): Matrix<TwoDArray["length"], TwoDArray[0]["length"]>TwoDArray[0]["length"]>;
export function function matrix<const Shape extends readonly [Dimension, Dimension]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Matrix<Shape[0], Shape[1]> (+1 overload)matrix<const function (type parameter) Shape in matrix<const Shape extends readonly [Dimension, Dimension]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Matrix<Shape[0], Shape[1]>Shape extends readonly [type Dimension = number | Var<string>Dimension, type Dimension = number | Var<string>Dimension]>(
  shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>shape: type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>> = true extends ArrayEveryElementIsNumericLiteralOrVar<T> ? T : readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[]AssertShapeEveryElementIsNumericLiteralOrVar<function (type parameter) Shape in matrix<const Shape extends readonly [Dimension, Dimension]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Matrix<Shape[0], Shape[1]>Shape>,
  init: number[] | undefinedinit?: number[],
): 
type Matrix<Rows extends Dimension, Columns extends Dimension> = {
    data: Float32Array;
    shape: readonly [Rows, Columns];
}Matrix<function (type parameter) Shape in matrix<const Shape extends readonly [Dimension, Dimension]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Matrix<Shape[0], Shape[1]>Shape[0], function (type parameter) Shape in matrix<const Shape extends readonly [Dimension, Dimension]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Matrix<Shape[0], Shape[1]>Shape[1]>;
export function function matrix<const TwoDArray extends ReadonlyArray<ReadonlyArray<number>>>(init: TwoDArray): Matrix<TwoDArray["length"], TwoDArray[0]["length"]> (+1 overload)matrix<const function (type parameter) Shape in matrix<const Shape extends readonly [Dimension, Dimension]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Matrix<Shape[0], Shape[1]>Shape extends readonly [type Dimension = number | Var<string>Dimension, type Dimension = number | Var<string>Dimension]>(
  shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>shape: type AssertShapeEveryElementIsNumericLiteralOrVar<T extends ReadonlyArray<number | Var<string>>> = true extends ArrayEveryElementIsNumericLiteralOrVar<T> ? T : readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[]AssertShapeEveryElementIsNumericLiteralOrVar<function (type parameter) Shape in matrix<const Shape extends readonly [Dimension, Dimension]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Matrix<Shape[0], Shape[1]>Shape>,
  init: number[] | undefinedinit?: number[],
): 
type Matrix<Rows extends Dimension, Columns extends Dimension> = {
    data: Float32Array;
    shape: readonly [Rows, Columns];
}Matrix<function (type parameter) Shape in matrix<const Shape extends readonly [Dimension, Dimension]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Matrix<Shape[0], Shape[1]>Shape[0], function (type parameter) Shape in matrix<const Shape extends readonly [Dimension, Dimension]>(shape: AssertShapeEveryElementIsNumericLiteralOrVar<Shape>, init?: number[]): Matrix<Shape[0], Shape[1]>Shape[1]> {
  let let resolvedShape: readonly [any, any]resolvedShape: readonly [any, any];
  if (function isDimensionArray(maybeDimensionArray: any): maybeDimensionArray is readonly Dimension[]isDimensionArray(shape: readonly [Dimension, Dimension] | readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[]shape)) {
    let resolvedShape: readonly [any, any]resolvedShape = shape: readonly [Dimension, Dimension]shape;
  } else if (function is2DArray(maybe2DArray: any): maybe2DArray is number[][]is2DArray(shape: readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[]shape)) {
    let resolvedShape: readonly [any, any]resolvedShape = [shape: readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[] & number[][]shape.length: number
Gets the length of the array. This is a number one higher than the highest element defined in an array.


Gets or sets the length of the array. This is a number one higher than the highest index in the array.length, shape: readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[] & number[][]shape[0].Array<T>.length: 2
Gets or sets the length of the array. This is a number one higher than the highest index in the array.length];
    init: number[] | undefinedinit = function flat<number>(arr: number[][]): number[]flat(shape: readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[] & number[][]shape);
  } else {
    throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)Error("Invalid shape type for matrix.");
  }

  return function tensor<readonly [any, any]>(shape: readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[], init?: number[]): Tensor<readonly [any, any]>tensor(let resolvedShape: readonly [any, any]resolvedShape, init: number[] | undefinedinit);
}

// Tests
const const matrixWithStaticSizes: Matrix<25, 50>matrixWithStaticSizes = function matrix<readonly [25, 50]>(shape: readonly [25, 50], init?: number[]): Matrix<25, 50> (+1 overload)matrix([25, 50] as type const = readonly [25, 50]const);
const const matrixWithRuntimeSize: Matrix<10, Var<"configuredDimensionName">>matrixWithRuntimeSize = function matrix<readonly [10, Var<"configuredDimensionName">]>(shape: readonly [10, Var<"configuredDimensionName">], init?: number[]): Matrix<10, Var<"configuredDimensionName">> (+1 overload)matrix([10, const Var: <"configuredDimensionName">(size: number, label: "configuredDimensionName") => Var<"configuredDimensionName">Var(100, "configuredDimensionName")] as type const = readonly [10, Var<"configuredDimensionName">]const);
const const matrixWithSizeFromData: Matrix<3, 3>matrixWithSizeFromData = function matrix<readonly [readonly [1, 2, 3], readonly [4, 5, 6], readonly [7, 8, 9]]>(init: readonly [readonly [1, 2, 3], readonly [4, 5, 6], readonly [7, 8, 9]]): Matrix<3, 3> (+1 overload)matrix([
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9],
]);

const const invalidMatrix1: Matrix<25, 50>invalidMatrix1 = function matrix<readonly [25, 50]>(shape: readonly [25, 50], init?: number[]): Matrix<25, 50> (+1 overload)matrix([25, 50]);
const const invalidMatrix2: Matrix<number, number>invalidMatrix2 = matrix([25 as number, 50] as type const = readonly [number, 50]const);
No overload matches this call.
  Overload 2 of 2, '(shape: readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[], init?: number[] | undefined): Matrix<...>', gave the following error.
    Type 'number' is not assignable to type 'InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">'.
  Overload 2 of 2, '(shape: readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[], init?: number[] | undefined): Matrix<...>', gave the following error.
    Type 'number' is not assignable to type 'InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">'.
const const invalidMatrix3: Matrix<number, number>invalidMatrix3 = matrix([10, 100 as 100 | 115] as type const = readonly [10, 100 | 115]const);
No overload matches this call.
  Overload 2 of 2, '(shape: readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[], init?: number[] | undefined): Matrix<...>', gave the following error.
    Type 'number' is not assignable to type 'InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">'.
  Overload 2 of 2, '(shape: readonly InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">[], init?: number[] | undefined): Matrix<...>', gave the following error.
    Type 'number' is not assignable to type 'InvalidArgument<"The `shape` argument must be marked `as const` and only contain number literals or branded types.">'.
      Type 'number' is not assignable to type 'readonly [never, "The `shape` argument must be marked `as const` and only contain number literals or branded types."]'.