combine

ソースをお取り寄せ。 book-real-world-haskell (ch16)

一番簡単なCSVのパーサー。

import Text.ParserCombinators.Parsec

csvFile = endBy line eol
line = sepBy cell (char ',')
cell = many (noneOf ",\n")
eol = char '\n'

parseCSV :: String -> Either ParseError [[String]]
parseCSV input = parse csvFile "(unknown)" input

なんと、これだけで素朴なCSVファイルをパース出来るとな。声に出して読んでみると、ファイルは、ラインが寄り集まって、最後はEOLで終わるやつ。EOLってのは、\\n ね。世の中には、他のEOLもあるけど、取り敢えず無視。

ラインの構成は、セル(EXCELLで考えるんだ)をカンマでくわけしたもの。で、肝心のセルってのは、カンマとEOLじゃ無い文字の羅列。たったこれだけ。定義を書いただけって趣。

これをcombineの木箱を使って賭。

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

fn type_of<T>(_: T) -> &'static str {
    std::any::type_name::<T>()
}

fn main() {
    let mut cell = many1(digit());
    println!("{}", type_of(&cell));
    let mut csv = sep_by(cell, char(',')).map(|words: Vec<String>| words);
    let result = csv.parse("221,130,64,59\n123,65,67,55\n");
    println!("{:?}", result.unwrap());
}

まだ、中途半端なやつだ。

&combine::parser::repeat::Many1<alloc::string::String, combine::parser::char::Digit<&str>>
(["221", "130", "64", "59"], "\n123,65,67,55\n")

haskellのお手本に習って、追加すればいいんだな。

fn main() {
    let cell = many1(digit());
    let mut line = sep_by(cell, char(','));
    let mut csv = sep_by(line, char('\n')).map(|words: Vec<String>| words);
    let result = csv.parse("221,130,64,59\n123,65,67,55\n");
    println!("{:?}", result.unwrap());
}

突然、地獄へ引っ張りこまれました。エラーのオンパレード。

error[E0283]: type annotations needed for `Many1<F, Digit<&str>>`
   --> src/main.rs:12:16
    |
12  |     let cell = many1(digit());
    |         ----   ^^^^^ cannot infer type for type parameter `F` declared on
the function `many1`
    |         |
    |         consider giving `cell` the explicit type `Many1<F, _>`, where the
type parameter `F` is specified
    |
    = note: cannot satisfy `_: Extend<char>`

推測できひんか。

note: required by a bound in `many1`
   --> /home/sakae/.cargo/registry/src/github.com-1285ae84e5963aae/combine-4.6.3
/src/parser/repeat.rs:532:8
    |
532 |     F: Extend<P::Output> + Default,
    |        ^^^^^^^^^^^^^^^^^ required by this bound in `many1`
help: consider specifying the type arguments in the function call
    |
12  |     let cell = many1::<F, Input, P>(digit());
    |                     +++++++++++++++

もう、お手上げです。

自分で考えていても解らん。benches/ なんて所にjson.rsがいた。ベンチマーク用？ 藁にもすがる気持で、コードを眺めましたよ。

で、分った亊は、自分で関数を定義する必要があるって亊。その関数ってのは、新しい型を返す関数。

下記の例だと、cellは１つ以上の数値の集まり。それが見付かったら、整数に変換して出力するよ。そういうParserだからね。って言う関数だ。

use combine::{
    many1,
    parser::char::{char, digit},
    sep_by, ParseError, Parser, Stream,
};

fn cell<Input>() -> impl Parser<Input, Output = i32>
where
    Input: Stream<Token = char>,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
{
    many1(digit())
        .map(|s: String| {
            let mut n = 0;
            for c in s.chars() {
                n = n * 10 + (c as i32 - '0' as i32);
            }
            n
        })
        .expected("integer")
}

fn main() {
    let line = sep_by(cell(), char(',')).map(|words: Vec<i32>| words);
    let mut csv = sep_by(line, char('\n')).map(|words: Vec<Vec<i32>>| words);
    let result = csv.parse("221,130,64,59\n305,135,67,55\n");
    println!("{:?}", result.unwrap());
}

して、結果は

([[221, 130, 64, 59], [305, 135, 67, 55], []], "")

何とか動き出したな。でも不満がある。

上記では、データが決めうち。これじゃ実用にならん。ファイルから読み込んだデータを使いたい。

let input =  std::fs::read_to_string("current.csv").unwrap();

ファイルから全部読みしたのを使いたい。が、エラーだ。

error[E0597]: `input` does not live long enough
  --> src/main.rs:30:26
   |
30 |         = csv.easy_parse(&input);
   |                          ^^^^^^ borrowed value does not live long enough
31 |     println!("{:?}", result.unwrap().0);
32 | }
   | -
   | |
   | `input` dropped here while still borrowed

これに対する説明として、rustc –explain E0597 こんな事例で解説されてた。

struct Foo<'a> {
    x: Option<&'a u32>,
}

let mut x = Foo { x: None };
{
    let y = 0;
    x.x = Some(&y); // error: `y` does not live long enough
}
println!("{:?}", x.x);

下のやつが改訂版。

struct Foo<'a> {
    x: Option<&'a u32>,
}

let mut x = Foo { x: None };

let y = 0;
x.x = Some(&y);

println!("{:?}", x.x);

目をこらして違いを見付ないといかん。悪いやつは、ブロックの中でyを宣言して、それを使って代入してる。ブロックの外で使おうとすると、rustの規則によりyは藻屑となってるからエラー。

だから、ブロックを削除して、同一階層で使いましょうとな。こんなに分かりやすい例ならいいんだけど。。

何かcombineの深い所で、これに反する亊が起きているんだろうね。深入りは止めておこう。

今迄cellって関数を使ってたけど、docs.rsに手軽な数値化を行うパーサーが出てた。すっきりっぽい。

let cell = spaces()
    .with(many1(digit())
          .map(|string: String| string.parse::<i32>().unwrap()));

一般的な文字列から数値に変換する方法だ。これを使ってやれ。

error[E0382]: use of moved value: `cell`
  --> src/main.rs:12:27
   |
8  |     let cell = spaces()
   |         ---- move occurs because `cell` has type `With<impl Parser<combine\
::easy::Stream<&str>>, combine::parser::combinator::Map<Many1<String, Digit<com\
bine::easy::Stream<&str>>>, [closure@src/main.rs:10:20: 10:67]>>`, which does n\
ot implement the `Copy` trait
...
12 |         (cell, char(','), cell, char(','), cell, char(','), cell)
   |          ----             ^^^^ value used here after move
   |          |
   |          value moved here

至る所が地雷源である。オイラーに取っては、combineって、取扱注意木箱ですな。 nom = alt(combine) になるかな。