HN 日本語サマリー

← 一覧へ戻る
プログラミング

「Parse, don't validate」に関するRustでの考察

Rusty thoughts on "Parse, don't validate" (eli.thegreenplace.net)

95 pointsby ingve47 コメント

要約

この記事は、プログラミングにおける「Parse, don't validate」(検証するのではなくパースせよ)というイディオムをRust言語に適用した考察です。Rustの標準ライブラリや人気のあるプロジェクトにおける具体的な例を通じて、このパターンがどのように活用されているか、そして型システムを利用して不変条件を強制することでコードの明確性や安全性を向上させる方法を解説しています。

全文翻訳

Rustにおける「パースせよ、検証するな」に関する考察

多くのプログラマーと同様に、私もAlexis Kingの「パースせよ、検証するな」という記事に魅了されています。なぜなら、それは以前から馴染みがあり重要だと感じていたイディオムに名前を与えてくれるからです。私はこのイディオムを、明示的に名前を付けずに過去に観察し、使用してきました。この記事は、Rustプログラミング言語(元の記事はHaskellを使用)に適用された「パースせよ、検証するな」パターンについてのレビューです。特に、Rust標準ライブラリやその他の有名なプロジェクトにおけるこのパターンの教育的な例を見つけることに興味がありました。

元の記事を繰り返すことなく(まずお読みください!)、その要点は以下の通りです。

古くからあるVecを考えてみましょう。そのfirstメソッドはOption<&T>を返します。なぜでしょうか? ベクターには要素が含まれている保証がないため、空のベクターに対してfirstが呼び出された場合にどうすればよいでしょうか? Rustでは、この場合の戻り値としてOptionを返すのが慣用的です[1]。Optionを返す関数の結果を受け入れ、次に何をすべきかを決定するための便利な構文糖衣があります。

では、問題は何でしょうか?

環境変数から設定パスを読み込む関数があると仮定しましょう。ただし、リストが空であってはならないという不変条件を強制します。

use anyhow::{Result, ensure};

fn get_configuration_directories() -> Result<Vec<PathBuf>> {
    let value = env::var("CONFIG_DIRS").context("could not read CONFIG_DIRS")?;

    let directories: Vec<PathBuf> = value
        .split(',')
        .map(str::trim)
        .map(PathBuf::from)
        .collect();

    ensure!(!directories.is_empty(), "empty CONFIG_DIRS");
    Ok(directories)
}

ここまでは順調です。次に、この関数の典型的な使用例を見てみましょう。

fn main() -> Result<()> {
    let config_dirs = get_configuration_directories()?;

    match config_dirs.first() {
        Some(cache_dir) => initialize_cache(cache_dir),
        None => unreachable!("already checked that CONFIG_DIRS is non-empty"),
    }

    Ok(())
}

get_configuration_directoriesが成功した結果を返せば、ベクターが空でないことは保証されています。それにもかかわらず、このベクターの最初の要素を取得したい場合、Option<&T>を返すfirstメソッドを使用しなければなりません。したがって、私たちは(再び)潜在的に空のケース(OptionがNoneになる場合)を処理することを余儀なくされます。

元の記事が述べているように、これにはコードの明確性、潜在的なパフォーマンスへの影響、そしてget_configuration_directoriesで不変条件が変更された場合に発生する「時限爆弾」といった、いくつかの問題があります。

根本的な問題は、Vecは基本的に空になりうる型であるということです。関連するすべてのコードに「これは空にはならない、約束するよ!」というコメントを添えて持ち運ぶことはできますが、それは何によっても形式的にチェックされません。

「空でない」ベクターのための型

解決策は、型システムを活用して新しく確立された不変条件を強制することです。「空にできないベクター」のために別の型を使用します。実際、そのような型はいくつかのRustクレートにすでに存在しています。例えば、nonemptyです。

pub struct NonEmpty<T> {
    pub head: T,
    pub tail: Vec<T>,
}

