MENU
  1. ホーム
  2. Rust
  3. Rustで構造体と列挙型を効率化！マクロ活用ガイド

Rustで構造体と列挙型を効率化！マクロ活用ガイド

Rust

Rustプログラミングにおいて、構造体や列挙型の定義はコードの設計や実装の基盤となる重要な部分です。しかし、これらの定義が複雑化するにつれて、コード量が増加し、保守性や可読性に影響を与えることがあります。Rustでは、マクロという強力な機能を活用することで、これらの定義を簡略化し、効率的かつエレガントに管理できます。本記事では、Rustのマクロを使って構造体や列挙型の定義を効率化する方法について、具体的な例を交えながら詳しく解説します。マクロの基本から応用例までを学ぶことで、より生産性の高いRustプログラミングが実現できるでしょう。

目次
  1. Rustのマクロの基本概要
    1. 宣言型マクロ（Declarative Macros）
    2. プロシージャルマクロ（Procedural Macros）
    3. マクロを使うメリット
  2. 構造体と列挙型の定義における課題
    1. 繰り返し作業の増加
    2. エラーの発生リスク
    3. 可読性とメンテナンス性の低下
    4. コードの一貫性が保ちにくい
    5. 属性とメソッドの追加が煩雑
  3. Rustマクロによる解決の概要
    1. 構造体と列挙型の自動生成
    2. 属性付与の効率化
    3. カスタムマクロによる柔軟性
    4. 保守性と再利用性の向上
  4. 実践例：簡単な構造体の定義
    1. マクロを使わない場合の構造体定義
    2. マクロを用いた簡略化
    3. さらに属性を追加
    4. メリット
  5. 実践例：列挙型の自動定義
    1. マクロを使わない場合の列挙型定義
    2. マクロを用いた列挙型の定義
    3. 属性を含む列挙型の自動生成
    4. 応用例：列挙型に値を関連付ける
    5. メリット
  6. 応用：deriveマクロとカスタムマクロ
    1. deriveマクロの基本
    2. カスタムderiveマクロ
    3. 属性マクロの活用
    4. カスタム関数型マクロ
    5. メリット
  7. マクロ利用時の注意点
    1. デバッグの困難さ
    2. コードの複雑化
    3. 型チェックの遅延
    4. 名前衝突のリスク
    5. コンパイル時間の増加
    6. セキュリティと保守性の懸念
    7. まとめ
  8. 実践課題：自分専用のマクロを作成してみよう
    1. 課題1: 構造体を生成するマクロを作成
    2. 課題2: 列挙型に値を関連付けるマクロを作成
    3. 課題3: `derive`属性を含む構造体生成マクロ
    4. 課題4: 構造体のメソッドを生成するマクロ
    5. 課題に取り組むメリット
  9. まとめ

Rustのマクロの基本概要


Rustにおけるマクロとは、コードの生成を自動化するための仕組みです。通常の関数が「引数を受け取り、値を返す」のに対し、マクロは「入力されたコードを解析し、新しいコードを生成する」点が特徴です。Rustでは以下の2種類のマクロが存在します。

宣言型マクロ（Declarative Macros）


宣言型マクロは、パターンマッチングを用いて入力コードを解析し、それに応じた出力を生成します。macro_rules!を使用して定義され、比較的シンプルなコード生成に適しています。

macro_rules! my_macro {
    ($name:ident) => {
        struct $name {
            value: i32,
        }
    };
}
my_macro!(Example);

プロシージャルマクロ（Procedural Macros）


プロシージャルマクロは、より複雑なコード生成を可能にする機能です。主に3種類存在し、以下のように使われます。

  • Custom Derive: 既存のderive属性を拡張。
  • Attribute Macros: 特定の属性を追加してコードを修正。
  • Function-like Macros: 関数のような形式でコード生成。

プロシージャルマクロは、より高度な抽象化や柔軟な操作が求められる場面で活躍します。

マクロを使うメリット

  • コード量の削減: 繰り返し書く必要のあるコードを自動生成できます。
  • エラー防止: 一貫性のあるコード生成により、ヒューマンエラーを減らします。
  • 柔軟性の向上: 複雑なテンプレートを作成し、再利用可能な構造を簡単に作れます。

Rustのマクロはシンプルな定義から高度なプロシージャルマクロまで幅広く使われ、開発効率とコード品質の向上に大きく寄与します。

