anchor.diff:                      | ty when ty = typeof<System.Enum> -> data |> Seq.map (fun x -> x.ToString())
                       // array type to string
                       | ty when ty.IsArray ->
  -                        data |> Seq.map (toPrettyString separator)
  +                        let stringFunc = 
  +                            let fstRecord = data |> Seq.head
  +                            [|formatFunctionsFst separator fstRecord; formatFunctionsRest separator fstRecord|]
  +                        data
  +                        |> Seq.mapi (fun i value ->
  +                                        if i = 0 then
  +                                            stringFunc.[0] value
  +                                        else
  +                                            stringFunc.[1] value
  +                                    )
                       | ty when ty = typeof<System.Enum> -> data |> Seq.map (fun x -> x.ToString())
                       // union type
                       | ty when FSharpType.IsUnion ty -> data |> Seq.map (fun x -> sprintf "%A" x)
  
positive.code:                             let fields = Reflection.FSharpType.GetRecordFields(dataType)
                                           |> Array.map (fun field -> FSharpValue.GetRecordField(firstElement, field), field.Name)
                              fields
                              |> Seq.map(fun (field,name) -> toPrettyHeaderString separator field name)
                              |> String.concat separator
                          // tuple type
                          | ty when FSharpType.IsTuple ty ->
  
negative.code:                         data |> Seq.map elemToStr
                       //tuple type
                      | ty when FSharpType.IsTuple ty ->
                          data |> Seq.map FSharpValue.GetTupleFields 
                          |> Seq.mapi (fun i value ->
                                          if i = 0 then
                                              (formatFunctionsFst separator value)value
                                          else
                                              (formatFunctionsRest separator value)value
                                      )
                      // objects
                      | _ ->
                          let props = dataType.GetProperties()
                                      |> List.ofArray
                          let stringFunc = 
                              let firstElememt = data |> Seq.head
                              props |> List.map ( fun prop ->
                                  prop.GetValue(firstElememt, null) )
                                  |> List.mapi (fun i value ->
                                      if i = 0 then
                                          formatFunctionsFst separator value
                                      else
                                          formatFunctionsRest separator value
                                          )
                          data |> Seq.map ( fun line ->
                                      props |> List.map ( fun prop ->
                                      prop.GetValue(line, null) ))
                                      |> Seq.map2 (fun func value ->
                                                       func value) stringFunc
  
                  yield! lines
              }
  
          static member inline toCSV (separator:string) (header:bool) (data:'a seq) =
              
              let inline toPrettyHeaderString sep input fieldName  =
                  let o = box input
                  match o with
                  | :? string       -> fieldName
                  | :? System.Enum  -> fieldName
                  | :? System.Collections.IEnumerable as e -> let count = seq {for i in e do yield i.ToString() } |> Seq.length
                                                              seq { for c = 1 to count do yield (sprintf "%s%i" fieldName c) } |> String.concat sep
                  | _               -> fieldName
  
              let inline funcPrecHead sep input =
                  let o = box input
  