この型には、「要素がない」ことを許可するコンストラクタがありません。そのnewは1つの要素を取り、そのfirstメソッドはOptionなしで&Tを返します。

pub const fn new(e: T) -> Self {
    Self::singleton(e)
}

pub const fn singleton(head: T) -> Self {
    NonEmpty {
        head,
        tail: Vec::new(),
    }
}

pub const fn first(&self) -> &T {
    &self.head
}

クレートの残りの部分は、多くの便利なトレイトを実装し、次のような変換を行うことで、NonEmptyを通常のVecにできるだけ近づけるように扱っています。

pub fn from_vec(mut vec: Vec<T>) -> Option<NonEmpty<T>> {
    if vec.is_empty() {
        None
    } else {
        let head = vec.remove(0);
        Some(NonEmpty { head, tail: vec })
    }
}

get_configuration_directories関数が通常のVecではなくNonEmptyを返すようにした場合、どのように見えるか見てみましょう。

fn get_configuration_directories() -> Result<NonEmpty<PathBuf>> {
    let value = env::var("CONFIG_DIRS").context("could not read CONFIG_DIRS")?;

    let directories = value
        .split(',')
        .map(str::trim)
        .map(PathBuf::from)
        .collect();

    let Some(directories) = NonEmpty::from_vec(directories) else {
        bail!("CONFIG_DIRS cannot be empty");
    };

    Ok(directories)
}

ここでNonEmpty::from_vecを使用していることに注意してください。ここで不変条件が確立されます。成功した結果は、単なるVecではなくNonEmptyになります。クライアントコードは次のようになります。

fn main() -> Result<()> {
    let config_dirs = get_configuration_directories()?;

    initialize_cache(config_dirs.first())?;
    Ok(())
}

返された値が空かどうかを再度チェックする必要はありません。これは型システムによって強制されます!

ここで、元の記事の「パース対検証」という用語が登場します。get_configuration_directoriesがVecを返した場合、それは単に検証しただけでした。しかし、NonEmptyを返す場合、ベクターは追加の意味を持つ別のエンティティに変換されます。「パース」という概念を最も一般的な意味、「データをある形式から別の形式に変換する」と捉えるなら、これは当てはまります。

人工的な例よりも、Rustで書かれたコアPOSIXユーティリティのリライトは、いくつかの場所でNonEmptyを使用しています[2]。例えば、シェルパイプラインを構築する際です。

pub struct Pipeline {
    pub commands: NonEmpty<Command>,
    pub negate_status: bool,
}

コマンドパーサーのコードです。

fn parse_pipeline(&mut self, alias_table: &AliasTable) -> ParseResult<Option<Pipeline>> {
    // pipeline = "!" command ("|" linebreak command)*
    let negate_status = self.match_alternatives(&[CommandToken::Bang])?.is_some();
    let mut commands = if let Some(command) = self.parse_command(alias_table)? {
        NonEmpty::new(command)
    } else {
        return Ok(None);
    };

    // ...
}

有効なPipelineは、解析されたASTにコマンドがいくつか存在する場合にのみ返されます。それ以外の場合は、Noneが返されます。これが完了すると、クライアントコードはNoneを返す可能性を心配することなくcommands.first()を使用できます。

段階的なパースと型精緻化

やや興味深い例は、rust-analyzerのソースコードに見られます。このプロジェクトには、絶対ファイルシステムパスを表す型があります。

pub struct AbsPathBuf(Utf8PathBuf);

通常のパスを持ち運ぶ代わりに、初期パースと検証が完了すると、絶対パスであることが型に記録されます。

impl TryFrom<Utf8PathBuf> for AbsPathBuf {
    type Error = Utf8PathBuf;
    fn try_from(path_buf: Utf8PathBuf) -> Result<AbsPathBuf, Utf8PathBuf> {
        if !path_buf.is_absolute() {
            return Err(path_buf);
        }
        Ok(AbsPathBuf(path_buf))
    }
}

