module GSyntax where

import GF.GFCC.DataGFCC
import GF.GFCC.AbsGFCC
----------------------------------------------------
-- automatic translation from GF to Haskell
----------------------------------------------------

class Gf a where gf :: a -> Exp
class Fg a where fg :: Exp -> a

newtype GString = GString String  deriving Show

instance Gf GString where
  gf (GString s) = DTr [] (AS s) []

instance Fg GString where
  fg t =
    case t of
      DTr [] (AS s) []  -> GString s
      _ -> error ("no GString " ++ show t)

newtype GInt = GInt Integer  deriving Show

instance Gf GInt where
  gf (GInt s) = DTr [] (AI s) []

instance Fg GInt where
  fg t =
    case t of
      DTr [] (AI s) []  -> GInt s
      _ -> error ("no GInt " ++ show t)

newtype GFloat = GFloat Double  deriving Show

instance Gf GFloat where
  gf (GFloat s) = DTr [] (AF s) []

instance Fg GFloat where
  fg t =
    case t of
      DTr [] (AF s) []  -> GFloat s
      _ -> error ("no GFloat " ++ show t)

----------------------------------------------------
-- below this line machine-generated
----------------------------------------------------

data GA2 =
   GDivisible 
 | GEqual 
 | GGreater 
 | GSmaller 
  deriving Show

data GAP =
   GComplA2 GA2 GNP 
 | GConjAP GConj GAP GAP 
 | GEven 
 | GOdd 
 | GPrime 
  deriving Show

data GAnswer =
   GNo 
 | GValue GNP 
 | GYes 
  deriving Show

data GCN =
   GModCN GAP GCN 
 | GNumber 
  deriving Show

data GConj =
   GAnd 
 | GOr 
  deriving Show

newtype GListPN = GListPN [GPN] deriving Show

data GNP =
   GConjNP GConj GNP GNP 
 | GEvery GCN 
 | GMany GListPN 
 | GNone 
 | GSome GCN 
 | GUsePN GPN 
  deriving Show

data GPN =
   GGCD GListPN 
 | GProduct GListPN 
 | GSum GListPN 
 | GUseInt GInt 
  deriving Show

data GQuestion =
   GQuestS GS 
 | GWhatIs GPN 
 | GWhichAre GCN GAP 
  deriving Show

data GS = GPredAP GNP GAP 
  deriving Show


instance Gf GA2 where
 gf GDivisible = DTr [] (AC (CId "Divisible")) []
 gf GEqual = DTr [] (AC (CId "Equal")) []
 gf GGreater = DTr [] (AC (CId "Greater")) []
 gf GSmaller = DTr [] (AC (CId "Smaller")) []

instance Gf GAP where
 gf (GComplA2 x1 x2) = DTr [] (AC (CId "ComplA2")) [gf x1, gf x2]
 gf (GConjAP x1 x2 x3) = DTr [] (AC (CId "ConjAP")) [gf x1, gf x2, gf x3]
 gf GEven = DTr [] (AC (CId "Even")) []
 gf GOdd = DTr [] (AC (CId "Odd")) []
 gf GPrime = DTr [] (AC (CId "Prime")) []

instance Gf GAnswer where
 gf GNo = DTr [] (AC (CId "No")) []
 gf (GValue x1) = DTr [] (AC (CId "Value")) [gf x1]
 gf GYes = DTr [] (AC (CId "Yes")) []

instance Gf GCN where
 gf (GModCN x1 x2) = DTr [] (AC (CId "ModCN")) [gf x1, gf x2]
 gf GNumber = DTr [] (AC (CId "Number")) []

instance Gf GConj where
 gf GAnd = DTr [] (AC (CId "And")) []
 gf GOr = DTr [] (AC (CId "Or")) []

instance Gf GListPN where
 gf (GListPN [x1,x2]) = DTr [] (AC (CId "BasePN")) [gf x1, gf x2]
 gf (GListPN (x:xs)) = DTr [] (AC (CId "ConsPN")) [gf x, gf (GListPN xs)]

instance Gf GNP where
 gf (GConjNP x1 x2 x3) = DTr [] (AC (CId "ConjNP")) [gf x1, gf x2, gf x3]
 gf (GEvery x1) = DTr [] (AC (CId "Every")) [gf x1]
 gf (GMany x1) = DTr [] (AC (CId "Many")) [gf x1]
 gf GNone = DTr [] (AC (CId "None")) []
 gf (GSome x1) = DTr [] (AC (CId "Some")) [gf x1]
 gf (GUsePN x1) = DTr [] (AC (CId "UsePN")) [gf x1]

