anchor.diff:          /// Convertes a generic sequence to a sequence of seperated string
           /// use write afterwards to save to file
   
  -        static member inline toCSVwith (separator:string) (header:bool) (data:'a seq) (formatFunctionsFst: string -> 'b -> 'c -> string) (formatFunctionsRest: string -> 'b -> 'c -> string)=
  -
  -            let inline toPrettyString sep input =
  -                let o = box input
  -                match o with
  -                | :? string as s -> sprintf "%s" s
  -                | :? System.Enum as en -> string en
  -                | :? System.Collections.IEnumerable as e -> seq { for i in e do yield sprintf "%A" i } |> String.concat sep
  -                | _ -> sprintf "%A" input
  -
  -
  -            let 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
  +        static member inline toCSVwith (separator:string) (header:bool) (data:'a seq) (formatFunctionsFst: string -> 'b -> (obj -> string)) (formatFunctionsRest: string -> 'b -> (obj -> string)) (formatFunctionHeader: string -> 'b -> string -> string) =
   
               seq {
                   let dataType=typeof<'a>
   
                   if header && (Seq.length(data) > 0) then
  -                    let firstElement = Seq.head data
  +                    let (firstElement: 'a) = Seq.head data
                       let header =
                           match dataType with
                           // simple value type to string
  
positive.code:                     | 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)
                      | 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)
  
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
  