                      (map (fn [k]
                             (let [from-assigners (get from-groups k)
                                   to-assigners (get to-groups k)
+                                  template (or (first from-assigners) (first to-assigners))
                                   f (fn [show snapshot target previous-assignment]
-                                      (let [from (run-assigners show snapshot from-assigners previous-assignment)
-                                            to (run-assigners show snapshot to-assigners previous-assignment)]
+                                      (let [from (with-default-assignment
+                                                   (run-assigners show snapshot from-assigners previous-assignment)
+                                                   template previous-assignment)
+                                            to (with-default-assignment
+                                                 (run-assigners show snapshot to-assigners previous-assignment)
+                                                 template previous-assignment)]
                                         (:value (fade-assignment from to v show snapshot))))]
-                              (map->Assigner (assoc (or (first from-assigners) (first to-assigners)) :f f))))
+                              (map->Assigner (assoc template :f f))))
                           keys)))))
              end-immediately)))

             (fn [show snapshot]
               (swap! active (fn [fx] () (filterv #(not (end % show snapshot)) fx)))
               (empty? @active)))))

(defmulti fade-between-assignments
  "Calculates an intermediate value between two attribute assignments

                                      (assign assigner show snapshot target result))
                                    previous-assignment assigners)]
             (Assignment. kind target-id target assignment))))))

(defn- with-default-assignment
  "If the current assignment is empty, but there was a previous
  assignment value, turn it into an actual assignment based on the
  supplied template."
  [assignment template previous-assignment]
  (or assignment
      (when previous-assignment (map->Assignment (assoc template :value previous-assignment)))))

(defn fade
  "Create an effect which fades between two other effects as the value
