anchor.diff:  
           | _ -> failwithf "Cannot create BsonValue from %A" value
   
  -    /// Creates a BsonValue and wraps it in a bson top
  +    /// Creates a BsonValue wrapped in a BsonTop
       static member CreateValue value =
           let bson = BsonRuntime.ToBsonValue value
           BsonTop.Create(bson, "")
   
  -    /// Creates a BsonDocument and wraps it in a bson top
  +    /// Creates a BsonDocument wrapped in a BsonTop
       static member CreateDocument properties =
  -        let inline bDoc (x:seq<BsonElement>) = BsonDocument(x)
  -        let bson =
  +        let value =
               properties
               |> Array.map (fun (k, v) -> BsonElement(k, BsonRuntime.ToBsonValue v))
  -            |> bDoc
  -
  -        BsonTop.Create(bson, "")
  -
  -    /// Creates a BsonArray and wraps it in a bson top
  +            |> Array.toSeq
  +        BsonTop.Create(BsonDocument value, "")
  +
  +    /// Creates a BsonArray wrapped in a BsonTop
       static member CreateArray elements =
  -        let inline bArray (x:BsonValue[]) = BsonArray(x)
  -        let bson =
  +        let value =
               elements
               |> Array.collect (BsonRuntime.ToBsonValue >> (fun value ->
                   match value.BsonType with
                   | BsonType.Array -> Array.ofSeq value.AsBsonArray.Values
                   | BsonType.Null -> [| |]
                   | _ -> [| value |]))
  -            |> bArray
  -
  -        BsonTop.Create(bson, "")
  +        BsonTop.Create(BsonArray value, "")
  
positive.code:             else None
          | _ -> None
  
      /// Optionally get bson property and wrap it together with path
      static member TryGetPropertyUnpackedWithPath(top:IBsonTop, name) =
          { BsonOpt = BsonRuntime.TryGetPropertyUnpacked(top, name)
            Path = sprintf "%s/%s" (top.Path()) name }
  
      /// Optionally get bson property wrapped it in bson document
      static member TryGetPropertyPacked(top:IBsonTop, name) =
          BsonRuntime.TryGetPropertyUnpacked(top, name)
          |> Option.map (fun value -> top.Create(value, sprintf "/%s" name))
  
      /// Get bson property and wrap it in bson document
      static member GetPropertyPacked(top:IBsonTop, name) =
          match BsonRuntime.TryGetPropertyPacked(top, name) with
          | Some top -> top
          | None -> failwithf "Property '%s' not found at '%s': %A" name (top.Path()) top
  
      /// Get bson property and wrap it in bson document, return null if not found
      static member GetPropertyPackedOrNull(top:IBsonTop, name) =
          match BsonRuntime.TryGetPropertyPacked(top, name) with
          | Some top -> top
          | None -> top.Create(BsonNull.Value, sprintf "/%s" name)
  
      /// Optionall get bson property and convert it to the specified type
      static member ConvertOptionalProperty<'T>(top:IBsonTop, name, mapping:Func<IBsonTop,'T>) =
          BsonRuntime.TryGetPropertyPacked(top, name)
          |> Option.map mapping.Invoke
  
      static member private Matches = function
          | InferedTypeTag.Boolean -> fun (value : BsonValue) ->
              value.IsBoolean
          | InferedTypeTag.Number -> fun (value : BsonValue) ->
              value.IsInt32 || value.IsInt64 || value.IsDouble
          | InferedTypeTag.String -> fun (value : BsonValue) ->
              value.IsString
          | InferedTypeTag.DateTime -> fun (value : BsonValue) ->
              value.IsBsonDateTime
          | InferedTypeTag.Collection -> fun (value : BsonValue) ->
              value.IsBsonArray
          | InferedTypeTag.Record _ -> fun (value : BsonValue) ->
              value.IsBsonDocument
          | tag -> failwithf "%s type not supported" tag.NiceName
  
  
negative.code: 
      static member ConvertObjectId value = value |> Option.bind BsonConversions.AsObjectId
  
      /// Operation that extracts the value from an option and reports a meaningful
      /// error message when the value is not present.
      static member GetNonOptionalValue<'T>(path:string, opt:option<'T>, value:BsonValue option) : 'T =
          match opt, value with
          | Some x, _ -> x
          | None, None -> failwithf "'%s' is missing" path
          | None, Some x -> failwithf "Expecting %A at '%s', but received %A" typeof<'T> path x
  
      /// Convert BSON array to array of target types
      static member ConvertArray<'T>(top:IBsonTop, mapping:Func<IBsonTop,'T>) =
  