構造体と列挙型の定義における課題

Rustで構造体や列挙型を手動で定義する際、以下のような課題が発生することがあります。

繰り返し作業の増加


構造体や列挙型の定義は、プロジェクトが大規模化するにつれて似たようなコードを何度も書く必要が生じます。例えば、同じようなフィールドを持つ構造体や同じパターンの列挙型を複数定義する場合、重複したコードが大量に増えてしまいます。

struct User {
    id: u32,
    name: String,
}

struct Admin {
    id: u32,
    name: String,
    permissions: Vec<String>,
}

エラーの発生リスク


手動での定義では、タイポや不整合が原因でエラーが発生するリスクがあります。特に、プロジェクトが大規模になると、定義の一部を変更した際に、他の関連部分を更新し忘れることがよくあります。

可読性とメンテナンス性の低下


構造体や列挙型が増えると、コードの可読性が低下します。変更が必要な場合、どこを修正すればよいのか分かりにくくなり、メンテナンスが煩雑になります。

コードの一貫性が保ちにくい


手動で定義を行うと、チーム内やプロジェクト内でコードのスタイルや一貫性を保つのが難しくなります。同じようなデータ型を持つ構造体であっても、開発者ごとに微妙に異なる定義がされることがあります。

属性とメソッドの追加が煩雑


構造体や列挙型に属性（deriveマクロなど）やメソッドを追加する際、すべての定義に個別に適用する必要があり、効率が悪くなります。

これらの課題を解決するために、Rustのマクロを活用すれば、コードの重複を減らし、保守性や効率性を大幅に向上させることが可能です。次章では、マクロによるこれらの問題解決方法について詳しく解説します。

Rustマクロによる解決の概要

Rustのマクロを活用することで、構造体や列挙型の定義における課題を効率的に解決できます。マクロはコード生成を自動化し、一貫性と可読性を高める強力なツールです。この章では、マクロを使用して構造体や列挙型を効率化する仕組みを説明します。

構造体と列挙型の自動生成


Rustの宣言型マクロやプロシージャルマクロを利用することで、繰り返しが多い構造体や列挙型の定義を自動化できます。例えば、macro_rules!を使用すれば、テンプレートとして機能するマクロを作成し、柔軟にデータ構造を定義できます。

macro_rules! create_struct {
    ($name:ident, $field1:ident: $type1:ty, $field2:ident: $type2:ty) => {
        struct $name {
            $field1: $type1,
            $field2: $type2,
        }
    };
}

create_struct!(User, id: u32, name: String);

属性付与の効率化


マクロを使用することで、derive属性などの定型的なコードをまとめて付与できます。これにより、一貫性を保ちながらコードを簡略化できます。

macro_rules! create_struct_with_derive {
    ($name:ident, $($field_name:ident: $field_type:ty),*) => {
        #[derive(Debug, Clone)]
        struct $name {
            $( $field_name: $field_type, )*
        }
    };
}

create_struct_with_derive!(User, id: u32, name: String);

カスタムマクロによる柔軟性


プロシージャルマクロを用いることで、特定のロジックを埋め込んだ構造体や列挙型を動的に生成できます。これにより、複雑なデータ構造も簡単に管理できます。

例: 列挙型の自動生成

use proc_macro::TokenStream;

#[proc_macro]
pub fn generate_enum(input: TokenStream) -> TokenStream {
    let variants = input.to_string();
    let result = format!(
        "enum AutoEnum {{ {} }}",
        variants.replace(",", ", ")
    );
    result.parse().unwrap()
}

// マクロの利用例
generate_enum!(Variant1, Variant2, Variant3);

保守性と再利用性の向上


マクロを使うことで、コードを再利用可能な部品に分解できます。これにより、チーム開発でのコードの一貫性が向上し、新しい要件に柔軟に対応できるようになります。

Rustマクロは、効率性、保守性、可読性の向上に大いに貢献します。次章では、これを実際に利用した構造体の定義例について具体的に見ていきます。

実践例：簡単な構造体の定義

Rustのマクロを使って、構造体の定義を簡略化する実践例を紹介します。この方法により、繰り返しが多いコードを削減し、コードの効率化を図ることができます。

マクロを使わない場合の構造体定義


通常、Rustで構造体を定義するには、以下のようにフィールドを一つひとつ明示的に記述する必要があります。

