anchor.diff:          toString id input
           |> String.concat "\r\n"
   
  -
  -    let prettyPrintGSE (gse:SOFT.Series.GSE) =
  -
  -        let formatSingleEntry rootIdent (s: string) =
  -            let ident = [for i in [1 .. (4*rootIdent)] do yield " "] |> String.concat ""
  -            s
  -            |> String.split ' '
  -            |> Array.chunkBySize 15
  -            |> Array.map (String.concat " ")
  -            |> Array.mapi (fun i s -> if i = 0 then s else sprintf "%s%s" ident s)
  -            |> String.concat "\r\n"
  -
  -
  -        let formatMultiEntries rootIdent (l: string list) =
  -            let ident = [for i in [1 .. (4*rootIdent)] do yield " "] |> String.concat ""
  -            l 
  -            |> List.map 
  -                (fun summary -> 
  -                    summary
  -                    |> String.split ' '
  -                    |> Array.chunkBySize 15
  -                    |> Array.map (String.concat " ")
  -                )
  -            |> Array.concat
  -            |> Array.mapi (fun i s -> if i = 0 then s else sprintf "%s%s" ident s)
  -            |> String.concat "\r\n"
  -
  -        let formatSamples rootIdent (sm : Map<string,SampleRecord>) = 
  -            let ident = [for i in [1 .. (4*rootIdent)] do yield " "] |> String.concat ""
  -            sm
  -            |> Map.toList
  -            |> List.map 
  -                (fun (k,v) ->
  -                    sprintf "%s => %s" k v.Title
  -                )
  -            |> List.mapi (fun i s -> if i = 0 then s else sprintf "%s%s" ident s)
  -            |> String.concat "\r\n"
  -
  -    
  -        let formatPlatforms rootIdent (sm : Map<string,PlatformRecord>) = 
  -            let ident = [for i in [1 .. (4*rootIdent)] do yield " "] |> String.concat ""
  -            sm
  -            |> Map.toList
  -            |> List.map 
  -                (fun (k,v) ->
  -                    sprintf "%s => %s" k v.Title
  -                )
  -            |> List.mapi (fun i s -> if i = 0 then s else sprintf "%s%s" ident s)
  -            |> String.concat "\r\n"
  -
  +    let prettyPrintSampleRecord (sample:SOFT.SampleRecord) =
  +        sprintf
  +            """
  +METADATA FOR SAMPLE RECORD %s
  +===========================%s
  +
  +Title:              %s
  +
  +Type(s):            %s
  +
  +Organism(s)         %s
  +
  +Characteristics:    %s
  +
  +Description:        %s
  +
  +(For more Metadata, access the type directly)
  +            """
  +            sample.Accession
  +            (sample.Accession           |> String.map (fun c -> '='))
  +            (sample.Title               |> SOFT.formatSingleEntry 5)
  +            (sample.Type                |> SOFT.formatSingleEntry 5)
  +            (sample.Organism            |> SOFT.formatMultiChannelEntry 5)
  +            (sample.Characteristics     |> SOFT.formatMultiChannelEntry 5)
  +            (sample.Description         |> SOFT.formatMultiEntries 5)
  +
  +    let prettyPrintSeriesRecord (series:SOFT.SeriesRecord) =
           sprintf
               """
   GEO SERIES RECORD %s
  
positive.code: 
  Type(s):        %s
  
  Platform(s):    %s
  
  Title:          %s
  
negative.code:     open BioFSharp.IO.GFF3
      open FSharpAux
      open System.Text
  
      module internal FormatHelpers =
          
              module SOFT =
  
                  let formatSingleEntry rootIdent (s: string) =
                      let ident = [for i in [1 .. (4*rootIdent)] do yield " "] |> String.concat ""
                      s
                      |> String.split ' '
                      |> Array.chunkBySize 15
                      |> Array.map (String.concat " ")
                      |> Array.mapi (fun i s -> if i = 0 then s else sprintf "%s%s" ident s)
                      |> String.concat "\r\n"
  
                  let formatMultiEntries rootIdent (l: string list) =
                      let ident = [for i in [1 .. (4*rootIdent)] do yield " "] |> String.concat ""
                      l 
                      |> List.map 
                          (fun summary -> 
                              summary
                              |> String.split ' '
                              |> Array.chunkBySize 15
                              |> Array.map (String.concat " ")
                          )
                      |> Array.concat
                      |> Array.mapi (fun i s -> if i = 0 then s else sprintf "%s%s" ident s)
                      |> String.concat "\r\n"
  
                  let formatSamples rootIdent (sm : Map<string,SampleRecord>) = 
                      let ident = [for i in [1 .. (4*rootIdent)] do yield " "] |> String.concat "" 
                      sm
                      |> Map.toList
                      |> List.map 
                          (fun (k,v) ->
                              sprintf "%s => %s" k v.Title
                          )
                      |> List.mapi (fun i s -> if i = 0 then s else sprintf "%s%s" ident s)
                      |> fun lines ->
                          if lines.Length > 15 then
                              let morelineCount = lines.Length - 15
                              [
                                  yield! lines.[0..14]
                                  sprintf "%s(...and %i more)" ident morelineCount
                              ]
                              |> String.concat "\r\n"
                          else
                              lines |> String.concat "\r\n"
      
                  let formatPlatforms rootIdent (sm : Map<string,PlatformRecord>) = 
                      let ident = [for i in [1 .. (4*rootIdent)] do yield " "] |> String.concat ""
                      sm
                      |> Map.toList
                      |> List.map 
                          (fun (k,v) ->
                              sprintf "%s => %s" k v.Title
                          )
                      |> List.mapi (fun i s -> if i = 0 then s else sprintf "%s%s" ident s)
                      |> fun lines ->
                          if lines.Length > 15 then
                              let morelineCount = lines.Length - 15
                              [
                                  yield! lines.[0..14]
                                  sprintf "%s(...and %i more)" ident morelineCount
                              ]
                              |> String.concat "\r\n"
                          else
                              lines |> String.concat "\r\n"
  
                  let formatSeries rootIdent (sm : Map<string,SeriesRecord>) = 
                      let ident = [for i in [1 .. (4*rootIdent)] do yield " "] |> String.concat ""
                      sm
                      |> Map.toList
                      |> List.map 
                          (fun (k,v) ->
                              sprintf "%s => %s" k v.Title
                          )
                      |> List.mapi (fun i s -> if i = 0 then s else sprintf "%s%s" ident s)
                      |> fun lines ->
                          if lines.Length > 15 then
                              let morelineCount = lines.Length - 15
                              [
                                  yield! lines.[0..14]
                                  sprintf "%s(...and %i more)" ident morelineCount
                              ]
                              |> String.concat "\r\n"
                          else
                              lines |> String.concat "\r\n"
  
                  let formatMultiChannelEntry rootIdent l =
                  l 
                  |> List.groupBy fst 
                  |> List.map (fun (i,c) -> (sprintf "[CHANNEL %i]\r\n" i ) :: (c |> List.map snd)) 
                  |> List.concat 
                  |> formatMultiEntries rootIdent
  
      open FormatHelpers
  
      ///print BioItems by using symbols for AminoAcids and Nucleotides, and the name of Modifications in [brackets]
      let prettyPrintBioItem (a: 'a when 'a :> IBioItem) =
          match (a :> IBioItem) with
  