(gz start (prog))
 (gz prog (module))
 (gz module (f :class id exports imports :cbeg f topdecl-star j j
             ::pr("module [[id]] [[exports]] where{\n[[imports]]\n"
                  "[[topdecl-star('',';\n','\n')]]}\n\n")))
 (gz exports (f export-star j
              ::pr("[[export-star('(',',',')')]]")) (:export-everything ::pr("")))
 (gz export (id))
 (gz imports (f import-star j
              ::pr("[[import-star('',';\n',';\n')]]")))
 (gz import(id ::pr( "import [[id]]")))
 (gz type-class (f :type-class context-opt type f type-class-decl-star j j
                 ::pr("class [[context-opt]][[type]] where{\n"
                      "[[type-class-decl-star('',';\n','\n')]]}")))
 (gz topdecl (decl) (data)(type-synonym)(newtype)(instance)(type-class))
 (gz type-class-decl (type-signature)(decl))
 (gz type-signature (f :tysig name ret-type-and-params j
                     ::pr("[[name]]::[[ret-type-and-params]]")))
 (gz instance (f :instance (type ::is id) (name ::is simpletype)  decls j
               ::pr ("instance [[type]] ([[name]]) where [[decls]]")))
 [(gz instance (f :instance context-opt (type ::is id) simpletype-plus :x decls j
                ::pr ("instance [[context-opt]][[type]] [[simpletype-plus('(',')(',')')]] where [[decls]]")))]
 (gz newtype (f :newtype simpletype type deriving-opt j
              ::pr("newtype [[simpletype]] = [[type]][[deriving-opt]]")))
 (gz deriving (:deriving f id-non-plus j
               ::pr(" deriving [[id-non-plus('(',',',')')]]")))
 (gz id-non (id))
 (gz type-synonym (f :type-synonym simpletype type j
                   ::pr("type [[simpletype]] = [[type]]")))
 (gz data (f :data simpletype constrs deriving-opt j ::pr("data [[simpletype]] = [[constrs]][[deriving-opt]]")))
 (gz simpletype (f id-non-plus j ::pr ("[[id-non-plus('',' ','')]]")))
 (gz constrs(f constr-star j ::pr("[[constr-star('',' | ','')]]"))

  )
 (gz field-type-and-param (f param type j
                           ::pr("[[param]]::[[type]]")))
 (gz type-and-param ( f param type j ::pr("[[type]]")))
 (gz constr(positional-constructor) (field-label-constructor) )
 (gz field-label-constructor(f type-ctor :field f field-type-and-param-star j j
                             ::pr("[[type-ctor]][[field-type-and-param-star('{',',','}')]]")))

 (gz decls (  decl-star  ::pr("{[[decl-star('\n',';\n','\n')]]}\n")))
 (gz context (:context f a-context-plus j ::pr
              ("[[a-context-plus('(',',',')')]]=>")))
 (gz a-context (f (type ::is id)(name ::is id) j ::pr("[[type]] [[name]]")))
 (gz ret-type-and-params
  (context-opt type f type-and-param-star j
   ::pr("[[context-opt]][[type-and-param-star('','\x2d>','')]]"
        (::c "if(my_type_and_param_star->v.size()>0)out('\x2d>');")
        "[[type]]")))

 (gz decl (f :fun name ret-type-and-params  expr j
           ::pr("[[name]]::[[ret-type-and-params]];\n"
                "[[name]]"
                (::c "for(many_trees::const_iterator pos = my_ret_type_and_params->my_type_and_param_star->v.begin();pos!= my_ret_type_and_params->my_type_and_param_star->v.end();++pos){"
                 "const tr_type_and_param* t=dynamic_cast<const tr_type_and_param*>(*pos);"
                 "assert(t);"
                 "out(' ');"
                 "t->my_param->print();" "}")
                " = [[expr]]"))
  (f :fun name :no-sig ret-type-and-params  expr j
   ::pr("[[name]]"
        (::c "for(many_trees::const_iterator pos = my_ret_type_and_params->my_type_and_param_star->v.begin();pos!= my_ret_type_and_params->my_type_and_param_star->v.end();++pos){"
         "const tr_type_and_param* t=dynamic_cast<const tr_type_and_param*>(*pos);"
         "assert(t);"
         "out(' ');"
         "t->my_param->print();" "}")
        " = [[expr]]")))
 (gz name (id))
 (gz positional-constructor
  (f   type-ctor typepls-opt j
   ::pr("[[type-ctor]][[typepls-opt]]"))
  (f :tuple type-plus j
   ::pr("[[type-plus('(',',',')')]]"))
  )
 (gz pattern
  (f  pattern-ctor pattern-star j
   ::pr ("([[pattern-ctor]][[pattern-star('',' ','')]])"))
  
  (f pattern-ctor :fpat f fpat-star j j
   ::pr ("[[pattern-ctor]][[fpat-star('{',',','}')]]"))
   
  (f :ptuple pattern-plus j [pattern-plus cuz :nil exists for empty lists]
   ::pr("[[pattern-plus('(',',',')')]]"))
  
  (f :plist pattern-plus j [pattern-plus cuz :nil exists for empty lists]
   ::pr("[[pattern-plus('\x5b',',','\x5d')]]"))
  
  (f :pchar astring j ::pr("(\x27[[astring]]\x27)"))

  (f :pstring astring j ::pr("\x22[[astring]]\x22"))
  
  (f :as id pattern j ::pr("[[id]]@[[pattern]]"))
  )
 (gz pattern-ctor (id) (:cons ::pr ("(:)")) (:nil ::pr ("[]")))

 (gz fpat (f (variable ::is id) pattern j
           ::pr("[[variable]] = [[pattern]]")))

 (gz type
  (f :fn ret-type-and-params j ::pr ("([[ret-type-and-params]])")) (:unit ::pr("()"))
  (positional-constructor))
 (gz typepls (paren-type-plus))
 (gz paren-type (type ::pr( "([[type]])"))
  (f :strict type j ::pr("!([[type]])"))
  (f :generic id j ::pr (" [[id]] ")))
 (gz type-ctor(id)(:list ::pr ("[]"))(:nondet ::pr ("[]")))
 (gz param (id))
 (gz qastring  (astring ::pr("\x22[[astring]]\x22")))

 (gz expr (id) (:mcons ::pr ("(:)")) [(:nil ::pr ("[]"))]
  (f :pipe expr-star j ::pr[("[[expr-star('(',' $ ',')')]]")]
   (
    (::c "for(many_trees::const_iterator pos = my_expr_star->v.begin();"
     "pos!=my_expr_star->v.end();++pos){")
    "("
    (::c "(*pos)->print();" "}")
    (::c "for(many_trees::const_iterator pos = my_expr_star->v.begin();"
     "pos!=my_expr_star->v.end();++pos){")
    ")"
    (::c  "}")
    )
   )
  (f :cc expr-star j ::pr ("[[expr-star('(',' ++ ',')')]]"))
  (qastring)
  (f :lit astring j ::pr("[[astring]]"))
  
  (f :ty type expr j ::pr("([[expr]]::[[type]])"))
  (f (fun-name ::is expr) expr-star j
   ::pr ("([[fun-name]][[expr-star(' ',' ','')]])"))
  [(f :construct ctor expr-star j
    ::pr ("([[ctor]] [[expr-star('',' ','')]])"))]
  (f :do  stmt-star  j ::pr("(do{\n[[stmt-star('  ','\n  ','\n')]]})"))
  (f :case expr  alt-star  j
   ::pr("(case [[expr]] of {\n[[alt-star('  ',';\n  ','\n')]]})"))
  
  (f :where expr decl-star j
   ::pr("(let {[[decl-star('\n',';\n','\n')]]}\n in [[expr]])"))
  (f :cfd (type ::is id) assignments-star j
   ::pr("[[type]][[assignments-star('{',',','}')]]"))
  [(f :compose (a ::is expr) (b ::is expr) j ::pr("((.)[[a]] [[b]])"))]
  [(:compose ::pr ("(.)"))]
  (f :compose expr-plus j ::pr ("[[expr-plus('(',' . ',')')]]"))
  (f :mlist expr-star j ::pr("[[expr-star('\x5b',',','\x5d')]]"))
  (f :cons-list expr-star j ::pr("[[expr-star('(',':',')')]]"))
  (f :mtuple expr-star j ::pr("[[expr-star('(',',',')')]]"))
  (:nothing  ::pr ("()"))

  )
 (gz assignments (f id expr j ::pr("[[id]] = [[expr]]")))
 (gz stmt (expr ::pr("[[expr]];"))
  (f ":=" id expr j ::pr("[[id]]<-[[expr]];")))
 (gz alt (f  pattern expr j
          ::pr("[[pattern]]\x2d>[[expr]]")))