+ (list cs return-type annotated))
+ (error #f "not a function"))))
+
+; returns a list (constraints type annotated)
+(define (check env x)
+ (define (make-result cs type)
+ (list cs type `(,x : ,type)))
+ ;; (display "check: ")
+ ;; (display x)
+ ;; (display "\n\t")
+ ;; (display env)
+ ;; (newline)
+ (let
+ ((res
+ (case (ast-type x)
+ ('int-literal (make-result '() 'Int))
+ ('bool-literal (make-result '() 'Bool))
+ ('string-literal (make-result '() 'String))
+ ('builtin (make-result '() (builtin-type x)))
+
+ ('if
+ (let* ((cond-type-res (check env (cadr x)))
+ (then-type-res (check env (caddr x)))
+ (else-type-res (check env (cadddr x)))
+ (then-eq-else-cs (~ (cadr then-type-res)
+ (cadr else-type-res)))
+ (cs (constraint-merge
+ (car then-type-res)
+ (constraint-merge (~ (cadr cond-type-res) 'Bool)
+ (constraint-merge (car else-type-res)
+ then-eq-else-cs))))
+ (return-type (substitute cs (cadr then-type-res)))
+ [annotated `((if ,(caddr cond-type-res)
+ ,(caddr then-type-res)
+ ,(caddr else-type-res)) : ,return-type)])
+ (list cs return-type annotated)))
+
+ ('var (make-result '() (env-lookup env x)))
+ ('let (check-let env x))
+
+
+ ('lambda
+ (let* ([new-env (env-insert env (lambda-arg x) (fresh-tvar))]
+
+ [body-type-res (check new-env (lambda-body x))]
+ [cs (car body-type-res)]
+ [subd-env (substitute-env (car body-type-res) new-env)]
+ [arg-type (env-lookup subd-env (lambda-arg x))]
+ [resolved-arg-type (substitute cs arg-type)]
+
+ [lambda-type `(abs ,resolved-arg-type ,(cadr body-type-res))]
+
+ [annotated `((lambda (,(lambda-arg x)) ,(caddr body-type-res)) : ,lambda-type)])
+
+ (list (car body-type-res) ; constraints
+ lambda-type ; type
+ annotated)))
+
+
+ ('app (check-app env x))
+ ['case
+ (let* ([expr-type-res (check env (case-expr x))]
+ [expr-type (cadr expr-type-res)]
+ [case-match-type-res (map (lambda (x) (check env x))
+ (map car (case-cases x)))]
+ [case-match-types (map cadr case-match-type-res)]
+
+ [case-expr-type-res (map (lambda (x) (check env x))
+ (map cadr (case-cases x)))]
+ [case-expr-types (map cadr case-expr-type-res)]
+
+ [case-match-equality-cs (fold-left constraint-merge '()
+ (map (lambda (t) (~ t expr-type)) case-match-types))]
+
+ [case-expr-equality-cs (fold-left constraint-merge '()
+ (map (lambda (t) (~ t (car case-expr-types)))
+ (cdr case-expr-types)))]
+
+ [resolved-type (substitute case-expr-equality-cs (car case-expr-types))]
+
+ [annotated `((case (,(case-expr x) : ,expr-type)
+ ,(map (lambda (c e et)
+ `(,c (,e : ,et)))
+ (map car (case-cases x))
+ (map cadr (case-cases x))
+ case-expr-types)) : ,resolved-type)]
+
+ [cs (fold-left constraint-merge '()
+ (append case-match-equality-cs
+ case-expr-equality-cs
+ (car expr-type-res)))])
+ (list cs resolved-type annotated))])))
+
+ ;; (display "result of ")
+ ;; (display x)
+ ;; (display ":\n\t")
+ ;; (display (pretty-type (cadr res)))
+ ;; (display "\n\t[")
+ ;; (display (pretty-constraints (car res)))
+ ;; (display "]\n")