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:             | 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
      }
  
  let private emitBinary (t: T) (op: Operator) (left: Expression) (right: Expression): TextWorkflow.T =
  
negative.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 var
              | While (cond, loop) -> emitWhile t cond loop
      }
  
  