F# 如何标记用户输入 : separating numbers, 单位、单词？

Question

我是 F# 的新手，但过去几周一直在阅读引用资料。我希望处理用户提供的输入字符串，识别和分离组成元素。例如，对于此输入:

XYZ Hotel: 6 nights at 220EUR / night plus 17.5% tax

输出应该类似于元组列表:

[ ("XYZ", Word); ("Hotel:", Word);
("6", Number); ("nights", Word);
("at", Operator); ("220", Number);
("EUR", CurrencyCode); ("/", Operator); ("night", Word);
("plus", Operator); ("17.5", Number); ("%", PerCent); ("tax", Word) ]

因为我处理的是用户输入，所以它可以是任何东西。因此，期望用户遵守语法是不可能的。我想识别数字(可以是整数、 float 、负数……)、度量单位(可选，但可以包括 SI 或英制物理单位、货币代码、计数，例如我的示例中的“night/s”) 、数学运算符(作为数学符号或单词，包括“at”、“per”、“of”、“discount”等)，以及所有其他单词。

我觉得我应该使用主动模式匹配——对吗？ -- 但我不确定如何开始。任何指向适当引用资料或类似示例的指针都会很棒。

Answer 1

我使用 FParsec 组合了一个示例图书馆。该示例一点也不健壮，但它很好地展示了如何使用 FParsec。

type Element =
| Word of string
| Number of string
| Operator of string
| CurrencyCode of string
| PerCent  of string    

let parsePerCent state =
    (parse {
        let! r = pstring "%"
        return PerCent r
    }) state

let currencyCodes = [|
    pstring "EUR"
|]

let parseCurrencyCode state =
    (parse {
        let! r = choice currencyCodes
        return CurrencyCode r
    }) state

let operators = [|
    pstring "at"
    pstring "/"
|]

let parseOperator state =
    (parse {
        let! r = choice operators
        return Operator r
    }) state

let parseNumber state =
    (parse {
        let! e1 = many1Chars digit
        let! r = opt (pchar '.')
        let! e2 = manyChars digit
        return Number (e1 + (if r.IsSome then "." else "") + e2)
    }) state

let parseWord state =
    (parse {
        let! r = many1Chars (letter <|> pchar ':')
        return Word r
    }) state

let elements = [| 
    parseOperator
    parseCurrencyCode
    parseWord
    parseNumber 
    parsePerCent
|]

let parseElement state =
    (parse {
        do! spaces
        let! r = choice elements
        do! spaces
        return r
    }) state

let parseElements state =
    manyTill parseElement eof state

let parse (input:string) =
    let result = run parseElements input 
    match result with
    | Success (v, _, _) -> v
    | Failure (m, _, _) -> failwith m