TypeScriptの型推論でnever型が生成される理由とその対策

TypeScriptは、JavaScriptに型安全性を付加する言語として広く使用されています。その特徴の一つが「型推論」で、コード内の変数や関数の型を自動的に決定する機能です。しかし、型推論の過程で予期しない型が推論されることがあり、その代表例がnever型です。never型は、通常のプログラムのフローでは到達しない場所で生成される特異な型です。本記事では、never型が自動的に生成される理由や、その対策方法について詳しく解説します。

型推論とは何か

型推論は、TypeScriptの特徴的な機能の一つで、開発者が明示的に型を指定しなくても、コンパイラがコードの文脈から適切な型を自動的に推測する仕組みです。これにより、開発者は型の明示を省略でき、効率的なコーディングが可能になります。例えば、変数に数値や文字列を代入すると、TypeScriptは自動的にその変数の型をnumberやstringとして推論します。

型推論は便利ですが、コードが複雑になると予期しない型が推論される場合があります。特に条件分岐や関数の戻り値で、開発者が意図しないnever型が推論されることがあります。このようなケースでは、型推論を理解し、適切に対処することが重要です。

never型とは

never型は、TypeScriptの中でも非常に特殊な型です。この型は、通常のプログラムの実行フローが到達しない場所や、処理が完了しない関数で自動的に推論されます。具体的には、以下のような状況でnever型が登場します。

• 常に例外を投げる関数：戻り値を返さず、例外をスローするだけの関数。
• 無限ループを含む関数：処理が終了しないため、決して戻り値が発生しない関数。
• 型が矛盾するケース：条件分岐の結果が論理的に成立しないとコンパイラが判断した場合。

never型の特徴は、「何も返さない、何も含まない」という点です。つまり、正常な処理フローからは決して到達できない型であり、エラーハンドリングや予期しない分岐処理の場面でしばしば現れます。この特殊な型が意図せず推論されると、思わぬバグを引き起こす可能性があるため、対策が必要です。

never型が生成されるシチュエーション

never型は、TypeScriptの型推論の過程で特定の条件下で自動的に生成されます。主に以下のようなシチュエーションでnever型が推論されます。

1. 例外をスローする関数

例外をスローする関数は、実際には何も戻り値を返しません。そのため、TypeScriptはその戻り値の型としてnever型を推論します。例えば、以下のような関数です。

function throwError(message: string): never {
    throw new Error(message);
}

この関数は常に例外を投げ、正常なフローには戻らないため、戻り値の型としてneverが適用されます。

2. 型が矛盾する条件分岐

条件分岐内で、型が全く一致しない場合、TypeScriptは論理的にその条件が成立しないと判断し、never型を推論します。例えば、次のコードのような場合です。

function processValue(value: string | number) {
    if (typeof value === "string") {
        // string型として処理
    } else if (typeof value === "number") {
        // number型として処理
    } else {
        // このブロックには到達しないと推論され、never型になる
        const neverValue: never = value;
    }
}

valueがstringまたはnumberしか取らない場合、elseのブロックには到達しないことが明らかです。この場合、TypeScriptはnever型として推論します。

3. 無限ループを持つ関数

無限ループを持つ関数も、正常に処理が終了しないため、戻り値がnever型となります。例えば、以下の関数です。

function infiniteLoop(): never {
    while (true) {
        // 無限ループ
    }
}

このような場合も、処理が永遠に続くため戻り値は存在せず、never型が自動的に割り当てられます。

これらのシチュエーションにおいて、never型は有用ですが、意図せず発生する場合には問題が生じることがあります。

never型が引き起こす問題

never型は、その特殊な性質ゆえに、意図せず生成された場合にさまざまな問題を引き起こす可能性があります。開発者がこの型の存在に気づかないと、エラーの発見や修正が難しくなることがあるため、事前にそのリスクを理解しておくことが重要です。以下は、never型が引き起こす代表的な問題です。

1. エラーハンドリングの失敗

never型が誤って推論されると、適切にエラーハンドリングが行われない場合があります。たとえば、関数が例外を投げた後に処理が続行されることを期待していたとしても、never型が関数の戻り値として推論されると、その後のコードに実行されない部分が発生します。このため、予期しない動作や処理の停止が発生する可能性があります。

2. 型推論のミスによるコンパイルエラー

