为整数编写解析器-类型错误

Question

Given the following Parser definitions (from Prof. Brent Yorgey's U of Penn class ):

newtype Parser a = Parser { runParser :: String -> Maybe (a, String) }

satisfy :: (Char -> Bool) -> Parser Char
satisfy p = Parser f
  where
    f [] = Nothing    -- fail on the empty input
    f (x:xs)          -- check if x satisfies the predicate
                        -- if so, return x along with the remainder
                        -- of the input (that is, xs)
        | p x       = Just (x, xs)
        | otherwise = Nothing  -- otherwise, fail

Given the following parser for one or more of 'a' :

oneOrMore :: Parser a -> Parser [a]
oneOrMore p = (:) <$> p <*> (zeroOrMore p)

And, now I'd like to extract an Integer or nothing:

parseInteger :: String -> Maybe Integer
parseInteger = fmap (read . fst) $ runParser (oneOrMore (satisfy isNumber))

But I'm getting this compile-time error:

JsonParser.hs:42:36:
    Couldn't match type ‘(String, b0)’ with ‘Maybe ([Char], String)’
    Expected type: String -> (String, b0)
      Actual type: String -> Maybe ([Char], String)
    In the second argument of ‘($)’, namely
      ‘runParser (oneOrMore (satisfy isNumber))’
    In the expression:
      fmap (read . fst) $ runParser (oneOrMore (satisfy isNumber))
Failed, modules loaded: SExpr, Model, AParser.
*SExpr Data.Char> :t runParser 
runParser :: Parser a -> String -> Maybe (a, String)

I'm confused since runParser has a type of String -> Maybe (a, String) .

Calling fmap on Maybe (a, String) should apply fmap 's function to the (a, String) type.

What am I missing?

Answer 1

You need to use (.) instead of $ :

fmap (read . fst) . runParser (oneOrMore (satisfy isNumber))

alternatively you need to supply the string to runParser :

parseInteger s = fmap (read . fst) $ runParser (oneOrMore (satisfy isNumber)) s

fmap (read . fst) in this case has type Maybe (String, a) -> Maybe Integer and runParser (oneOrMore (satisfy isNumber)) has type String -> Maybe (String, String) . These two functions can be composed with (.) , but ($) has type (a -> b) -> a -> b - here a is Maybe (String, a) while you are supplying the function inside the Parser .

If you apply the string to this function instead, you can get the Maybe (String, a) required by ($) .