;; DESUGAR.SCM

;;6.001 PROJECT 4: EXPLICIT-CONTINUATION EVALUATOR 


;;DESUGAR
;transform a scheme expression to one with a reduced set of special forms.
(define (desugar expr)
  (cond ((quoted? expr) expr)
	((let? expr) (desugar-let expr))
;	((let*? expr) (desugar-let* expr))
        ((assignment? expr)
	 (make-assignment (assignment-variable expr)
                          (desugar (assignment-value expr))))
	((definition? expr)
	 (make-define (definition-variable expr)
                      (desugar (definition-value expr))))
	((begin? expr)
	 (make-begin (map desugar (begin-actions expr))))
	((cond? expr)
	 (desugar-cond expr))
	((and? expr)
	 (desugar-and expr))
	((or? expr)
	 (desugar-or expr))
	((lambda? expr)
	 (make-lambda (lambda-parameters expr)
		      (map desugar (lambda-body expr))))
	((application? expr) (desugar-application expr))
	(else expr)))

(define (make-assignment var expr)
  (list 'set! var expr))
(define (make-define var expr)
    (list 'm-define var expr))
(define (make-begin seq)
  (cons 'begin seq))


;;DESUGAR-AND
;; turn an and into some other special forms.  return false, or the last true value
;; code for you to write


;; Here are some helper functions

(define (and? expr) (tagged-list? expr 'and))
(define and-exprs cdr)
(define (make-and exprs) (cons 'and exprs))
(define (make-if pred conseq alt)
  (list 'if pred conseq alt))

;;DESUGAR-OR
;; turn an or into some other special forms.  return false, or the first true value
;; CODE FOR YOU TO WRITE -- SHOULD BE VERY SIMILAR TO AND


;; Here are some helper functions

(define (or? expr) (tagged-list? expr 'or))
(define or-exprs cdr)
(define (make-or exprs) (cons 'or exprs))


;;DESUGAR-LET
(define (desugar-let expr)
  (let ((names (let-bound-variables expr))
        (values (map desugar (let-values expr)))
        (body (map desugar (let-body expr))))
    (make-application (make-lambda names body)
		      values)))

(define (let? expr) (tagged-list? expr 'let))
(define (let-bound-variables expr) (map first (second expr)))
(define (let-values expr) (map second (second expr)))
(define (let-body expr) (cddr expr)) ;differs from lecture--body may be a sequence
(define (make-let bindings body)
  (cons 'let (cons bindings body)))
(define (make-application rator rands)
  (cons rator rands))


;;DESUGAR-LET*

;; YOU NEED TO WRITE THIS CODE

;;DESUGAR-APPLICATION
;desugar each piece of a combination
(define (desugar-application expr)
  (map desugar expr))

;prevent runaway printer cycles
;(set! *unparser-list-depth-limit* 10)
;(set! *unparser-list-breadth-limit* 20)


;; DESUGAR-COND
(define (cond? expr) (tagged-list? expr 'cond))
(define cond-clauses cdr)
(define first-cond-clause car)
(define rest-cond-clauses cdr)
(define (make-cond seq) (cons 'cond seq))

(define (desugar-cond expr)
  (let ((clauses (cond-clauses expr)))
    (if (null? clauses)
	#f
	(if (eq? (car (first-cond-clause clauses)) 'else)
	    (make-begin (cdr (first-cond-clause clauses)))
	    (make-if (car (first-cond-clause clauses))
		     (make-begin (cdr (first-cond-clause clauses)))
		     (desugar (make-cond (rest-cond-clauses clauses))))))))