型推論でnever型が使われることで、意図していないコンパイルエラーが発生する場合があります。例えば、条件分岐で全てのケースをカバーしたはずなのに、TypeScriptが「到達しないコード」と判断し、never型を推論してエラーを発生させることがあります。これにより、実際には実行されるべきコードが、TypeScriptの型システムによって不適切とみなされる事態が発生します。

3. 可読性と保守性の低下

コードの可読性と保守性にも影響を与えます。特に、予期しない場所でnever型が推論されると、他の開発者がそのコードを理解するのが困難になります。never型が存在する箇所がエラーの原因となっていても、その場所を特定するのに時間がかかり、結果的にプロジェクト全体の進行が遅れることがあります。

4. 動的な型チェックの複雑化

動的な型チェックを行う場面では、never型が発生することで、その型チェックが複雑になり、正しい条件を見逃してしまう可能性があります。特に、条件分岐の最後のelseブロックでnever型が使用されるケースでは、開発者が意図していない条件を見逃すリスクがあります。

このように、never型が予期しない形で現れると、コードのエラーハンドリングや型チェックに影響を与え、開発者の意図しない動作やエラーを引き起こす可能性があります。そのため、適切な対策を講じて、この型が引き起こす問題を未然に防ぐことが重要です。

条件分岐とnever型

never型が最も頻繁に登場するシチュエーションの一つが、条件分岐やswitch文の中です。特に、条件が論理的にすべてのケースを網羅しているとコンパイラが判断した場合、残りの選択肢に対してnever型が自動的に推論されることがあります。これが予期しない問題を引き起こす原因になることがあります。ここでは、具体的な条件分岐でのnever型生成について見ていきます。

1. if-else文とnever型

if-else文の中で、全ての条件が網羅されていると判断された場合、最後のelseブロックでnever型が推論されることがあります。たとえば、次のようなコードを考えます。

function checkValue(value: string | number) {
    if (typeof value === "string") {
        console.log("The value is a string");
    } else if (typeof value === "number") {
        console.log("The value is a number");
    } else {
        // このブロックには到達しないと推論され、never型が推論される
        const neverValue: never = value;
        console.log(neverValue);
    }
}

このコードでは、valueがstringまたはnumberのいずれかしか持たないため、TypeScriptはelseブロックには決して到達しないと判断し、この部分でnever型を推論します。これは理論的には正しい動作ですが、開発者が意図していない場合に問題が発生することがあります。

2. switch文でのnever型

switch文においても同様に、全てのケースを処理した場合、残りのdefaultブロックでnever型が推論されます。例えば、以下のようなコードが典型的な例です。

type Animal = "cat" | "dog" | "bird";

function getAnimalSound(animal: Animal) {
    switch (animal) {
        case "cat":
            return "Meow";
        case "dog":
            return "Woof";
        case "bird":
            return "Chirp";
        default:
            const neverAnimal: never = animal;
            return neverAnimal;  // このコードには到達しない
    }
}

このswitch文では、Animal型に属する全てのケースが処理されています。そのため、defaultブロックには到達しないと判断され、never型が推論されます。これも理論上は正しいですが、Animal型に新しい値が追加された場合（例: "fish"など）、defaultブロックがカバーしていないために、実行時エラーが発生する可能性があります。

3. ユニオン型の分岐でのnever型

ユニオン型（|）を使った分岐でも、型がすべてカバーされているとnever型が発生します。例えば、次のような場合です。

function processInput(input: string | number | boolean) {
    if (typeof input === "string") {
        console.log("Input is a string");
    } else if (typeof input === "number") {
        console.log("Input is a number");
    } else if (typeof input === "boolean") {
        console.log("Input is a boolean");
    } else {
        // 全てのケースがカバーされているため、このブロックはnever型になる
        const neverInput: never = input;
        console.log(neverInput);
    }
}

この場合も、すべての型がif-elseブロックで処理されているため、elseに到達することはなく、never型が推論されます。

このように、条件分岐の中で意図せずnever型が発生することがあります。これが予期せぬ動作やエラーにつながることがあるため、分岐構造には慎重な設計が必要です。

関数の戻り値でのnever型の生成

