Rust の組織管理

どのプログラミング言語でも、コードを組織化できなければ深く学ぶことは難しい。ほぼすべてのソフトウェア製品が1つのソースファイルからコンパイルされるわけではない。

このチュートリアルでこれまでのところすべてのプログラムは1つのファイルで書かれている。主にRust言語の構文と概念を学びやすくするためである。

プロジェクトにとって、コードの組織化は非常に重要である。

Rustには3つの重要な組織化の概念がある:クレート、パッケージ、モジュールである。

クレート(Crate)

「クレート」はバイナリプログラムファイルまたはライブラリファイルであり、「パッケージ」の中に存在する。

「クレート」はツリー構造であり、そのルートはコンパイラが実行を開始したときにコンパイルするソースファイルからコンパイルされたプログラムである。

注意:「バイナリプログラムファイル」は必ずしも「バイナリ実行可能ファイル」ではない。ターゲットマシンの機械語を含むファイルであることだけは確かであり、ファイル形式はコンパイル環境によって異なる。

パッケージ(Package)

Cargo で new コマンドを実行して Rust プロジェクトを作成すると、プロジェクトディレクトリに Cargo.toml ファイルが作成される。プロジェクトの実体はパッケージであり、パッケージは Cargo.toml ファイルによって管理されなければならない。このファイルにはパッケージの基本情報と依存関係が記述される。

1つのパッケージは最大で1つのライブラリ「クレート」を含むことができ、任意の数のバイナリ「クレート」を含むことができる。ただし、少なくとも1つの「クレート」を含まなければならない(ライブラリかバイナリ「クレート」のどちらでもよい)。

cargo new コマンドでパッケージを作成すると、src ディレクトリに main.rs ソースファイルが生成される。Cargo はこのファイルをバイナリクレートのルートとみなし、コンパイル後のバイナリクレートはパッケージ名と同じになる。

モジュール(Module)

ソフトウェアプロジェクトでは、使用するプログラミング言語の組織化の規約に従って整理するのが一般的である。モジュールを組織化する主な構造はツリーである。Java で機能モジュールを組織化する主要な単位はクラスであり、JavaScript でモジュールを組織化する主な方法は function である。

これらの先進的な言語の組織単位は、ファイルシステムのディレクトリ構造のように階層的に包含することができる。Rust における組織単位はモジュール(Module)である。

mod nation {
    mod government {
        fn govern() {}
    }
    mod congress {
        fn legislate() {}
    }
    mod court {
        fn judicial() {}
    }
}

これは法治国家を記述したプログラムである:国家(nation)は政府(government)、議会(congress)、裁判所(court)を含み、それぞれ行政、立法、司法の機能を持つ。これをツリー構造に変換できる:

nation
 ├── government
 │ └── govern
 ├── congress
 │ └── legislate
 └── court
   └── judicial

ファイルシステムでは、ディレクトリ構造は通常、パス文字列内のスラッシュでオブジェクトの位置を表す。Rust のパス区切り文字は:: 。

パスは絶対パスと相対パスに分けられる。絶対パスは crate キーワードから記述を始める。相対パスは self または super キーワード、あるいは識別子から記述を始める。例えば:

crate::nation::government::govern();

これは govern 関数を記述する絶対パスである。相対パスは次のように表せる:

nation::government::govern();

では、ソースプログラム内で同様のモジュール構造を定義し、main関数内でパスを使用してみてほしい。

実際にやってみると、必ず正しくない箇所に気づくだろう:government モジュールとその中の関数はすべてプライベート(private)であり、それらにアクセスすることは許可されていない。


アクセス権限

Rust には2つのシンプルなアクセス権がある:パブリック(public)とプライベート(private)である。

デフォルトでは、修飾子を付けない場合、モジュール内のメンバーのアクセス権はプライベートになる。

パブリックなアクセス権を使用したい場合は、pub キーワードを使用する必要がある。

プライベートなモジュールは、同じ階層または下位の階層からのみアクセスでき、その外部からはアクセスできない。

例

mod nation {
    pub mod government {
        pub fn govern() {}
    }

    mod congress {
        pub fn legislate() {}
    }
   
