anchor.diff:              | Binary (op, left, right) -> emitBinary t op left right
               | Dereference expr -> emitDereference t expr
               | Unary (op, operand) -> emitUnary t op operand
  -            | Value value -> emitValue t value
  -            | VarRef var -> emitVar t var
  +            | Value value -> emitValue value
  +            | VarRef var -> emitVar var
       }
   
   let private emitBinary (t: T) (op: Operator) (left: Expression) (right: Expression): TextWorkflow.T =
  
positive.code:             | DoWhile (loop, cond) -> emitDoWhile t loop cond
              | FunctionCall expr -> emitFunctionCall t expr
              | IfThenElse (cond, trueBranch, falseBranch) -> emitIfThenElse t cond trueBranch falseBranch
              | Return var -> emitReturn t var
              | While (cond, loop) -> emitWhile t cond loop
      }
  
  
negative.code: open Type
  
  let private findRootVar (stmts: IReadOnlyList<Statement>): Var option =
      let rec findRoot =
          function
          | Assignment _ -> None
          | DoWhile (loop, _) -> loop |> Seq.tryPick findRoot
          | FunctionCall _ -> None
          | IfThenElse (_, trueBranch, falseBranch) ->
              let root = trueBranch |> Seq.tryPick findRoot
              if root.IsSome then root else falseBranch |> Seq.tryPick findRoot
          | Return var -> var
          | While (_, loop) -> loop |> Seq.tryPick findRoot
      stmts
      |> Seq.rev
      |> Seq.tryPick findRoot
  
  type private T = {
      name: string
  