関数の戻り値においても、never型が意図せず生成されることがあります。特に、関数が正常な実行フローを持たず、常に例外をスローしたり、無限ループを含む場合、TypeScriptはその関数の戻り値の型としてnever型を推論します。これが適切な場面もありますが、意図しない場面で発生すると、バグの原因となり得ます。ここでは、関数の戻り値としてnever型が生成される典型的なケースを見ていきます。

1. 例外をスローする関数

常に例外をスローする関数は、戻り値を返さないため、never型が推論されます。このような関数はエラーハンドリングに頻繁に使用されます。例えば、次のような関数です。

function throwError(message: string): never {
    throw new Error(message);
}

この関数は、例外をスローするだけで、正常に戻り値を返すことがありません。そのため、TypeScriptはnever型を戻り値として推論します。これはエラーハンドリングでは正しい動作ですが、意図せずこのような関数が使われていると、誤った場所でエラーが発生する原因になります。

2. 無限ループを含む関数

無限ループを持つ関数も、処理が決して終了しないため、戻り値を返すことができません。このため、関数の戻り値の型はneverとなります。例えば、次のようなコードです。

function infiniteLoop(): never {
    while (true) {
        // 永遠にループし続ける
    }
}

この関数は処理が決して終わらないため、never型が推論されます。この場合は正しい動作ですが、意図せずこのようなコードが存在すると、アプリケーションの動作が停止する原因になる可能性があります。

3. 戻り値が型矛盾を起こす場合

条件分岐や関数内のロジックによっては、すべての戻り値の型がカバーされている場合に、コンパイラがnever型を推論することがあります。例えば、次のような関数です。

function exhaustiveCheck(value: "a" | "b"): string {
    switch (value) {
        case "a":
            return "Value is A";
        case "b":
            return "Value is B";
        default:
            const neverValue: never = value;  // 型矛盾があるため、never型が推論される
            return neverValue;
    }
}

この場合、valueが"a"または"b"でしかあり得ないため、defaultブロックは実際には存在しないはずです。しかし、もしdefaultが書かれている場合、never型が推論され、矛盾が発生します。このような型矛盾は、開発者が意図していない場合に問題を引き起こす可能性があります。

関数の戻り値におけるnever型の発生は、意図的であれば問題はありませんが、予期せぬ形で発生するとコードの保守性やデバッグが難しくなる原因となります。特に、エラーハンドリングや無限ループに関する部分では、never型の発生に注意が必要です。

never型が自動生成されないようにする対策

never型が意図せず自動生成されると、予期しないエラーやコードの不具合につながる可能性があります。そのため、特定の状況でnever型が生成されるのを防ぐ対策を講じることが重要です。ここでは、never型の自動生成を防ぐための具体的な対策をいくつか紹介します。

1. 型の網羅性チェックを慎重に行う

条件分岐やswitch文を使用する際は、可能な限りすべての型をカバーするように意識することが重要です。never型は、型がすべてカバーされているときに発生することが多いため、条件分岐の範囲を明確にし、必要に応じて新しい型が追加されても対応できるようにします。

例えば、switch文におけるdefaultブロックを意図的に省略することで、将来的に型が追加された際のエラーを早期に検知することができます。

function getAnimalSound(animal: "cat" | "dog" | "bird"): string {
    switch (animal) {
        case "cat":
            return "Meow";
        case "dog":
            return "Woof";
        case "bird":
            return "Chirp";
        // defaultを記載しないことで、新しい型が追加された場合にエラーが発生する
    }
}

2. 冗長なdefaultブロックを避ける

switch文で冗長なdefaultブロックを記述すると、コンパイラがnever型を推論する原因になります。すべてのケースを明示的に列挙し、defaultブロックは可能な限り避けることで、意図せぬnever型の発生を抑制できます。

3. 型ガードを用いる

型ガードを使用することで、意図的に特定の型がどのように処理されるかを明示し、予期せぬnever型の生成を防ぐことができます。例えば、ユニオン型を扱う場合に型ガードを使って型チェックを厳密に行うと、エラーが発生しにくくなります。

function processValue(value: string | number | boolean): string {
    if (typeof value === "string") {
        return `String: ${value}`;
    } else if (typeof value === "number") {
        return `Number: ${value}`;
    } else if (typeof value === "boolean") {
        return `Boolean: ${value}`;
    }
    // 他のケースがカバーされているので、never型の生成を防ぐ
}

4. 明示的な型アサーションの活用

