F＃解析器组合器

Question

I'm trying translate the example about monadic parsers ( https://www.cs.nott.ac.uk/~gmh/pearl.pdf ) to F#.

So far I have:

type Parser<'a> = Parser of  (string -> ('a*string) list)

let item : Parser<char> =
  Parser (fun (s:string) -> 
                match s with
                | "" -> []
                | null -> []
                | _ -> (s.Chars(0),s.Substring 1)::[])

let sat (pred : (char -> bool)) : Parser<char> =
  parserWf
    {
       let! c = item
       if pred c then return c
    }

let char c : Parser<char> =
  sat (fun c' -> c'.Equals(c))

let rec string (str:string) : Parser<string> =
  parserWf
    {
        if (str.Length > 0)
        then
            let! c = char (str.Chars 0)
            let! cs = string (str.Substring 1)
            printfn "String: %s" cs
            return c.ToString() + cs
        else
            return ""
    }

If I remove the else return "" from the string method then the result is always the empty list. In Haskell the string function is declared:

string :: String -> Parser String
string "" = return ""
string (c:cs) = do {char c; string cs; return (c:cs)}  

and this works just fine. Why does the F# function not work as expected?

Answer 1

My Haskell is a bit rusty, but isn't the snippet you posted equivalent to your F# code, ie in Haskell too, you need a base case for the recursion (the empty string)?

If you remove the else part, the second to last call to string (ie the one with just one character left) will get no result from its recursive call (passing ""), so it'll return no valid result as well. This then propagates 'upwards' and you'll end up with an empty list.