如何正确丢弃F＃中的（单峰）计算结果

Question

In Haskell, I can write:

token: Parser a -> Parser a
token p = do space
             v <- p
             space  
             return v

In F#, I have come this far:

let token = compose {
        let! _ = space
        let! v = parser
        let! _ = space
        return v
    }

In other words, I have to introduce this unused let! _ = let! _ = binding to discard the parse value of "space" parser (monad), that I don't need.

How to avoid these useless bindings in F#? I have tried using do!, but I get an error (because my >>= function does not take type unit but 'a):

let (>>=) (p: Parser<'a>) (f: 'a -> Parser<'b>) : Parser<'b> 

Here is my builder definition:

type ParserComposer() = 
  member x.Bind(p, f) = p >>= f
  member x.Return(y) = ret y
  member x.Zero() = failure

Do I need to define >> function? Add Combine() to builder? Any ideas how to do this right? Code example?

Answer 1

Assuming the return type of space is Parser<unit> (which would make sense if it does not represent a parser that returns some result) you can write:

let token = compose {
    do! space
    let! v = parser
    do! space
    return v
}

This is just a syntactic sugar for what you wrote - so do! e do! e is translated as let! _ = e let! _ = e which is, in turn, translated to parser.Bind(e, fun _ -> ...) . I have a sample for Additive parsers on Try Joinads which also defines Combine and a few more (possibly) useful things, but the do! keyword only needs Bind .