anchor.diff:                      defaultArg (transformer e) (e :> _)
               
                   override this.VisitBlock(expr : BlockExpression) =
  -                    let exprs' = expr.Expressions |> Seq.map this.Visit
  +                    let exprs' =  this.Visit expr.Expressions 
                       let e = Expression.Block(exprs')
                       defaultArg (transformer e) (e :> _)
   
  +                // transform
                   override this.VisitCatchBlock(expr : CatchBlock) =
                       let var    = this.Visit expr.Variable :?> ParameterExpression
                       let body   = this.Visit expr.Body
                       let filter = this.Visit expr.Filter
  -                    let e      = Expression.MakeCatchBlock(expr.Test, var, body, filter)
  -                    e
  +                    Expression.MakeCatchBlock(expr.Test, var, body, filter)
   
                   override this.VisitConditional(expr : ConditionalExpression) =
                       let ifTrue = this.Visit expr.IfTrue
  
positive.code:                     defaultArg (transformer e) (e :> _)
  
                  override this.VisitConstant(expr : ConstantExpression) =
                      let e = expr
                      defaultArg (transformer e) (e :> _)
          
          let transform (transformer : Expression -> Expression option) =
              let t = new ExpressionTransformer(transformer)
              fun (expr : Expression) -> t.Visit expr
  
negative.code: 
      module internal ExpressionTransformer =
  
          type private ExpressionTransformer (transformer : Expression -> Expression option) as self =
  
              inherit ExpressionVisitor() with
                  override this.VisitBinary(expr : BinaryExpression) =
  