CODEWITHSUNDEEP
parsinghaskell
The One
The One

Reputation: 150

Haskell Type error in Double recursion function

I'm trying to define a greedy function

greedy :: ReadP a -> ReadP [a]

that parses a sequence of values, returning only the "maximal" sequences that cannot be extended any further. For example,

> readP_to_S (greedy (string "a" +++ string "ab")) "abaac"
[(["a"],"baac"),(["ab","a","a"],"c")]

I'm using a very simple and probably clumsy way. Just parse the values and see if they can be parsed any further; if so, then reapply the function again to get all the possible values and concat that with the previous ones, or else just return the value itself. However, there seems to be some type problems, below is my code.

import Text.ParserCombinators.ReadP

addpair :: a -> [([a],String)] -> [([a],String)]
addpair a [] = []
addpair a (c:cs) = (a : (fst c), snd c ) : (addpair a cs)

greedy :: ReadP a -> ReadP [a]
greedy ap = readS_to_P (\s ->
    let list = readP_to_S ap s in 
    f list )
    where
        f :: [(a,String)] -> [([a],String)]
        f ((value, str2):cs) = 
            case readP_to_S ap str2 of
                [] -> ([value], str2) : (f cs)
                _ -> (addpair value (readP_to_S (greedy ap) str2)) ++ (f cs)

The GHC processes the code and says that function "f" has type [(a1,String)] -> [([a1],String)] but greedy is ReadP a -> ReadP [a]. I wonder why it is so because I think their type should agree. It also really helps if anyone can come up with some clever and more elegant approach to define the function greedy(my approach is definitely way too redundant)

Upvotes: 2

Views: 94

Answers (1)

Izaak Weiss
Izaak Weiss

Reputation: 1310

To fix the compilation error, you need to add the language extension

{-# LANGUAGE ScopedTypeVariables #-}

to your source file, or pass the corresponding flag into the compiler. You also need to change the type signature of greedy to

greedy :: forall a. ReadP a -> ReadP [a]

This is because your two a type variables are not actually the same; they're in different scopes. With the extension and the forall, they are treated as being the same variable, and your types unify properly. Even then, the code errors, because you don't have an exhaustive pattern match in your definition of f. If you add

f [] = []

then the code seems to work as intended.

In order to simplify your code, I took a look at the provided function munch, which is defined as:

munch :: (Char -> Bool) -> ReadP String
-- ^ Parses the first zero or more characters satisfying the predicate.
--   Always succeeds, exactly once having consumed all the characters
--   Hence NOT the same as (many (satisfy p))
munch p =
  do s <- look
     scan s
 where
  scan (c:cs) | p c = do _ <- get; s <- scan cs; return (c:s)
  scan _            = do return ""

In that spirit, your code can be rewritten as:

greedy2 :: forall a. ReadP a -> ReadP [a]
greedy2 ap = do
  -- look at the string
  s <- look
  -- try parsing it, but without do notation
  case readP_to_S ap s of
    -- if we failed, then return nothing
    [] -> return []
    -- if we parsed something, ignore it
    (_:_) -> do
      -- parse it again, but this time inside of the monad
      x <- ap
      -- recurse, greedily parsing again
      xs <- greedy2 ap
      -- and return the concatenated values
      return (x:xs)

This does have the speed disadvantage of executing ap twice as often as needed; this may be too slow for your use case. I'm sure my code could be further rewritten to avoid that, but I'm not a ReadP expert.

Upvotes: 2

Related Questions