場合によっては、TypeScriptに対して明示的に型を指定することでnever型が推論されるのを防ぐことができます。特に、関数の戻り値が不明な場合や、複雑な条件分岐の中で型が適切に推論されない場合には、明示的な型アサーションを行うことでnever型の発生を防げます。

function handleUnknownInput(input: unknown): string {
    if (typeof input === "string") {
        return input;
    }
    throw new Error("Unsupported type");
    // 明示的に型を指定することで、never型を回避
}

5. 厳密なコンパイラオプションの設定

TypeScriptのコンパイラオプションを設定して、未定義の型や非網羅的な分岐を検出できるようにすることも効果的です。strictモードを有効にすることで、より厳密に型チェックが行われ、意図しないnever型の生成を抑止できます。

このような対策を講じることで、never型の自動生成を未然に防ぎ、予期しないエラーやコードの保守性低下を回避できます。特に、条件分岐の網羅性や型の明示を意識することで、より堅牢なTypeScriptコードを作成することが可能です。

型ガードの活用

never型の発生を防ぐために、型ガードを活用することは非常に効果的です。型ガードは、変数が特定の型に属していることを確認し、その型に基づいて異なる処理を行うための手法です。これにより、TypeScriptが型推論を正しく行えるようになり、意図しないnever型の生成を防ぐことができます。ここでは、型ガードを使用してnever型を回避する具体的な方法を解説します。

1. typeofを使った型ガード

typeof演算子を使って、変数の型を確認し、型に応じた処理を行うのは最も一般的な型ガードの方法です。例えば、次のように文字列か数値かを判定して、それぞれに対応する処理を実装することができます。

function handleInput(input: string | number): string {
    if (typeof input === "string") {
        return `String input: ${input}`;
    } else if (typeof input === "number") {
        return `Number input: ${input}`;
    } else {
        // never型の生成を防ぐため、型のチェックをしっかり行う
        const neverInput: never = input;
        return neverInput;  // 実際にはこの行に到達しない
    }
}

このように、typeofを使った型チェックにより、never型の生成を防ぐことができます。全ての型を網羅的にチェックすることで、余計なエラーやバグを防ぐことができます。

2. instanceofを使った型ガード

instanceof演算子は、オブジェクトのインスタンスかどうかを確認する際に有効です。特に、クラスやオブジェクトを使う場合、instanceofを活用することで特定の型を正確に識別できます。

class Dog {
    bark() {
        console.log("Woof!");
    }
}

class Cat {
    meow() {
        console.log("Meow!");
    }
}

function handleAnimal(animal: Dog | Cat) {
    if (animal instanceof Dog) {
        animal.bark();
    } else if (animal instanceof Cat) {
        animal.meow();
    } else {
        // 全てのケースをカバーしているため、never型の発生を防ぐ
        const neverAnimal: never = animal;
        return neverAnimal;
    }
}

この例では、instanceofを使用してオブジェクトの型を正確に判定しています。これにより、DogとCatの両方を適切に処理し、never型が発生しないようにしています。

3. カスタム型ガードの利用

TypeScriptでは、カスタム型ガードを作成して、より複雑な型チェックを行うことも可能です。カスタム型ガードは、関数が特定の型であることを判定する関数を作成することで実現されます。

interface Fish {
    swim: () => void;
}

interface Bird {
    fly: () => void;
}

function isFish(animal: Fish | Bird): animal is Fish {
    return (animal as Fish).swim !== undefined;
}

function handleAnimal(animal: Fish | Bird) {
    if (isFish(animal)) {
        animal.swim();
    } else {
        animal.fly();
    }
}

この例では、isFishというカスタム型ガードを使って、Fishであるかどうかを判定しています。これにより、animalがFishかBirdかを確実に区別し、TypeScriptの型推論が正しく働くようにしています。

4. never型を積極的に使用してエラーを検知する

実は、never型をあえて使用して、プログラムの網羅性を検証する方法もあります。never型は、到達不能なコードを示すため、条件分岐やswitch文で処理が漏れている場合に、エラーとして検出することができます。これにより、意図しない型の未処理を防ぐことができます。

type Animal = "dog" | "cat" | "bird";

