anchor.diff:                          fieldName
                   | _               -> fieldName
           
  +            //array of functions to extract values
               let valFuncs =
  +                //first element of data taken as sample to be "analyzed"
                   let firstElement = data |> Seq.head
                   valFunc firstElement
           
  +            //values returned by valFuncs
               let values =
                   data
                   |> Seq.map (fun entry ->
                       valFuncs
                       |> Seq.map (fun func -> func entry)
                       )
  +
  +            //array of functions to format values
               let strFuncs : seq<(obj -> string)> =
  +                //first element of values taken as sample to be "analyzed"
                   let firstElement = values |> Seq.head
                   firstElement
                   |> Seq.map (fun x -> strFunc separator flatten x)
  
positive.code:                         // array type to string
                          | ty when ty.IsArray ->
                              data |> Seq.map (fun x -> toPrettyHeaderString separator (box x) dataType.Name flatten) |> String.concat separator
                          | ty when (try ty.GetGenericTypeDefinition() = typedefof<_ list>
                                     with
                                     | _ -> false) ->
                                                      data |> Seq.map (fun x -> toPrettyHeaderString separator (box x) dataType.Name flatten) |> String.concat separator
                          // union type
                          | ty when FSharpType.IsUnion ty -> dataType.Name
                          // record type
  
negative.code:                 yield! strings
              }
  
          ///Returns an array of functions to extract the values of the given types
          static member inline valueFunction (dataEntry: 'a) =
              //giving the datatype as parameter returns an error
              let dataType = typeof<'a>
          
              match dataType with
  