struct User {
    id: u32,
    name: String,
    email: String,
}

この方法では、似たような構造体を複数定義する場合、手作業での記述が煩雑になり、ミスの原因になります。

マクロを用いた簡略化


macro_rules!を使うことで、テンプレート形式で構造体を定義できるようになります。

macro_rules! define_struct {
    ($name:ident, $($field_name:ident: $field_type:ty),*) => {
        struct $name {
            $( $field_name: $field_type, )*
        }
    };
}

// マクロの利用例
define_struct!(User, id: u32, name: String, email: String);

このマクロを使用すると、define_struct!を呼び出すだけで構造体を生成できます。フィールド名と型をリスト形式で渡せば、自動的に構造体が定義されます。

さらに属性を追加


#[derive]属性などを含む構造体を定義する場合も、マクロで効率的に記述できます。

macro_rules! define_struct_with_derive {
    ($name:ident, $($field_name:ident: $field_type:ty),*) => {
        #[derive(Debug, Clone)]
        struct $name {
            $( $field_name: $field_type, )*
        }
    };
}

// マクロの利用例
define_struct_with_derive!(User, id: u32, name: String, email: String);

上記の例では、生成される構造体にDebugとCloneの実装が自動的に追加されます。

メリット

  1. コード量の削減: 短いマクロ呼び出しで複数の構造体を一貫して生成可能。
  2. エラーの軽減: フィールドの一貫性を保ちやすく、ヒューマンエラーを防止。
  3. 再利用性の向上: プロジェクト全体で汎用的なマクロを共有可能。

このアプローチにより、簡潔でエラーの少ない構造体定義が可能になります。次章では、列挙型の定義をマクロで効率化する方法を見ていきます。

実践例：列挙型の自動定義

Rustの列挙型は、状態や選択肢を明確に表現するために便利ですが、定義が多くなるとコードが冗長になりがちです。ここでは、マクロを使って列挙型の定義を簡略化する方法を具体例とともに解説します。

マクロを使わない場合の列挙型定義


手動で列挙型を定義する場合、以下のようにすべてのバリアントを個別に記述する必要があります。

enum UserRole {
    Admin,
    User,
    Guest,
}

シンプルな場合はこれで問題ありませんが、バリアントが増えると、繰り返しの多い記述になり、ミスの温床となります。

マクロを用いた列挙型の定義


macro_rules!を使えば、バリアントをリスト形式で指定するだけで列挙型を簡単に定義できます。

macro_rules! define_enum {
    ($name:ident, $($variant:ident),*) => {
        enum $name {
            $( $variant, )*
        }
    };
}

// マクロの利用例
define_enum!(UserRole, Admin, User, Guest);

このマクロを使用すると、define_enum!を呼び出すだけで、指定されたバリアントを持つ列挙型が自動生成されます。

属性を含む列挙型の自動生成


必要に応じて、列挙型に#[derive]属性やカスタム属性を追加することも可能です。

macro_rules! define_enum_with_derive {
    ($name:ident, $($variant:ident),*) => {
        #[derive(Debug, Clone, PartialEq)]
        enum $name {
            $( $variant, )*
        }
    };
}

// マクロの利用例
define_enum_with_derive!(UserRole, Admin, User, Guest);

この例では、生成される列挙型にDebug、Clone、PartialEqの実装が自動的に追加されます。

応用例：列挙型に値を関連付ける


バリアントに値を関連付ける列挙型も、マクロを利用して自動生成できます。

macro_rules! define_enum_with_values {
    ($name:ident, $($variant:ident = $value:expr),*) => {
        enum $name {
            $( $variant = $value, )*
        }
    };
}

// マクロの利用例
define_enum_with_values!(HttpStatus, Ok = 200, NotFound = 404, InternalServerError = 500);

この例では、各バリアントに整数値を関連付けた列挙型を生成できます。

メリット

  1. 可読性の向上: バリアントが増えてもコードが煩雑になりにくい。
  2. メンテナンスの容易さ: バリアントの追加や変更が簡単。
  3. 再利用可能: 複数の列挙型で共通のパターンを使用可能。

マクロを活用することで、列挙型の定義が簡略化され、コードの保守性が向上します。次章では、マクロの応用例としてderiveやカスタムマクロを利用した高度な活用方法を解説します。