function handleAnimal(animal: Animal): string {
    switch (animal) {
        case "dog":
            return "Woof!";
        case "cat":
            return "Meow!";
        case "bird":
            return "Chirp!";
        default:
            const neverAnimal: never = animal;
            return neverAnimal;  // エラーを早期に検出
    }
}

このように、never型を利用して、型漏れや未対応のケースをコンパイラが検知するように設計することで、より安全なコードを構築することができます。

型ガードは、TypeScriptの型推論の力を最大限に活用し、never型による問題を未然に防ぐための強力な手段です。正しく活用することで、より堅牢で保守性の高いコードを書くことができます。

外部ライブラリでの対策

TypeScriptプロジェクトでは、外部ライブラリを活用することでnever型の問題を回避し、型推論をよりスムーズに行えるようにすることが可能です。特に、型安全性を確保するためのライブラリやツールを導入することで、型に関するエラーを未然に防ぐことができます。ここでは、外部ライブラリを使用してnever型の問題を軽減する方法を紹介します。

1. io-tsを使った型検証

io-tsは、TypeScriptでランタイム型検証を行うための強力なライブラリです。静的な型定義だけでなく、実際にランタイムで型を検証する機能を提供するため、予期せぬnever型の生成やランタイムエラーを防ぐことができます。

以下は、io-tsを使用してAPIからのレスポンスを型検証する例です。

import * as t from 'io-ts';

const User = t.type({
    id: t.number,
    name: t.string,
});

type User = t.TypeOf<typeof User>;

function fetchUser(): unknown {
    // 実際のAPIから返ってくるデータ
    return { id: 1, name: "Alice" };
}

const result = User.decode(fetchUser());

if (result._tag === "Right") {
    console.log(result.right.name);  // 型安全にアクセス可能
} else {
    console.error("Invalid data structure");
}

この例では、io-tsを使ってAPIレスポンスの型を検証しています。もしレスポンスが期待される型と一致しない場合は、エラーを返し、never型が発生するような予期しないケースを回避することができます。

2. Zodによるスキーマベースの型検証

Zodは、スキーマベースで型を定義し、その型に基づいてランタイムでデータを検証するライブラリです。シンプルなAPIでありながら、複雑な型の検証や変換を行うことができ、never型の問題を防ぎつつ、型の整合性を保つのに役立ちます。

import { z } from 'zod';

const UserSchema = z.object({
    id: z.number(),
    name: z.string(),
});

type User = z.infer<typeof UserSchema>;

function fetchUser(): unknown {
    return { id: 1, name: "Alice" };
}

const user = UserSchema.safeParse(fetchUser());

if (user.success) {
    console.log(user.data.name);  // 型安全にアクセス
} else {
    console.error("Invalid data");
}

この例でも、Zodを使ってデータを安全に型検証することで、型のミスマッチを回避し、never型が不必要に推論されることを防ぐことができます。

3. ts-patternによるパターンマッチング

ts-patternは、TypeScriptにおいて安全で強力なパターンマッチングを提供するライブラリです。特に、ユニオン型や条件分岐が複雑になるケースにおいて、never型が発生しないようにするために非常に有効です。

例えば、次のような複雑なユニオン型の分岐において、never型の問題をts-patternで防ぐことができます。

import { match } from 'ts-pattern';

type Animal = { type: 'dog', bark: () => void } 
            | { type: 'cat', meow: () => void }
            | { type: 'bird', chirp: () => void };

function handleAnimal(animal: Animal) {
    match(animal)
        .with({ type: 'dog' }, (dog) => dog.bark())
        .with({ type: 'cat' }, (cat) => cat.meow())
        .with({ type: 'bird' }, (bird) => bird.chirp())
        .exhaustive();  // 全てのケースをカバーしていることを保証
}

ts-patternのexhaustiveメソッドを使うことで、すべてのケースをカバーしていることをコンパイル時に保証できます。これにより、ケース漏れがなくなり、never型の推論によるエラーを防ぐことができます。

4. type-festによるユーティリティ型の活用

type-festは、TypeScriptの型をより柔軟に扱うためのユーティリティ型が豊富に含まれたライブラリです。特に、ユニオン型の処理やオプション型の扱いにおいて便利な型が多く、never型を回避しやすくする機能が揃っています。

例えば、type-festのSimplify型を使って複雑な型を簡素化することで、型推論の精度を上げ、never型の発生を防ぐことができます。

import { Simplify } from 'type-fest';

