anchor.diff:          |> Seq.map (fun i -> i.Key, i.Value)
           |> dict
           |> ModelParser.tryParse<'T> cultureInfo
  -    
  +
       /// <summary>
       /// Parses the request body into an object of type 'T based on the request's Content-Type header.
       /// </summary>
  
positive.code:             arrayOfObjects |> box |> Some
          else
              None
      
      /// <summary>
      /// Tries to create an instance of type 'T from a given set of data.
      /// It will try to match each property of 'T with a key from the data dictionary and parse the associated value to the value of 'T's property.
  
negative.code:         | true, Some err -> Error err
          | _   , _        -> Ok model
  
      /// Returns a value (the None union case) if the type is `Option<'T>` otherwise `None`.
      and getValueForMissingProperty (t : Type) =
          match t.IsFSharpOption() with
          | false -> None
          | true  -> Some (t.MakeNoneCase())
  
      and getValueForComplexType (cultureInfo : CultureInfo option)
                                (data        : IDictionary<string, StringValues>)
                                (strict      : bool)
                                (prop        : PropertyInfo)
                                : (obj option) =
          let lowerCasedPropName    = prop.Name.ToLowerInvariant()
          let isMaybeComplexType    = data.Keys |> Seq.exists (fun k -> k.StartsWith(lowerCasedPropName + "."))
          let isRecordType          = FSharpType.IsRecord prop.PropertyType
          let isGenericType         = prop.PropertyType.IsGenericType
          let tryResolveComplexType = isMaybeComplexType && (isRecordType || isGenericType)
  
          if tryResolveComplexType then
              let pattern = lowerCasedPropName |> Regex.Escape |> sprintf @"%s\.(\w+)"
  
              let dictData =
                  data
                  |> Seq.filter (fun item -> Regex.IsMatch(item.Key, pattern))
                  |> Seq.map (fun item ->
                      let matchedData = Regex.Match(item.Key, pattern)
                      let key = matchedData.Groups.[1].Value
                      let value = item.Value
                      key, value
                  )
                  |> Seq.fold(fun (state : Map<string, StringValues>) (key, value) ->
                      state.Add(key, value)
                  ) Map.empty
  
              match prop.PropertyType.IsFSharpOption() with
              | false ->
                  let model = Activator.CreateInstance(prop.PropertyType)
                  let res = parseModel model cultureInfo dictData strict
                  match res with
                  | Ok o    -> o |> box |> Some
                  | Error _ -> None
              | true  ->
                  let genericType = prop.PropertyType.GetGenericType()
                  let model = Activator.CreateInstance(genericType)
                  let res = parseModel model cultureInfo dictData strict
                  match res with
                  | Ok o    -> prop.PropertyType.MakeSomeCase(o) |> box |> Some
                  | Error _ -> None
  
          else
              None
  
      and getValueForArrayOfGenericType (cultureInfo : CultureInfo option)
                                        (data        : IDictionary<string, StringValues>)
                                        (strict      : bool)
  