haskell happy - "Couldn't match expected type"

1
votes

I have some problems to understand error messages of the parser generator system happy for haskell.

For instance this code

{
module Test_parser where

import System.IO
import Test_lexer

}

%name parse

%tokentype { Token }
%error { parseError }

%token

    true                { TokenTrue posn }
    false               { TokenFalse posn }
    number              { TokenInteger posn $$ }

%%

LiteralExpr :
        true            {LiteralTrue ()}
    | false         {LiteralFalse ()}
    | number        {LiteralInteger () $1}

{

data Expression n =
    LiteralTrue n
    | LiteralFalse n
    | LiteralInteger n Integer
        deriving (Eq, Show)

parseError xs = error "Parse error"

main = do 
  inStr <- getContents
  let parseTree = parse (alexScanTokens inStr)  
  putStrLn $ show(parseTree)
}

works fine.

But if I do something like that

....

LiteralExpr :
    true            {LiteralTrue ()}
    | false         {LiteralFalse ()}
    | Inte          {$1}

Inte :
    number          {LiteralInteger () $1}


{

data Expression n =
    LiteralTrue n
    | LiteralFalse n
    | Inte n
        deriving (Eq, Show)

data Inte n =
    LiteralInteger n Integer
        deriving (Eq, Show)

....

I will get a huge error message. So it would be very nice if you could help me to understand it.

thanks in advance

2
parsinghaskellparser-generatorhappy

2 Answers

2
votes

Seems like you're confusing data constructors and type constructors. Inte in Expression is a data constructor that happened to have the same name as (and isn't otherwise related to) the Inte datatype that you define below.

You should have something like

data Expression n =
    LiteralTrue n
    | LiteralFalse n
    | LiteralInt (Inte n)

and modify your code appropriately (add LiteralInt where needed).

0
votes

ok, this is the way it goes:

...
LiteralExpr :
    true            {LiteralTrue ()}
    | false         {LiteralFalse ()}
    | Inte          {LiteralInt $1}

Inte :
    number          {LiteralInteger () $1}
...

and

...
data Expression n =
    LiteralTrue n
    | LiteralFalse n
    | LiteralInt (Inte n)
        deriving (Eq, Show)

data Inte n =
    LiteralInteger n Integer
        deriving (Eq, Show)
...