(package ml [ml-datatype of ,]
                                       
(define parse-ml
  ML-Rules -> (compile (fn <ml-rules>) ML-Rules))
  
(defcc <ml-rules>
  <ml-rule> , <ml-rules> := [<ml-rule> | <ml-rules>];
  <ml-rule> := [<ml-rule>];)
  
(defcc <ml-rule>                                           
  Constructor of <datatypes> := [Constructor | <datatypes>];
  <datatype> := <datatype>;)
  
(defcc <datatypes>
  <datatype> , <datatypes> := [<datatype> | <datatypes>];
  <datatype> := [<datatype>];)

(defcc <datatype>
  Datatype := Datatype where (not (= Datatype ,));)
  
(define ml->shen
  Datatype [Constructor | Datatypes] -> (let Vars (map (fn newvar) Datatypes)
                                             Conclusion (conclusion Constructor Datatype Vars)
                                             Premises (premises Vars Datatypes)
                                             (append Premises
                                                     [=============]
                                                      Conclusion))
  Datatype Instance -> [_____________________
                        Instance : Datatype;])
                        
(define conclusion
  Constructor Datatype Vars -> [(cons-form [Constructor | Vars]) : Datatype;] )                       
                       
(define premises
  [] [] -> []
  [V | Vs] [D | Ds] -> [V : D ; | (premises Vs Ds)])                         
                       
(define cons-form
  [X | Y] -> [cons (cons-form X) (cons-form Y)] 
  X -> X)                      
                       
(define newvar
  _ -> (gensym (protect X))) 
  
(defmacro ml-macro
  [ml-datatype Datatype = | ML-Rules] -> [datatype Datatype
                                        | (mapcan (/. ML-Rule (ml->shen Datatype ML-Rule)) 
                                                  (parse-ml ML-Rules))])  )