anchor.diff:              []
       
       ///Returns all features of a specific type of a GenBank file representation
  -    let getFeaturesWithType (featureType:string) (gb:Dictionary<string,GenBankItem>) =
  +    let getFeaturesWithType (featureType:string) (gb:Dictionary<string,GenBankItem<'a>>) =
           if gb.ContainsKey("FEATURES") then
               match gb.["FEATURES"] with
               |Features f ->  [for i in f do if i.Type = featureType then yield i]
  
positive.code:         ///Value of the Feature
          Value:string
          }
      
      ///create a FeatureQualifier from input c
      let createFeatureQualifier name value = {Name=name;Value=value} 
  
      ///Regular expression for parsing a feature key,value pair from a string
      let private featureRegexPattern = @"/(?<qualifierName>.+)="+  @"(?<qualifierValue>.+)"
  
      ///Regular expression for parsing a feature key,value pair that contains no value from a string
      let private featureRegexPattern2 = @"/(?<qualifierName>.+)"
  
      ///returns an key value pair for a feature from an input string. If the input string does not contain an "=" sign, the value belongs
      ///to the previous line and the function EXPLAIN THIS LATER
      let private parseFeatureQualifier (s: string) =
          if s.Contains "=" then
              match s with 
              |RegexGroups featureRegexPattern qual -> (qual.[0].["qualifierName"].Value),(qual.[0].["qualifierValue"].Value)
              |_ -> ".","."
          else
              match s with 
              |RegexGroups featureRegexPattern2 qual -> (qual.[0].["qualifierName"].Value),"."
              |_ -> ".","."
      
      ///Represents a single feature from the FEATURES section of a GenBank file. Features can contain
      ///Information about genes and gene products, as well as regions of biological significance reported in the sequence
      type Feature = {
  
negative.code:         ///Represents the lines ranking lowest in hierarchy. These lines are idented and dont have a key. This union case indicates that the 
          ///value contained belongs to the next highest ranking line in hierarchy.
          | Value of string
          
      
          ///Splits the input string at a specific position (pos) returns two substrings of it, one sarting at (start) and
          ///ending at (pos), the other starting at (pos) and containing the rest of the string
          let private subStr start pos (str:string) =
              if start+pos < str.Length then 
                  str.Substring(start,pos),(str.Substring(pos))
              else
                  str,""
          ///Returns true if the input string is idented, otherwise returns false
          let private isIdent (s:string) = s.StartsWith " " 
          ///Retursn true if the input string is empty after being trimmed of whitespace, otherwise returns false
          let private isEmpty (s:string) =
              if s.Trim() = "" then true else false
          
          ///Returns a CurrentSection depending on an input key. Returns the input currentSection if the key does not indicate that the section changes.
          let private getCurrentSection (current: CurrentSection) (key : string) =
              match key.Trim() with
  