    mod court {
        fn judicial() {
            super::congress::legislate();
        }
    }
}

fn main() {
    nation::government::govern();
}

このプログラムはコンパイルに成功する。court モジュール内での super のアクセス方法に注目してほしい。

モジュール内で構造体を定義する場合、構造体自体がプライベートであることに加えて、そのフィールドもデフォルトでプライベートになる。そのため、モジュール内の構造体とそのフィールドを使用したい場合は、pub 宣言が必要である:

例

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }

    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("peaches"),
            }
        }
    }
}
pub fn eat_at_restaurant() {
    let mut meal = back_of_house::Breakfast::summer("Rye");
    meal.toast = String::from("Wheat");
    println!("I'd like {} toast please", meal.toast);
}
fn main() {
    eat_at_restaurant()
}

実行結果:

I'd like Wheat toast please

列挙型の列挙子はフィールドを含むことができるが、同様の性質は持たない:

例

mod SomeModule {
    pub enum Person {
        King {
            name: String
        },
        Queen
    }
}

fn main() {
    let person = SomeModule::Person::King{
        name: String::from("Blue")
    };
    match person {
        SomeModule::Person::King {name} => {
            println!("{}", name);
        }
        _ => {}
    }
}

実行結果:

Blue

発見しにくいモジュール

Java を使ったことのある開発者は、プログラミングの際に最外部の class ブロックを非常に煩わしく感じることが多い。その名前はファイル名とまったく同じであり、ファイルのコンテナを表すからだ。煩雑ではあるが、「このクラスはファイルに含まれるクラスである」ことを強調するために、どうしても一度は書かなければならない。

しかし、これにはいくつかの利点がある:少なくとも開発者はクラスのラッパーの存在をはっきりと認識でき、クラスの継承関係を明確に記述できる。

Rust では、モジュールは Java のクラスラッパーのようなものだが、ファイルの先頭に main 関数を書くことができる。これはどのように説明すればよいのだろうか?

すべての Rust ファイルの内容は、「発見しにくい」モジュールなのである。

2つのファイルを使ってこのことを明らかにしよう:

main.rs ファイル

// main.rs
mod second_module;

fn main() {
    println!("This is the main module.");
    println!("{}", second_module::message());
}

second_module.rs ファイル

// second_module.rs
pub fn message() -> String {
    String::from("This is the 2nd module.")
}

実行結果:

This is the main module.
This is the 2nd module.

use キーワード

use キーワードは、モジュールの識別子を現在のスコープに導入できる:

例

mod nation {
    pub mod government {
        pub fn govern() {}
    }
}

use crate::nation::government::govern;

fn main() {
    govern();
}

このプログラムはコンパイルに成功する。

use キーワードが govern 識別子を現在のモジュールに導入したため、直接使用できる。

これにより、ローカルモジュールのパスが長すぎる問題を解決できる。

もちろん、同じ名前が2つ存在し、両方をインポートする必要がある場合もある。その場合は as キーワードを使用して識別子に別名を付けることができる:

例

mod nation {
    pub mod government {
        pub fn govern() {}
    }
    pub fn govern() {}
}
   
use crate::nation::government::govern;
use crate::nation::govern as nation_govern;

fn main() {
    nation_govern();
    govern();
}

ここには2つの govern 関数がある。1つは nation の下、もう1つは government の下にある。as を使用して nation の下にあるものに nation_govern という別名を付ける。2つの名前を同時に使用できる。

use キーワードは pub キーワードと組み合わせて使用できる:

例

mod nation {
    pub mod government {
        pub fn govern() {}
    }
    pub use government::govern;
}

fn main() {
    nation::govern();
}

標準ライブラリを参照する

Rust 公式標準ライブラリリファレンス:https://doc.rust-lang.org/stable/std/all.html

この章の概念を学んだ後は、システムライブラリを簡単にインポートして、便利にプログラムを開発できる:

例

use std::f64::consts::PI;

fn main() {
    println!("{}", (PI / 2.0).sin());
}

実行結果:

1

すべてのシステムライブラリモジュールはデフォルトでインポートされている。そのため、使用する際は use キーワードでパスを簡略化するだけで便利に使える。

その他の拡張