content: module SyntaxUtil(module SyntaxUtil,module HsConstants) where
  import HsConstants
  import Syntax
  import PrettyPrint
  
  -- Built-in type constructors/names
  
  unit_tycon          = hsTyCon unit_tycon_name :: HsType
  fun_tycon           = hsTyCon fun_tycon_name  :: HsType
  list_tycon          = hsTyCon list_tycon_name :: HsType
  tuple_tycon i       = hsTyCon $ tuple_tycon_name i :: HsType
  
  
  -- Test functions (used by the parser)
  isPatternExp :: HsExp -> Bool
  isPatternExp (Exp pe) = isPatternE isConE isVarE isPatternExp pe
  
  isFundefLhs :: HsExp -> Bool -> Bool
  isFundefLhs (Exp pe) p = isFundefLhsE isPatternExp isFundefLhs pe p
  
  isInfixApp :: HsExp -> Bool
  isInfixApp (Exp (HsInfixApp _ _ _)) = True
  isInfixApp _                        = False
  
  isPInfixApp :: HsPat -> Bool
  isPInfixApp (Pat (HsPInfixApp _ _ _)) = True
  isPInfixApp _                         = False
  
  isConE (Exp (HsId (HsCon _))) = True
  isConE _                      = False
  
  isVarE (Exp (HsId (HsVar _))) = True
  isVarE _                      = False
  
  isTyVar (Typ (HsTyVar _)) = True
  isTyVar _                 = False
  
  
  -- Extractor functions
  
  getOpAndArgs :: HsExp -> (HsIdent, HsExp, HsExp)
  getOpAndArgs (Exp (HsInfixApp a op b)) = (op, a, b)
  getOpAndArgs e                         =
      error ("BaseSyntaxUtil.getOpAndArgs: not an infix application:\n\n"
  	   ++ pp e ++ "\n")
  
  getPOpAndArgs :: HsPat -> (HsIdent, HsPat, HsPat)
  getPOpAndArgs (Pat (HsPInfixApp a op b)) = (op, a, b)
  getPOpAndArgs p                         =
      error ("BaseSyntaxUtil.getPOpAndArgs: not an infix application:\n\n"
  	   ++ pp p ++ "\n")
  
  getTyVar (Typ (HsTyVar v)) = v
  getTyCon (Typ (HsTyCon c)) = c
  
  getTyName (Typ (HsTyVar v)) = v
  getTyName (Typ (HsTyCon c)) = c
  
  
  {-
  -- Produces a nub'd list of type variable names in the list
  
  namesTyp (Typ t) = namesT namesTyp t
  namesT acct t = reverse $ accNamesT t []
      where accNamesT (HsTyVar n) ans | n `elem` ans = ans
  				    | otherwise    = n : ans
            accNamesT t           ans = accT acct t ans
  -}
  
  