type ComplexType = { a: number } & { b: string };

type SimpleType = Simplify<ComplexType>;

// SimpleTypeは{ a: number; b: string } となり、never型の混入を防ぐ

Simplify型のようなユーティリティを使うことで、型の複雑さを減らし、型システムが混乱してnever型が推論されるのを防ぐことができます。

まとめ

これらの外部ライブラリを活用することで、TypeScriptの型システムに関する問題を解消し、never型が発生しないようにするための効果的な手段を提供します。io-tsやZodでのランタイム型チェック、ts-patternでの安全なパターンマッチング、そしてtype-festでのユーティリティ型の利用を通じて、開発者はより堅牢で保守性の高いコードを作成することが可能です。

演習問題: never型の生成を防ぐ

ここでは、never型の生成を防ぐための実践的な演習問題を提供します。これにより、実際にTypeScriptのコードを書く際に、どのようにnever型が発生し、どのようにそれを防ぐかを体験できます。各問題には、予期しないnever型の発生を防ぐためのヒントが含まれています。

問題1: 条件分岐での型ガードの活用

以下のコードには、never型が発生する可能性があります。すべての型をカバーし、never型が発生しないようにコードを修正してください。

function handleInput(input: string | number | boolean) {
    if (typeof input === "string") {
        console.log(`String: ${input}`);
    } else if (typeof input === "number") {
        console.log(`Number: ${input}`);
    } else {
        const neverInput: never = input;  // never型が発生する可能性
        console.log(neverInput);
    }
}

ヒント: 型ガードを使ってboolean型のケースも網羅することで、never型の生成を防ぐことができます。

問題2: switch文での網羅的な分岐

次のコードでは、Animal型の全てのケースをカバーしていますが、defaultブロックでnever型が発生します。defaultブロックを使わずに、すべてのケースを正しく処理するようにコードを修正してください。

type Animal = "cat" | "dog" | "bird";

function getAnimalSound(animal: Animal): string {
    switch (animal) {
        case "cat":
            return "Meow";
        case "dog":
            return "Woof";
        case "bird":
            return "Chirp";
        default:
            const neverAnimal: never = animal;  // never型が推論される
            return neverAnimal;
    }
}

ヒント: defaultブロックを削除し、switch文で全てのAnimalの型をカバーすることで、コンパイラが未処理の型を検出できるようにします。

問題3: パターンマッチングでnever型を防ぐ

次のユニオン型を持つコードでは、never型が発生するケースがあります。ts-patternライブラリを使用して、全てのケースを網羅し、never型が発生しないようにコードを書き直してください。

type Fruit = { type: "apple" } | { type: "banana" } | { type: "orange" };

function getFruitColor(fruit: Fruit): string {
    switch (fruit.type) {
        case "apple":
            return "red";
        case "banana":
            return "yellow";
        // orangeがカバーされていない
        default:
            const neverFruit: never = fruit;
            return neverFruit;
    }
}

ヒント: ts-patternを使い、全てのFruit型を網羅するパターンマッチングを行うことで、型の漏れを防ぎます。

問題4: ランタイム型検証でnever型を防ぐ

次のコードでは、APIレスポンスを処理していますが、予期しないデータ型が渡された場合にnever型が発生する可能性があります。io-tsまたはZodを使って、ランタイム型検証を追加し、never型が発生しないようにコードを書き換えてください。

function processApiResponse(response: unknown) {
    if (typeof response === "object" && response !== null) {
        return "Valid response";
    } else {
        const neverResponse: never = response;  // never型が発生する可能性
        return neverResponse;
    }
}

ヒント: io-tsまたはZodを使って、APIレスポンスの型検証を行うことで、型の不整合を防ぎ、never型の発生を抑えます。

これらの演習問題を通じて、実際にnever型の発生を防ぐための方法を学び、TypeScriptの型システムをより深く理解することができます。

まとめ

本記事では、TypeScriptにおけるnever型の自動生成とその対策について詳しく解説しました。never型は、予期しない型エラーを引き起こす可能性がありますが、適切な型ガードや条件分岐の網羅性を確保することで防ぐことができます。また、外部ライブラリを活用して型検証を行うことで、さらに安全な開発が可能になります。これらの手法を取り入れることで、never型の発生を抑え、より堅牢なコードを書くことができるようになるでしょう。