instance Gf GPN where
 gf (GGCD x1) = DTr [] (AC (CId "GCD")) [gf x1]
 gf (GProduct x1) = DTr [] (AC (CId "Product")) [gf x1]
 gf (GSum x1) = DTr [] (AC (CId "Sum")) [gf x1]
 gf (GUseInt x1) = DTr [] (AC (CId "UseInt")) [gf x1]

instance Gf GQuestion where
 gf (GQuestS x1) = DTr [] (AC (CId "QuestS")) [gf x1]
 gf (GWhatIs x1) = DTr [] (AC (CId "WhatIs")) [gf x1]
 gf (GWhichAre x1 x2) = DTr [] (AC (CId "WhichAre")) [gf x1, gf x2]

instance Gf GS where gf (GPredAP x1 x2) = DTr [] (AC (CId "PredAP")) [gf x1, gf x2]


instance Fg GA2 where
 fg t =
  case t of
    DTr [] (AC (CId "Divisible")) [] -> GDivisible 
    DTr [] (AC (CId "Equal")) [] -> GEqual 
    DTr [] (AC (CId "Greater")) [] -> GGreater 
    DTr [] (AC (CId "Smaller")) [] -> GSmaller 
    _ -> error ("no A2 " ++ show t)

instance Fg GAP where
 fg t =
  case t of
    DTr [] (AC (CId "ComplA2")) [x1,x2] -> GComplA2 (fg x1) (fg x2)
    DTr [] (AC (CId "ConjAP")) [x1,x2,x3] -> GConjAP (fg x1) (fg x2) (fg x3)
    DTr [] (AC (CId "Even")) [] -> GEven 
    DTr [] (AC (CId "Odd")) [] -> GOdd 
    DTr [] (AC (CId "Prime")) [] -> GPrime 
    _ -> error ("no AP " ++ show t)

instance Fg GAnswer where
 fg t =
  case t of
    DTr [] (AC (CId "No")) [] -> GNo 
    DTr [] (AC (CId "Value")) [x1] -> GValue (fg x1)
    DTr [] (AC (CId "Yes")) [] -> GYes 
    _ -> error ("no Answer " ++ show t)

instance Fg GCN where
 fg t =
  case t of
    DTr [] (AC (CId "ModCN")) [x1,x2] -> GModCN (fg x1) (fg x2)
    DTr [] (AC (CId "Number")) [] -> GNumber 
    _ -> error ("no CN " ++ show t)

instance Fg GConj where
 fg t =
  case t of
    DTr [] (AC (CId "And")) [] -> GAnd 
    DTr [] (AC (CId "Or")) [] -> GOr 
    _ -> error ("no Conj " ++ show t)

instance Fg GListPN where
 fg t =
  case t of
    DTr [] (AC (CId "BasePN")) [x1,x2] -> GListPN [fg x1, fg x2]
    DTr [] (AC (CId "ConsPN")) [x1,x2] -> let GListPN xs = fg x2 in GListPN (fg x1:xs)
    _ -> error ("no ListPN " ++ show t)

instance Fg GNP where
 fg t =
  case t of
    DTr [] (AC (CId "ConjNP")) [x1,x2,x3] -> GConjNP (fg x1) (fg x2) (fg x3)
    DTr [] (AC (CId "Every")) [x1] -> GEvery (fg x1)
    DTr [] (AC (CId "Many")) [x1] -> GMany (fg x1)
    DTr [] (AC (CId "None")) [] -> GNone 
    DTr [] (AC (CId "Some")) [x1] -> GSome (fg x1)
    DTr [] (AC (CId "UsePN")) [x1] -> GUsePN (fg x1)
    _ -> error ("no NP " ++ show t)

instance Fg GPN where
 fg t =
  case t of
    DTr [] (AC (CId "GCD")) [x1] -> GGCD (fg x1)
    DTr [] (AC (CId "Product")) [x1] -> GProduct (fg x1)
    DTr [] (AC (CId "Sum")) [x1] -> GSum (fg x1)
    DTr [] (AC (CId "UseInt")) [x1] -> GUseInt (fg x1)
    _ -> error ("no PN " ++ show t)

instance Fg GQuestion where
 fg t =
  case t of
    DTr [] (AC (CId "QuestS")) [x1] -> GQuestS (fg x1)
    DTr [] (AC (CId "WhatIs")) [x1] -> GWhatIs (fg x1)
    DTr [] (AC (CId "WhichAre")) [x1,x2] -> GWhichAre (fg x1) (fg x2)
    _ -> error ("no Question " ++ show t)

instance Fg GS where
 fg t =
  case t of
    DTr [] (AC (CId "PredAP")) [x1,x2] -> GPredAP (fg x1) (fg x2)
    _ -> error ("no S " ++ show t)