応用：deriveマクロとカスタムマクロ

Rustのderiveマクロやカスタムマクロを活用すると、構造体や列挙型に対して追加の機能を簡単に実装できます。この章では、これらのマクロを組み合わせて効率的にコードを生成する方法を解説します。

deriveマクロの基本


Rustでは、#[derive]属性を使用して一般的なトレイトの実装を自動生成できます。これにより、標準的な操作を簡単に実装できます。

#[derive(Debug, Clone, PartialEq)]
struct User {
    id: u32,
    name: String,
}

この例では、Debug、Clone、PartialEqのトレイト実装が自動的に追加されます。これにより、構造体のデバッグ表示や比較、クローン操作が可能になります。

カスタムderiveマクロ


標準のderiveトレイトだけでなく、独自のderiveマクロを作成して、特定の機能を自動的に構造体や列挙型に追加することも可能です。

例: カスタムログマクロ


以下は、構造体に自動的にロギング機能を追加するカスタムderiveマクロの例です。

use proc_macro::TokenStream;

#[proc_macro_derive(WithLogger)]
pub fn with_logger_derive(input: TokenStream) -> TokenStream {
    let ast = syn::parse(input).unwrap();
    let name = &ast.ident;
    let gen = quote! {
        impl #name {
            pub fn log(&self) {
                println!("Logging instance of {}: {:?}", stringify!(#name), self);
            }
        }
    };
    gen.into()
}

このマクロを利用することで、以下のようなコードでロギング機能を簡単に追加できます。

#[derive(Debug, WithLogger)]
struct User {
    id: u32,
    name: String,
}

// 利用例
let user = User { id: 1, name: "Alice".to_string() };
user.log(); // "Logging instance of User: User { id: 1, name: "Alice" }"

属性マクロの活用


属性マクロを使用すれば、構造体や列挙型の定義を直接修正し、より高度なカスタマイズが可能です。

例: JSON変換マクロ


以下のようなマクロを作成することで、構造体を簡単にJSONに変換する機能を追加できます。

#[proc_macro_attribute]
pub fn json_serializable(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let ast = syn::parse(item).unwrap();
    let name = &ast.ident;
    let gen = quote! {
        #ast
        impl #name {
            pub fn to_json(&self) -> String {
                serde_json::to_string(self).unwrap()
            }
        }
    };
    gen.into()
}

// 利用例
#[json_serializable]
struct User {
    id: u32,
    name: String,
}

このマクロを利用すると、構造体を簡単にJSON形式に変換できます。

カスタム関数型マクロ


関数型マクロを使えば、特定のコードブロックを生成するための柔軟なツールを作成できます。たとえば、複数の列挙型を同時に生成するマクロを作成できます。

macro_rules! generate_enums {
    ($($name:ident => { $($variant:ident),* }),*) => {
        $(
            enum $name {
                $( $variant, )*
            }
        )*
    };
}

// マクロの利用例
generate_enums!(
    UserRole => { Admin, User, Guest },
    HttpStatus => { Ok, NotFound, InternalServerError }
);

メリット

  1. コードの簡略化: 煩雑なトレイト実装や共通操作を自動化。
  2. 柔軟性の向上: カスタムマクロでプロジェクト固有の機能を効率的に作成可能。
  3. 生産性の向上: よく使用する機能をマクロ化することで、開発速度が向上。

deriveマクロやカスタムマクロを組み合わせることで、Rustのコードがさらに効率化され、生産性が飛躍的に向上します。次章では、マクロを利用する際の注意点を解説します。

マクロ利用時の注意点

Rustのマクロは強力な機能を提供しますが、その利用にはいくつかの注意点があります。適切に使用しないと、保守性や可読性に悪影響を及ぼすことがあります。この章では、マクロ使用時の主な注意点を解説します。

デバッグの困難さ


マクロによって生成されたコードは、直接的に見えないため、デバッグが難しくなることがあります。特にエラーが発生した場合、エラーメッセージが生成後のコードに基づいているため、問題の箇所を特定しづらいことがあります。

macro_rules! faulty_macro {
    ($name:ident) => {
        struct $name {
            invalid_syntax:
        }
    };
}
faulty_macro!(Example); // エラー内容が曖昧で理解しにくい

対策:

  • Rustのcargo expandツールを使用して、マクロ展開後のコードを確認する。
  • マクロを細かく分割して可読性を高める。