後続のコードは、パスが絶対であることを検証する必要はありません。型がそれを強制します。

また、AbsPathBufはPathBufではなくUtf8PathBufをラップしていることにも注意してください。Utf8PathBuf自体は、caminoクレートからのカスタムで「パースされた」型の精緻化です。Rust標準ライブラリの通常のパスは有効なUTF-8であることが保証されていないため、文字列(Rustでは有効なUTF-8である必要がある)に簡単に変換できません。camino::Utf8PathBufは構築時に有効性を確立し、その後次のように簡単に文字列に変換できます。

fn as_str(&self) -> &str {
  ...
}

したがって、ここでは段階的なパースと型精緻化の例が見られます。

std::path::PathBuf

      |
      |
      |   UTF-8であることを証明
      |
      V

camino::Utf8PathBuf

      |
      |
      |   絶対パスであることを証明
      |
      V

rust-analyzerのpaths::AbsPathBuf

ゼロでない整数

Rustには、ゼロでないことがわかっている符号なし数値量を表すための汎用型であるNonZeroがあります。

例えば、thread::available_parallelismは次のように定義されています。

pub fn available_parallelism() -> Result<NonZero<usize>>

呼び出しが成功した場合、それはNonZero<usize>を返します。これは、ゼロではないという制約を持つ通常のusizeのようなものです。クライアントコードは、並列性が0かどうかを常にチェックする必要はありません。それは型システムに組み込まれています。

Rustは、分母にNonZero<usize>を持つ除算演算子を「パニックしない」操作として定義しています。

NonZeroには追加の利点があります。ゼロはこの型の無効な値であるため、RustはゼロビットパターンをNoneを表すために使用できます。したがって、Option<NonZeroUsize>は、NonZeroUsize自体(およびusize)と同じサイズとアラインメントを持つことが保証されています。これは、Option<usize>が通常必要とする追加のストレージを回避できる可能性があります。

JSONのパース

「パースせよ、検証するな」イディオムの一般的な例は、JSON文字列からのデータの逆シリアライズに見られます。Rustのserdeクレートは、型システムにエンコードされた検証済みの決定を伴うパースを可能にします。例えば。

#[derive(Debug, Deserialize)]
struct Config {
    name: String,
    workers: NonZeroUsize,
    mode: Mode,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "snake_case")]
enum Mode {
    Fast,
    Safe,
}

そして後で。

let input = r#"
     {
         "name": "compiler",
         "workers": 4,
         "mode": "fast"
     }
 "#;

 let config: Config = serde_json::from_str(input)?;

バックグラウンドでは多くのことが行われています。

  • すべてのフィールドの型が強制されます(例:「name」が配列であってはならない)。
  • modeはModeの列挙値のいずれかに検証されます。
  • workersは、NonZeroUsizeフィールド型のため、ゼロでない整数に検証されます。

私たちは今日、これらのことを当たり前のように受け取っていますが、それでもこの記事で議論されているパターンの素晴らしい例です。パーサーがmodeをMode列挙型に変換すると、それ以上の検証は不要になります。

PythonやJSのような動的言語では、プロセスは通常、はるかに手動で行われます。Pythonのjson.loadsは辞書を返しますが、その内容を検証するのはユーザー次第です。PydanticのようなライブラリはRustのアプローチに近いものを提供しますが、それらは普遍的に使用されているわけではありません。


1他の言語(GoやPythonなど)には専用のfirstメソッドや関数がなく、プログラマーはlst[0]が空のリストやスライスでアクセスされたときに例外やパニックを引き起こすような実行時チェックに依存する必要があります。これは間違いではなく、Optionのような型なしでは意味を狭めるのが難しいため、GoやPythonにはこれらのメソッド/関数が追加されませんでした。
2このプロジェクトはnonemptyクレートに依存せずに独自のNonEmptyを実装していますが、この記事のすべての点は当てはまります。

コメントについては、メールでお送りください。