(define (interp expr)
  (local [(define lookup
            ;; lookup looks up a variable name in a env
            (lambda (id env)
              (type-case Env env
                [mtEnv () (error "free variable")]
                [anEnv (name value anotherEnv) (if (symbol=? id name)
                                                   value
                                                   (lookup id anotherEnv))])))
          (define sample-from-dist (get-default-sampler))

          ;; ISE Env number -> ValueXState
          ;; helper for interp
          (define interp-helper
            (lambda (expr env state)
              (type-case ISE expr
                [id (name) (vals (lookup name env) state)]
                [num (n) (vals (numV n) state)]
                [binop (op lhs rhs)
                       (local [(define result (interp-helper lhs env state))
                               (define lhsV (vals-val result))
                               (define S1 (vals-state result))]
                         (type-case ISE-Value lhsV
                           [numV (n1)
                                 (local [(define result (interp-helper rhs env S1)) ; state -> S1
                                         (define rhsV (vals-val result))
                                         (define S2 (vals-state result))]
                                   (type-case ISE-Value rhsV
                                     [numV (n2) (vals (wrapResult (op n1 n2)) S2)] ; state -> S2
                                     [rejected () (vals (rejected) 0)]
                                     [else (error "non-numerical value in binop rhs")]))]
                           [rejected () (vals (rejected) 0)]
                           [else (error "non-numerical value in binop lhs")]))]
                [ifelse (cond conseq altern)
                        (local [(define result (interp-helper cond env state))
                                (define condV (vals-val result))
                                (define S1 (vals-state result))]
                          (type-case ISE-Value condV
                            [numV (n) (if (not (= n 0))
                                          (interp-helper conseq env state)
                                          (interp-helper altern env state))]
                            [rejected () (vals (rejected) 0)]
                            [else (error "non-boolean value in ifelse test")]))]
                [fun (param body) (vals (closureV param body env) state)]
                [app (f arg)
                     (local [(define first (interp-helper f env state))
                             (define fV (vals-val first))
                             (define S1 (vals-state first))
                             (define second (interp-helper arg env S1)) ; state -> S1
                             (define argV (vals-val second))
                             (define S2 (vals-state second))]
                       (cond [(or (rejected? fV) (rejected? argV)) (vals (rejected) 0)]
                             [(not (closureV? fV)) (error 'app "Function has to be a closureV!")]
                             [else
                              (let* ([param  (closureV-param fV)]
                                     [body   (closureV-body fV)]
                                     [cEnv   (closureV-env fV)]
                                     [newEnv (anEnv param argV cEnv)])
                                (interp-helper body newEnv S2))]))] ; state -> S2
                [with (bnd body)
                      (interp-helper (app (fun (binding-name bnd) body)
                                          (binding-named-expr bnd))
                                     env
                                     state)]
                [distribution (elems)
                              (local [;; ISE Env number -> (vals (listof ISE-Value) number)
                                      ;; Evaluates a list of ISE's to a list of ISE-Value's and resulting state
                                      (define (interp-list exprs env state)
                                        (if (empty? exprs)
                                            (values empty state)
                                            (local [(define firstResult (interp-helper (first exprs) env state))
                                                    (define expr-val (vals-val firstResult))
                                                    (define expr-state (vals-state firstResult))
                                                    (define-values (rest-vals rest-state) (interp-list (rest exprs) env expr-state))]
                                              (values (cons expr-val rest-vals) state))))

                                      (define-values (elemsV S1) (interp-list elems env state))]
                                (if (or (empty? elemsV) (member (rejected) elemsV))
                                    (vals (rejected) 0)
                                    (vals (distV elemsV) state)))]
                [sample (e)
                        (local [(define result (interp-helper e env state))
                                (define v (vals-val result))
                                (define S1 (vals-state result))]
                          (type-case ISE-Value v
                            [rejected () (vals (rejected) 0)]
                            [distV (listVals)
                                   (if (empty? listVals)
                                       (error "Cannot sample empty distribution")
                                       (vals (sample-from-dist listVals) S1))] ;state -> S1
                            [else (error "Can only sample distributions")]))]
                [defquery (body) (vals (thunkV body env) state)]
                [infer (n query) (error "TODO")]
                [rec-begin (expr next)
                           (local [(define first (interp-helper expr env state))
                                   ;(define fv (vals-val first))
                                   (define fs (vals-state first))
                                   (define second (interp-helper next env fs))
                                   (define sv (vals-val second))
                                   (define ss (vals-state second))]
                             (vals second ss))]
                [observe (dist pred) (error "TODO")])))]
    ;; start with an empty env and weight of 1
    (interp-helper expr (mtEnv) 1)))