コードの複雑化


マクロを多用すると、コードの意図が分かりにくくなり、結果として可読性が低下することがあります。特にプロジェクトが大規模になると、どのマクロがどのようなコードを生成するのか把握が困難になります。

対策:

  • マクロの使用を最小限に抑える。
  • ドキュメントコメント（///）でマクロの意図と使用方法を明確に記述する。

型チェックの遅延


マクロ展開後に型チェックが行われるため、誤ったコードを生成するマクロを作成してしまうと、コンパイル時に予期しないエラーが発生する可能性があります。

macro_rules! create_struct {
    ($name:ident, $field:ident) => {
        struct $name {
            $field: String, // 型が固定化されている
        }
    };
}
create_struct!(User, id: u32); // 型エラー

対策:

  • 入力の型を適切に検証する。
  • プロシージャルマクロを使用して型チェックを強化する。

名前衝突のリスク


マクロで生成されたコードが他のコードと名前衝突を起こす場合があります。これにより、予期せぬ挙動が発生することがあります。

対策:

  • 名前空間（モジュール）を活用して名前の衝突を防ぐ。
  • マクロで生成される名前にプレフィックスを追加する。
macro_rules! create_struct_with_prefix {
    ($prefix:ident, $name:ident) => {
        struct $prefix$name {
            value: u32,
        }
    };
}
create_struct_with_prefix!(App, User); // AppUser構造体が生成

コンパイル時間の増加


マクロの使用が多いと、コードの複雑さに応じてコンパイル時間が増加することがあります。特にプロシージャルマクロはコンパイル負荷が高くなる傾向があります。

対策:

  • 必要以上に複雑なマクロを作らない。
  • 再利用可能な汎用コードをマクロではなくライブラリとして実装する。

セキュリティと保守性の懸念


動的にコードを生成する性質上、マクロはバグや脆弱性を引き起こす可能性があります。また、プロジェクトチーム内でマクロの設計意図が共有されていない場合、保守性が著しく低下します。

対策:

  • マクロの動作を十分にテストする。
  • チーム内でマクロの使用ルールを明確化する。

まとめ


Rustのマクロは、コード生成や自動化の強力な手段ですが、適切に使用しなければデメリットが目立つ場合があります。デバッグツールやコメントを活用し、使用範囲を限定することで、マクロの利便性を最大限に活用しましょう。次章では、学習を深めるための実践課題を紹介します。

実践課題：自分専用のマクロを作成してみよう

これまで学んだ内容を活かして、Rustのマクロを用いたコード生成を実際に試してみましょう。以下では、課題として自分専用のマクロを作成し、効率的なコードの実装に挑戦していただきます。

課題1: 構造体を生成するマクロを作成


内容: 複数の構造体を一度に生成できるマクロを作成してください。このマクロでは、構造体の名前とフィールドをリスト形式で渡すと、すべての構造体が自動生成されるようにします。

仕様例:

create_structs! {
    User {
        id: u32,
        name: String,
        email: String
    },
    Admin {
        id: u32,
        name: String,
        permissions: Vec<String>
    }
}

期待される生成コード:

struct User {
    id: u32,
    name: String,
    email: String,
}

struct Admin {
    id: u32,
    name: String,
    permissions: Vec<String>,
}

ヒント: macro_rules!を利用し、複数の入力を柔軟に受け取れるように設計してください。

課題2: 列挙型に値を関連付けるマクロを作成


内容: バリアントと関連付ける値をリスト形式で指定できる列挙型を生成するマクロを作成してください。各バリアントには整数値が自動的に関連付けられるようにします。

仕様例:

define_enum_with_values!(HttpStatus {
    Ok = 200,
    NotFound = 404,
    InternalServerError = 500
});

期待される生成コード:

enum HttpStatus {
    Ok = 200,
    NotFound = 404,
    InternalServerError = 500,
}

ヒント: バリアント名と値を柔軟に受け取るためのパターンマッチを工夫してください。

課題3: `derive`属性を含む構造体生成マクロ


内容: 自動的に#[derive(Debug, Clone)]属性を付与する構造体生成マクロを作成してください。このマクロを使うことで、すべての構造体がデバッグ表示可能でクローン操作ができるようになります。

仕様例:

