Use "as const" in Typescript without adding "readonly" modifiers?

Question

If I want to define a tuple or constant object shape, I'd use as const. E.g.:

const arr = [{ a: 1 }] as const;

/* readonly [{
  readonly a: 1;
}] */

However, I don't want readonly because I'd get a lot of The type 'readonly ...' is 'readonly' and cannot be assigned to the mutable type '...'

I defined a "Mutable" generic:

type Mutable<T> = {
  -readonly [K in keyof T]: Mutable<T[K]>;
}

type Arr = Mutable<typeof arr>;

/* [Mutable<{
    readonly a: 1;
}>] */

However, TS doesn't recursively apply Mutable in VS Code's type preview. In other words, I want VS Code's type preview to show:

/* [{
    a: 1;
}] */

I don't think it's possible for VS Code to recursively evaluate Mutable, since it could be too slow.

Is there something like as const, but without adding readonly?

So what *do* you want? If you're looking for `const arr: [{a: number}] = [{a: 1}];`, then just write that. — Bergi, Jul 05 '21 at 01:50
If there's something like as const, but without adding readonly, then that's what I want — Leo Jiang, Jul 05 '21 at 02:22
Yes, but with a syntax as simple as `as const`. I'm assuming it's not possible — Leo Jiang, Jul 05 '21 at 05:23

captain-yossarian from Ukraine · Answer 1 · 2021-07-05T07:35:17.867

In fact, you already made this array mutable. But you probably have noticed that type of first element is {a: 1}

const arr = [{ a: 1 }] as const;

type Mutable<T> = {
    -readonly [K in keyof T]:  Mutable<T[K]>;
}

type Arr = Mutable<typeof arr>[0]; // {a: 1}

Because a has literal type number 1, you still can't mutate the element.

Sorry, you can, but you are allowed to use only 1

const x: Arr = [{ a: 1 }]
x[0].a = 1 // ok

In order to make it fully mutable, you should map all literal types to more commont types.

1 -> number


type LiteralToCommon<T extends PropertyKey> =
    T extends number
    ? number : T extends string
    ? string : T extends symbol
    ? symbol : never;

type Mutable<T> = {
    -readonly [K in keyof T]: T[K] extends PropertyKey ? LiteralToCommon<T[K]> : Mutable<T[K]>;
}

const arr = [{ a: 1 }] as const;


type Arr = Mutable<typeof arr>;

const x: Arr = [{ a: 1 }]

x[0].a = 10 // ok

Playground

There is an alternative way:

type Mutable<T> = {
    -readonly [K in keyof T]: Mutable<T[K]>;
}

const arr = [{ a: 1 }];

type ImmutableArr = Readonly<typeof arr>

type MutableArr = Mutable<ImmutableArr>

type Arr = Mutable<typeof arr>;

const x: MutableArr = [{ a: 1 }]

x[0].a = 10 // ok

You can use just Readonly for array. This util will infer {a: 1} as {a: number}

Use "as const" in Typescript without adding "readonly" modifiers?

1 Answers1

Linked