Rust製のパーサコンビネータcombine v4.4.0を覗き見する

$ cloc nom/src/
      32 text files.
      32 unique files.
       0 files ignored.

github.com/AlDanial/cloc v 1.82  T=0.04 s (853.9 files/s, 581289.6 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Rust                            32           1480           7348          12957
-------------------------------------------------------------------------------
SUM:                            32           1480           7348          12957
-------------------------------------------------------------------------------

$ cloc combine/src/
      23 text files.
      23 unique files.
       0 files ignored.

github.com/AlDanial/cloc v 1.82  T=0.03 s (778.9 files/s, 551101.4 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Rust                            23           1401           3594          11278
-------------------------------------------------------------------------------
SUM:                            23           1401           3594          11278
-------------------------------------------------------------------------------

use combine::{many1, Parser, sep_by};
use combine::parser::char::{letter, space};

// parser::char::letter はchar型の入力がstd::char::is_alphabeticを満たせばeatして返す
// many1 は引数に受け取ったパーサが一回以上適用できればパース成功とする
// ここで得られるwordという変数ももちろんパーサである(後述)
let word = many1(letter());

// sep_by は2つ目の引数に渡したパーサをseparatorとする構造をパースする
// 今回で言えばparser::char::space なので，スペース区切りの文字列をパースすると考えてくれれば良い
// 後述するが，各パーサはmap()メソッドを持つ．
// sep_by の返り値が Vec<String> であると注釈することで， 
// rustcは parser.parse() の成果物がStringだとわかる
let mut parser = sep_by(word, space())
    .map(|mut words: Vec<String>| words.pop());

// parse() メソッドを呼び出すことで，実際にパースを実行する
// 今回は入力文字列としてとして &'static strを渡している
let result = parser.parse("Pick up that word!");

// パース成功時，(パーサの成果物， eatされた文字列)というタプルが返る
// タプルの順番がnomと真逆なので注意
assert_eq!(result, Ok((Some("word".to_string()), "!")));

/// Parses an alphabet letter according to [`std::char::is_alphabetic`].
///
/// [`std::char::is_alphabetic`]: https://doc.rust-lang.org/std/primitive.char.html#method.is_alphabetic
///
/// ```
/// use combine::Parser;
/// use combine::parser::char::letter;
/// assert_eq!(letter().parse("a"), Ok(('a', "")));
/// assert_eq!(letter().parse("A"), Ok(('A', "")));
/// assert!(letter().parse("9").is_err());
/// ```
pub fn letter<Input>() -> impl Parser<Input, Output = char, PartialState = ()>
where
    Input: Stream<Token = char>,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
{
    satisfy(|ch: char| ch.is_alphabetic()).expected("letter")
}

impl<'a> StreamOnce for &'a str {
    type Token = char;
    type Range = &'a str;
    type Position = PointerOffset<str>;
    type Error = StringStreamError;

    #[inline]
    fn uncons(&mut self) -> Result<char, StreamErrorFor<Self>> {
        let mut chars = self.chars();
        match chars.next() {
            Some(c) => {
                *self = chars.as_str();
                Ok(c)
            }
            None => Err(StringStreamError::Eoi),
        }
    }
}

impl<'a, T> Positioned for &'a [T]
where
    T: Clone + PartialEq,
{
    #[inline]
    fn position(&self) -> Self::Position {
        PointerOffset::new(self.as_ptr() as usize)
    }
}

impl<'a> Positioned for &'a str {
    #[inline]
    fn position(&self) -> Self::Position {
        PointerOffset::new(self.as_bytes().position().0)
    }
}

#[doc(hidden)]
#[macro_export]
macro_rules! clone_resetable {
    (( $($params: tt)* ) $ty: ty) => {
        impl<$($params)*> ResetStream for $ty
            where Self: StreamOnce
        {
            type Checkpoint = Self;

            fn checkpoint(&self) -> Self {
                self.clone()
            }
            #[inline]
            fn reset(&mut self, checkpoint: Self) -> Result<(), Self::Error> {
                *self = checkpoint;
                Ok(())
            }
        }
    }
}

clone_resetable! {('a) &'a str}

pub trait Stream: StreamOnce + ResetStream + Positioned {}

impl<Input> Stream for Input
where
    Input: StreamOnce + Positioned + ResetStream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
{
}

pub fn letter<Input>() -> impl Parser<Input, Output = char, PartialState = ()>
where
    Input: Stream<Token = char>,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
{
    satisfy(|ch: char| ch.is_alphabetic()).expected("letter")
}

#[derive(Copy, Clone)]
pub struct Satisfy<Input, P> {
    predicate: P,
    _marker: PhantomData<Input>,
}

pub fn satisfy<Input, P>(predicate: P) -> Satisfy<Input, P>
where
    Input: Stream,
    P: FnMut(Input::Token) -> bool,
{
    Satisfy {
        predicate,
        _marker: PhantomData,
    }
}

impl<Input, P> Parser<Input> for Satisfy<Input, P>
where
    Input: Stream,
    P: FnMut(Input::Token) -> bool,
{
    type Output = Input::Token;
    type PartialState = ();

    #[inline]
    fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<Self::Output, Input::Error> {
        satisfy_impl(input, |c| {
            if (self.predicate)(c.clone()) {
                Some(c)
            } else {
                None
            }
        })
    }
}

fn satisfy_impl<Input, P, R>(input: &mut Input, mut predicate: P) -> ParseResult<R, Input::Error>
where
    Input: Stream,
    P: FnMut(Input::Token) -> Option<R>,
{
    let position = input.position();
    match uncons(input) {
        PeekOk(c) | CommitOk(c) => match predicate(c) {
            Some(c) => CommitOk(c),
            None => PeekErr(Input::Error::empty(position).into()),
        },
        PeekErr(err) => PeekErr(err),
        CommitErr(err) => CommitErr(err),
    }
}

pub fn any<Input>() -> Any<Input>
where
    Input: Stream,
{
    Any(PhantomData)
}

#[derive(Copy, Clone)]
pub struct Any<Input>(PhantomData<fn(Input) -> Input>);

impl<Input> Parser<Input> for Any<Input>
where
    Input: Stream,
{
    type Output = Input::Token;
    type PartialState = ();

    #[inline]
    fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<Input::Token, Input::Error> {
        uncons(input)
    }
}