create_struct_with_debug! {
    Product {
        id: u32,
        name: String,
        price: f64
    },
    Order {
        id: u32,
        product_id: u32,
        quantity: u32
    }
}

期待される生成コード:

#[derive(Debug, Clone)]
struct Product {
    id: u32,
    name: String,
    price: f64,
}

#[derive(Debug, Clone)]
struct Order {
    id: u32,
    product_id: u32,
    quantity: u32,
}

ヒント: 属性を自動で付与するために、マクロの内部で#[derive]を活用してください。

課題4: 構造体のメソッドを生成するマクロ


内容: 構造体の定義だけでなく、指定されたフィールドに対応するゲッターを自動生成するマクロを作成してください。

仕様例:

create_struct_with_getters! {
    User {
        id: u32,
        name: String
    }
}

期待される生成コード:

struct User {
    id: u32,
    name: String,
}

impl User {
    pub fn id(&self) -> &u32 {
        &self.id
    }

    pub fn name(&self) -> &String {
        &self.name
    }
}

ヒント: implブロック内にゲッターを自動生成する仕組みを設計してください。

課題に取り組むメリット


これらの課題を通じて、以下のスキルを習得できます:

  • マクロ設計の基本と応用。
  • Rustにおけるコードの効率的な生成方法。
  • 可読性と保守性を考慮したマクロの実装。

挑戦する中で得られた知識は、実際のプロジェクトでのマクロ活用に役立つでしょう。次章では、マクロの利用による効果を総括し、さらに学びを深めるための参考情報を提示します。

まとめ

本記事では、Rustのマクロを使った構造体や列挙型の定義の効率化について解説しました。Rustのマクロは、コード生成の自動化や繰り返し作業の削減に非常に有効であり、特にmacro_rules!やプロシージャルマクロを活用することで、柔軟かつ効率的なプログラミングが可能になります。

具体的には、マクロを使った構造体と列挙型の自動定義、deriveマクロの応用、そして注意点を解説しました。さらに、実践課題を通じて、自分専用のマクロを作成することで、実際の開発に役立つスキルを身につけられるように設計しました。

マクロを適切に利用することで、コードの可読性や保守性を高め、プロジェクト全体の生産性を向上させることができます。ぜひ実際のプロジェクトに活用し、Rustのプログラミングをさらに効率化してください。

Rust
プログラミング マクロ Rust

コメント

コメントする

目次
  1. Rustのマクロの基本概要
    1. 宣言型マクロ（Declarative Macros）
    2. プロシージャルマクロ（Procedural Macros）
    3. マクロを使うメリット
  2. 構造体と列挙型の定義における課題
    1. 繰り返し作業の増加
    2. エラーの発生リスク
    3. 可読性とメンテナンス性の低下
    4. コードの一貫性が保ちにくい
    5. 属性とメソッドの追加が煩雑
  3. Rustマクロによる解決の概要
    1. 構造体と列挙型の自動生成
    2. 属性付与の効率化
    3. カスタムマクロによる柔軟性
    4. 保守性と再利用性の向上
  4. 実践例：簡単な構造体の定義
    1. マクロを使わない場合の構造体定義
    2. マクロを用いた簡略化
    3. さらに属性を追加
    4. メリット
  5. 実践例：列挙型の自動定義
    1. マクロを使わない場合の列挙型定義
    2. マクロを用いた列挙型の定義
    3. 属性を含む列挙型の自動生成
    4. 応用例：列挙型に値を関連付ける
    5. メリット
  6. 応用：deriveマクロとカスタムマクロ
    1. deriveマクロの基本
    2. カスタムderiveマクロ
    3. 属性マクロの活用
    4. カスタム関数型マクロ
    5. メリット
  7. マクロ利用時の注意点
    1. デバッグの困難さ
    2. コードの複雑化
    3. 型チェックの遅延
    4. 名前衝突のリスク
    5. コンパイル時間の増加
    6. セキュリティと保守性の懸念
    7. まとめ
  8. 実践課題：自分専用のマクロを作成してみよう
    1. 課題1: 構造体を生成するマクロを作成
    2. 課題2: 列挙型に値を関連付けるマクロを作成
    3. 課題3: `derive`属性を含む構造体生成マクロ
    4. 課題4: 構造体のメソッドを生成するマクロ
    5. 課題に取り組むメリット
  9. まとめ