anchor.diff:                  let disjoint (a : TypedVar list) (b : Set<TypedVar>) = List.forall (b.Contains >> not) a
                   let processEdge ctx (e : OutEdge) =
                       if isLocalResults locals e.Command
  -                        then
  -                            let pViewexpr = nView
  -                            let qViewexpr = (fun (viewexpr, _, _, _) -> viewexpr) <| ctx.Graph.Contents.[e.Dest]
  -                            // strip away mandatory/advisory and just look at the internal view
  -                            // (TODO: do something with the ViewExpr annotations?)
  -                            match (pViewexpr, qViewexpr) with
  -                            | InnerView pView, InnerView qView ->
  -                                let vars = unionMap iteratedGFuncVars (Multiset.toSet pView)
  -                                let cmdVars = commandResults e.Command
  -                                // TODO: Better equality?
  -                                if pView = qView && disjoint cmdVars vars
  -                                    then
  -                                        (flip runTransforms) ctx
  -                                        <| seq {
  -                                            yield RmOutEdge (node, e)
  -                                        }
  -                                    else ctx
  -                        else ctx
  +                    then
  +                        let pViewexpr = nView
  +                        let qViewexpr = (fun (viewexpr, _, _, _) -> viewexpr) <| ctx.Graph.Contents.[e.Dest]
  +                        // strip away mandatory/advisory and just look at the internal view
  +                        // (TODO: do something with the ViewExpr annotations?)
  +                        match (pViewexpr, qViewexpr) with
  +                        | InnerView pView, InnerView qView ->
  +                            let vars = unionMap iteratedGFuncVars (Multiset.toSet pView)
  +                            let cmdVars = commandResults e.Command
  +                            // TODO: Better equality?
  +                            if pView = qView && disjoint cmdVars vars
  +                            then
  +                                (flip runTransforms) ctx
  +                                <| seq {
  +                                    yield RmOutEdge (node, e)
  +                                    yield Unify (node, e.Dest, OnlyIfNoConnections)
  +                                }
  +                            else ctx
  +                    else ctx
                   Set.fold processEdge ctx outEdges
   
       /// Collapses edges {p}c{q}d{r} to {p}d{r} iff c is unobservable
  
positive.code:     /// </returns>
      let glueNames ({ Name = a } : InEdge) ({ Name = b } : OutEdge) : string =
          String.concat "__" [ a ; b ]
  
      /// <summary>
      ///     Runs a graph transformation.
  
negative.code:                               (inE.Command @ outE.Command)
              | MkEdgeBetween (src, dest, name, cmd) ->
                  mkEdgeBetween src dest name cmd
              | Unify (src, dest, mode) ->
                  match mode with
                  | MakeConnectionsCycles -> unify src dest
                  | RemoveConnections ->
                      // NB: rmEdgesBetween only removes in one direction!
                      rmEdgesBetween src dest always
                      >> Option.bind (rmEdgesBetween dest src always)
                      >> Option.bind (unify src dest)
                  | OnlyIfNoConnections ->
                      fun graph ->
                          if Seq.isEmpty (connections src dest graph)
                          then unify src dest graph
                          else Some graph
  
          let node' =
              match xform with
  