anchor.diff:          yield! emitExpression t operand
       }
   
  -let private emitValue (t: T) (value: int): TextWorkflow.T =
  +let private emitValue (value: int): TextWorkflow.T =
       text {
           yield value.ToString()
       }
   
  -let private emitVar (t: T) (var: Var): TextWorkflow.T =
  +let private emitVar (var: Var): TextWorkflow.T =
       text {
           let (Var name) = var
           yield name
  
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
  