引数の型を number または string に制限し，引数の型と返り値の型が一致する TypeScript のtwice関数の実装方法

Question

前提・実現したいこと

TypeScript で， 以下のアルゴリズムと型制約を満たす twice 関数のソースコードが欲しい

アルゴリズム

• [x] 引数の型が number または string でない場合，エラーオブジェクト（実行時エラー）を返すこと（number， string 以外の型を引数で受け取らないようにするotherwiseに相当するもの）
  追記(DR;TL): 今回の質問の本質は「引数の型制約と引数と返り値の一致」なので，条件から削除する．　~~元々，関数型言語のパターンマッチングのように，想定外の型の条件分岐ができないようにすること，想定した型の条件分岐を強制的に書かせることの2つを満たすやり方をTypeScript で探していた． 一番目をdefaultとErrorの返却で満たせるのでは，と考えて条件に追加していた．　2つ目は，やり方が分からないので条件に入れていない　~~
• 数字(number)の場合は， その数字の2倍の値を返すこと
• 文字列(string)の場合は, その文字列を2回繰り返した文字列を返すこと

型制約

• 引数の型が number または string でない場合， 型エラー（コンパイルエラー）が発生すること
• 引数と返り値の型が一致しない場合， 型エラー（コンパイルエラー）が発生すること (引数が T で返り値が T 以外の場合)

発生している問題・エラーメッセージ

Type 'number' is not assignable to type 'T'.
  'number' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'Twicable'.(2322)

Type 'string' is not assignable to type 'T'.
  'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'Twicable'.(2322)

該当のソースコード

twice関数 例1 | TypeSctipt Playground

function assertNever(x: any): never {
    throw new Error("Unexpected object: " + x);
}

type Twiceable = number | string;

function twice<T extends Twiceable>(x: T): T {
    switch (typeof x) {
        case 'number':
            return x * 2; // should not be type error
            // return 'hello' + 'hello'; // should be type error
        case 'string':
            return x + x; // should not be type error
            // return 2 * 2; // should be type error
        default:
            return assertNever(x);
    }
}

console.log(twice(2));
console.log(twice('hello'));
console.log(twice(true)); // should be type error

試したこと

返り値を Twiceable に変更した． 上述の返り値のエラーは出なくなるが， 型制約の二番目 を満たせない．

twice関数 例2 | TypeSctipt Playground

function assertNever(x: any): never {
    throw new Error("Unexpected object: " + x);
}

type Twiceable = number | string;

// NOTE: change T of return value to Twicable
function twice<T extends Twiceable>(x: T): Twiceable {
    switch (typeof x) {
        case 'number':
            return 'hello' + 'hello'; // NOTE: should be error
        case 'string':
            return 2 * 2; // NOTE: should be error
        default:
            return assertNever(x);
    }
}

console.log(twice(2));
console.log(twice('hello'));
console.log(twice(true)); // should be error

コメントの指摘を元に考えたソースコード

type Twiceable = number | string;

function twice<T>(x: T): T {
    switch (typeof x) {
        case 'number':
            return x * 2; // should not be type error
            // return 'hello' + 'hello'; // should be type error
        case 'string':
            return x + x; // should not be type error
            // return 2 * 2; // should be type error

    }
    return never;
}

console.log(twice<number>(2));
console.log(twice<string>('hello'));
console.log(twice(true)); // should be type error

補足情報（FW/ツールのバージョンなど）

• TypeSript Playground
• TypeScript: オーバーロードメソッドを定義する方法

Comments

[maisumakun]

「// should be error」はコンパイルエラーでしょうか、実行時エラーでしょうか？そして、どのようなエラーが起きるべきところでしょうか。

[kuro3]

// shoud be error　の部分は，コンパイル時やエディタ等での赤線として，実行前に出るコンパイルエラーを想定しています．

例外として，アルゴリズムの一番目のエラーオブジェクトの部分のみ実行時エラーを想定しています

[kuro3]

具体的には，引数の型と返り値の型が異なる場合，以下のようなコンパイルエラーメッセージが出ることを期待しています．

```
// Type 'string' is not assignable to type 'number'.(2322)
case 'number':
return 'hello' + 'hello';

// Type 'number' is not assignable to type 'string'.(2322)
case 'string':
return 2 * 2;
```

同様に，指定外の引数の型の場合は，以下です

```
Argument of type 'true' is not assignable to parameter of type 'Twiceable'.(2345)
console.log(twice(true));
```

Answer 1

先の回答の関数の型宣言のオーバーロードでのやり方で、本質問の回答をしてみました。

twice関数 - 関数の型宣言のオーバーロード

function assertNever(x: any): never {
    throw new Error("Unexpected object: " + x);
}

type Twiceable = number | string;

// HACK: 1. `関数の型宣言のオーバーロード` での解決策
// TODO: オーバロードの numberとstringをTwiceableを使って動的に宣言したい
//       または、 2 `型演算で導出` での解決策
function twice(x: number): number;
function twice(x: string): string;
function twice<T extends Twiceable>(x: T) {
    switch (typeof x) {
        case 'number':
            return x * 2; // should not be type error
            // return 'hello' + 'hello'; // should be type error
        case 'string':
            return x + x; // should not be type error
            // return 2 * 2; // should be type error
        default:
            return assertNever(x);
    }
}

console.log(twice(2));
console.log(twice('hello'));
console.log(twice(true)); // should be type error

Comments

[kuro3]

#reply-386381 の `型演算で導出` での実装方法については、分からなかったので、
もし分かる方がいれば、回答お待ちしています！！

Answer 2

そもそも論として、

引数の型が number または string でない場合，エラーオブジェクトを返すこと

これが、他の型の値を引数へ渡してコンパイルを通ることを意味していると解釈するなら、引数の型はunknownあるいは無制約のTとして受け取るしかないのではないかと考えます。

そして、「stringあるいはnumberならその型」「それ以外ならnever」となる返り値の型を適切の割り振るためには、

• 関数の型宣言のオーバーロードを行う
• 型演算で導出する

のどちらかのプロセスが必要となります。

Comments

[maisumakun]

型制約の2番目は、返り値をTにすればいいだけかと思います。

[kuro3]

>
関数の型宣言のオーバーロードを行う
型演算で導出する

を使用して，どのようなプログラムとすればよろしいでしょうか？

コメントを参考にして考えたプログラムは，以下の形です．ここからどのようにして，オーバーロードや型演算をすればいいのでしょうか？

```typescript
type Twiceable = number | string;

function twice(x: string): string;
function twice(x: number): number;
function twice(x: never): never;

function twice<T extends Twiceable>(x: T): T {
switch (typeof x) {
case 'number':
return 'hello' + 'hello';
case 'string':
return 2 * 2;
default:
return never;
}
}

console.log(twice(2));
console.log(twice('hello'));
console.log(twice(true));
```

[maisumakun]

> 関数の型宣言のオーバーロードを行う
型演算で導出する

正しくない引数を型エラーにしていいのなら不要ですね。すでにコメントしたように、返り値の型をTにするだけで問題ありません。

…ともいかなかったですね。

[maisumakun]

（通常はanyやasを使って、「外部から見た型の整合性だけ保つ」ように妥協して、「関数内で型を間違えた場合のコンパイルエラー」までこだわらずに実装します）