content: module OldBaseSyntax where
  import BaseSyntax
  
  -- For backwards compatibility -------------------------------------------------
  
  type E = EI HsName
  type HsField e = HsFieldI HsName e
  
  mapE :: (e1 -> e2) ->
          (p1 -> p2) ->
          (d1 -> d2) ->
          (t1 -> t2) ->
          (c1 -> c2) ->
          EI i e1 p1 d1 t1 c1 ->
          EI i e2 p2 d2 t2 c2
  mapE = mapEI id 
  
  seqE :: (Monad m,Functor m) =>
          E (m e) (m p) (m ds) (m t) (m c) ->
          m (E e p ds t c)
  seqE = seqEI . mapEI return id id id id id
  
  
  accE :: (e -> b -> b) ->
          (p -> b -> b) ->
          (d -> b -> b) ->
          (t -> b -> b) ->
          (c -> b -> b) ->
          EI i e p d t c ->
          b ->
          b
  accE = accEI (const id)
      
  type P p = PI HsName p
  
  mapP :: (p1 -> p2) ->
          PI i p1 ->
          PI i p2
  mapP = mapPI id
  
  seqP :: (Monad m,Functor m) => PI i (m p) -> m (PI i p)
  seqP = seqPI . mapPI return id
  
  type D = DI HsName
  type HsMatch = HsMatchI HsName
  type HsConDecl = HsConDeclI HsName
  
  mapD :: (e1 -> e2) ->           -- expression recursion function
          (p1 -> p2) ->           -- pattern recursion function
          (d1 -> d2) ->           -- declaration recursion function
          (t1 -> t2) ->           -- type recursion function
          (c1 -> c2) ->           -- context recursion function
          (tp1 -> tp2) ->         -- type pattern recursion function
          DI i e1 p1 d1 t1 c1 tp1 -> -- old declaration structure
          DI i e2 p2 d2 t2 c2 tp2    -- new declaration structure
  mapD = mapDI id
  
  type T t = TI HsName t
  
  type HsIdent = HsIdentI HsName
  type HsModule = HsModuleI HsName
  type HsExportSpec = HsExportSpecI HsName
  type HsImportDecl = HsImportDeclI HsName
  type HsImportSpec =  HsImportSpecI HsName
  