anchor.diff:                          // 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
  +                        //| ty when (try ty.GetGenericTypeDefinition() = typedefof<_ list>
  +                        //           with
  +                        //           | _ -> false) ->
  +                        // list type
  +                        | ty when ty.Name = (typeof< _ list>).Name ->
  +                            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
  
positive.code:                         fieldName
                  | _               -> fieldName
          
              let valFuncs =
                  let firstElement = data |> Seq.head
                  valFunc firstElement
          
              let values =
                  data
                  |> Seq.map (fun entry ->
                      valFuncs
                      |> Seq.map (fun func -> func entry)
                      )
              let strFuncs : seq<(obj -> string)> =
                  let firstElement = values |> Seq.head
                  firstElement
                  |> Seq.map (fun x -> strFunc separator flatten x)
  
negative.code:                     values
                      |> Seq.map (fun x ->
                          let sb =
                              //apply different formatting to first element of the sequence to prevent separator as first character
                              let stringBuilder = new System.Text.StringBuilder()
                              stringBuilder.Append ((Seq.head strFuncs)(Seq.head x)) |> ignore
                              (Seq.tail x)
                              //fold over string builder to format rest of sequence with correct separator
                              |> Seq.fold2 (fun (sb: System.Text.StringBuilder) (func: obj -> string) value ->
                                  sb.AppendFormat (sprintf "%s{0}" separator, (func value))
                                  ) stringBuilder (Seq.tail strFuncs)
  