   (should
    (equal
     (whatif--simplify '(if x y z) nil)
-    (list 'unknown '(if x y z))))
+    (list 'partial '(if x y z))))
   (should
    (equal
     (whatif--simplify '(if x y z) '((x . 42)))
-    (list 'unknown 'y))))
+    (list 'partial 'y))))
 
 (ert-deftest simplify--if-body ()
   "We should always simplify the THEN and ELSE."
   (should
    (equal
     (whatif--simplify '(if x y z) '((y . 42) (z . 41)))
-    (list 'unknown '(if x 42 41)))))
+    (list 'partial '(if x 42 41)))))
 
 (ert-deftest simplify--if-condition ()
   "We should always simplify the COND."
   (should
    (equal
     (whatif--simplify '(if (if t x a) y z) '((y . 42) (z . 41)))
-    (list 'unknown '(if x 42 41)))))
+    (list 'partial '(if x 42 41)))))
 
 (ert-deftest simplify--if-without-else ()
   (should
    (equal
     (whatif--simplify '(if t y) nil)
-    (list 'unknown 'y)))
+    (list 'partial 'y)))
   (should
    (equal
     (whatif--simplify '(if nil y) nil)

          else))
       ;; Otherwise, return an if where we have simplified as much as
       ;; we can.
       (`(unknown ,_)
        (list 'unknown
              `(if ,(cl-second cond) ,(cl-second then) ,(cl-second else))))))
    ;; Remove pointless values in progn, e.g.
    ;; (progn nil (foo) (bar)) -> (progn (foo) (bar))

                  ;; arguments to `or'.
                  (push value simple-exprs))))
             ;; If we couldn't fully evaluate it, we need to preserve it.
             (`(partial ,expr)
              (push expr simple-exprs))))
         (pcase (nreverse simple-exprs)
           (`() (list 'value nil))
           (`(,expr) (list 'partial expr))
           (`,exprs (list 'partial `(or ,@exprs)))))))
    (`(,fn . ,args)
     (if (functionp fn)
         (let ((simple-args
                (whatif--simplify-progn-body args bindings)))
           (list 'partial `(,fn ,@(mapcar #'cl-second simple-args))))
       ;; Either a function we don't know about, or a macro. We can't
       ;; simplify because we don't know which arguments are evaluated.
       (list 'partial form)))
    (_ (error "Don't know how to simplify: %s" form))))

(ert-deftest simplify--bool ()
