(define parse
  (let ((run
	 (compose-patterns
          (pattern-rule
	   (? 'c simple-const?)
	   (lambda (c) `(const ,c)))
          (pattern-rule
   	   `(quote ,(? 'c))
            	   (lambda (c) `(const ,c)))
          (pattern-rule
	   (? 'v var?)
	   (lambda (v) `(var ,v)))
    	  (pattern-rule
	   `(if ,(? 'test) ,(? 'dit) ,(? 'dif))
	   (lambda (test dit dif)
	     `(if3 ,(parse test) ,(parse dit) ,(parse dif))))
          (pattern-rule
	   `(if ,(? 'test) ,(? 'dit))
	   (lambda (test dit)
	     `(if3 ,(parse test) ,(parse dit) (const ,*void-object*))))
	  (pattern-rule
           `(lambda ,(? 'v) ,(? 'e) . ,(? 'es list?))
           (lambda (v e es)
             (check-lambda v
               (lambda () `(lambda-simple ,v ,(parse (beginify (cons e es)))))
               (lambda (s a) `(lambda-opt ,s ,a  ,(parse (beginify (cons e es)))))
               (lambda () `(lambda-variadic ,v ,(parse (beginify (cons e es)))))
                 )))
    	  (pattern-rule
	   `(define ,(? 'var var?) ,(? 'value))
	   (lambda (var value)
	     `(define ,(parse var) ,(parse value))))
    	  (pattern-rule
	   `(define (,(? 'var var?) . ,(? 'vars)) ,(? 'value))
	   (lambda (var vars value)
	     `(define ,(parse var) ,(parse (list 'lambda vars value)))))
        	  (pattern-rule
	   `(,(? 'var is-not-reserved?) . ,(? 'vars))
	   (lambda (var vars)
	     `(applic ,(parse var) ,(map parse vars))))
           (pattern-rule
	   `(begin . ,(? 'exprssions list?))
	   (lambda (exprssions)
           (if (not (pair? exprssions)) `(const ,*void-object*)
	                                `(seq ,(map parse exprssions)))))
        	  (pattern-rule
	   `(let ,(? 'var list?) . ,(? 'expr))
	   (lambda (var expr)
             (if (is-duplicate? (map car var)) (error 'Input "There is one or more variables with the same name")
	     (parse `((lambda ,(map car var) (,(beginify expr))) ,@(map cadr var))))))
           (pattern-rule
	   `(let* () ,(? 'expr) . ,(? 'exprs list?))
	     (lambda (expr exprs)
	      (parse (beginify (cons expr exprs)))))
	   (pattern-rule
	   `(let* ((,(? 'var var?) ,(? 'val)) . ,(? 'rest)) . ,(? 'exprs))
	     (lambda (var val rest exprs)
	      (parse `(let ((,var ,val))
		       (let* ,rest . ,exprs)))))
	   (pattern-rule
	   `(letrec . ,(? 'expr))
	     (lambda (expr)
	      (parse (expand-letrec `(letrec . ,expr)))))
          (pattern-rule
	   `(and . ,(? 'expr))
	     (lambda (expr)
               (if (null? expr) `(const #t)
                  (if (null? (cdr expr)) `,(parse (car expr))
                      (parse `(if ,(car expr) (and ,@(cdr expr)) #f))))))
          (pattern-rule
	   `(cond (else . ,(? 'rule list?)))
	     (lambda (rule)
                  (parse `,(beginify rule))))
          (pattern-rule
	   `(cond ,(? 'rule list?) . ,(? 'rules))
	     (lambda (rule rules)
                  (if (null? rules) (parse `(if ,(car rule) ,(beginify (cdr rule))))
                      (parse `(if ,(car rule) ,(beginify (cdr rule)) (cond ,@rules))))))
	  (pattern-rule
	   `(quasiquote . ,(? 'expr))
	   (lambda (expr) `,(expand-qq expr)))
    )))
    (lambda (e)
      (run e
	   (lambda ()
	     (error 'parse
		    (format "I can't recognize this: ~s" e)))))))