anchor.diff:          Expression.Lambda<'a>(body, args |> Array.ofList)
       let inline ofArity1 (expr : Expr<'a -> 'b>) =
           toLinq<Func<'a,'b>> expr
  -    let inline ofArity1WithCollection (expr : Expr<'a -> 'b>) =
  -        toLinq<Func<'a, Collections.Generic.IEnumerable<'b>>> expr
       let inline ofArity2 (expr : Expr<'a -> 'b -> 'c>) =
           toLinq<Func<'a,'b,'c>> expr
   
  
positive.code:             let func = Lambda.ofArity1 part
              pExpr.Increment(func, inc)
  
  
  
  module Queryable =
  
      open System.Linq
  
negative.code:         /// Creates an async computation that runs a mapping function on the result of an async computation
          let map f x = x |> bind (f >> singleton)
  
      module Task =
          open System.Threading.Tasks
          let map f (t : Task<_>) = t.ContinueWith(fun (x : Task<_>) -> x.Result |> f)
  
  
  
  module Option =
      /// Creates an option from a potentially null record type
      let ofNullableRecord record =
          if (record |> box |> isNull) then None
          else Some record
  
  
  open System
  