anchor.diff:        (when (may-fall-off body) (add-type ret-tc :undefined))
         (let* ((*function-tcs* (cons arg-tcs ret-tc))
                tmp
  +             ;; The new scope list
                (sc (loop :for name :in locals :collect
                       (cond ((string= name "this") (list t nil name (tc :object)))
  +                          ;; defuns get some magic to store them as delayed functions,
  +                          ;; and to be able to keep their ftype
                             ((setf tmp (find name defuns :key #'second :test #'string=))
                              (list (list nil) (cons :function (cdr tmp)) name (tc :object)))
  +                          ;; arguments
                             ((setf tmp (position name args :test #'string=))
                              (list t nil name (nth tmp arg-tcs)))
  +                          ((string= name "arguments") (list t nil name (tc :object)))
                             (t (list nil nil name (tc ()))))))
                (env (cons sc env)))
           (dolist (stat body) (setf env (infer stat env)))
  
positive.code:     (:and a) ;; used by link-tc
      (:+ ;; the interesting effects of the + operator
       (cond ((or (eq a :string) (eq b :string)) :string)
             ((or (member a '(:string t :object))
                  (member b '(:string t :object))) t)
             ((and (eq a :integer) (eq b :integer)) :integer)
             (t :number)))
      (:either (combine-types a b))
      (:maybe-int ;; result of other numeric operations
       (if (and (eq a :integer) (or (not b) (eq b :integer))) :integer :number))))
  
  ;; 'Resolve' a type-cell, computing its final type from its current
  ;; type and its relations. Done in a second pass after inference has
  
negative.code:   ;; stricter, this terminates.
    (labels ((apply-rel (tc rel)
               (let* ((result (compute-rel (car rel) (resolve-tc (second rel))
                                           (if (third rel) (resolve-tc (third rel)) :none)))
                      (combined (combine-types result (tc-tp tc))))
                 (unless (eq combined (tc-tp tc))
                   (setf (tc-tp tc) combined)
  