anchor.diff:                              "       let x = 1\r\n" +
                               "       let bar() = let x = x in <@ x @>\r\n";
   
  -                        NotSupportedException(message) |> raise    
  -        | DerivedPatterns.AndAlso(x1,x2)             -> Expression.AndAlso(ConvExpr env x1, ConvExpr env x2) |> asExpr
  -        | DerivedPatterns.OrElse(x1,x2)              -> Expression.OrElse(ConvExpr env x1, ConvExpr env x2)  |> asExpr
  -        | Patterns.Value(x,ty)                -> Expression.Constant(x,ty)              |> asExpr
  +                        raise <| NotSupportedException message
  +        | DerivedPatterns.AndAlso(x1,x2) -> Expression.AndAlso(ConvExpr env x1, ConvExpr env x2) |> asExpr
  +        | DerivedPatterns.OrElse(x1,x2)  -> Expression.OrElse(ConvExpr env x1, ConvExpr env x2)  |> asExpr
  +        | Patterns.Value(x,ty)           -> Expression.Constant(x,ty)                            |> asExpr
   
           // REVIEW: exact F# semantics for TypeAs and TypeIs
  -        | Patterns.Coerce(x,toTy)             -> Expression.TypeAs(ConvExpr env x,toTy)     |> asExpr
  -        | Patterns.TypeTest(x,toTy)           -> Expression.TypeIs(ConvExpr env x,toTy)     |> asExpr
  +        | Patterns.Coerce(x,toTy)             -> Expression.TypeAs(ConvExpr env x,toTy) |> asExpr
  +        | Patterns.TypeTest(x,toTy)           -> Expression.TypeIs(ConvExpr env x,toTy) |> asExpr
           
           // Expr.*Get
  -        | Patterns.FieldGet(objOpt,fieldInfo) -> 
  -            Expression.Field(ConvObjArg env objOpt None, fieldInfo) |> asExpr
  +        | Patterns.FieldGet(objOpt,fieldInfo) -> Expression.Field(ConvObjArg env objOpt None, fieldInfo) |> asExpr
   
           | Patterns.TupleGet(arg,n) -> 
                let argP = ConvExpr env arg 
  
positive.code:                                 assignState;
                                  theFuncObject |> asExpression
                              ]) |> asExpr
              else
                  let v, body = firstVar, firstBody
  
                  let vP = ConvVar v
                  let env = { env with varEnv = Map.add v (vP |> asExpression) env.varEnv }
                  let tyargs = [| v.Type; body.Type |]
                  let bodyP = ConvExpr env body
                  let convType = typedefof<System.Converter<obj,obj>>.MakeGenericType tyargs
                  let convDelegate = Expression.Lambda(convType, bodyP, [| vP |]) |> asExpression
                  Expression.Call(typeof<FuncConvert>,"ToFSharpFunc",tyargs,[| convDelegate |]) |> asExpr
      
          | Patterns.WhileLoop(condition, iteration) -> 
              let linqCondition = ConvExpr env condition
  
negative.code:     let asExpr x = AsExpression x
      let asExpression x = (x :> Expression)
  
      let getFunctionType typ = 
          let isFunctionType typ =
              let equivHeadTypes (ty1:Type) (ty2:Type) = 
                  let isNamedType (typ:Type) =
                      not (typ.IsArray || typ.IsByRef || typ.IsPointer)
      
                  isNamedType(ty1) &&
                      if ty1.IsGenericType then 
                        ty2.IsGenericType && (ty1.GetGenericTypeDefinition()).Equals(ty2.GetGenericTypeDefinition())
                      else 
                        ty1.Equals(ty2)
  
              equivHeadTypes typ (typeof<(int->int)>)
  
          if not (isFunctionType typ) then
              invalidArg "typ" "cannot convert recursion except for function types"
  
          let tyargs = typ.GetGenericArguments()
          tyargs.[0], tyargs.[1]
  
  