anchor.diff:          /// column used in the data format for the schema as index
           type FieldAttribute(indexTag:FieldIndex) =
               inherit Attribute()    
  -            new (index:int)           = FieldAttribute(FieldIndex.Single (Index.Int index))
  -            new (index:string)        = FieldAttribute(FieldIndex.Single (Index.String index))    
  -            new (indices:int[])       = FieldAttribute(FieldIndex.Collection (indices |> Array.map (fun item -> Index.Int item))) 
  -            new (indices:string[])    = FieldAttribute(FieldIndex.Collection (indices |> Array.map (fun item -> Index.String item)))
  +            new (index:int)                 = FieldAttribute(FieldIndex.Single (Index.Int index))
  +            new (index:string)              = FieldAttribute(FieldIndex.Single (Index.String index))    
  +            new (indices:int[])             = FieldAttribute(FieldIndex.Collection (indices |> Array.map (fun item -> Index.Int item))) 
  +            new (indices:string[])          = FieldAttribute(FieldIndex.Collection (indices |> Array.map (fun item -> Index.String item)))
  +            new (indexFrom:int,indexTo:int) = FieldAttribute(FieldIndex.Collection ([for i=indexFrom to indexTo do yield Index.Int i]))
               member this.IndexTag = indexTag
   
    
  
positive.code:             if schemaIndexCount <> (Seq.length(words)) then failwithf "Number of columns do not match the number of attributes"       
              
              // Get value from schemaValues but failes if there is key not found exception
              let getvalue (words:SchemaValues) key = match words.TryFind(key) with
                                                      | Some(value) -> value
                                                      | None -> failwithf "No value in Column %A" key 
  
              let valueToObject schemaItem =
                  match schemaItem.Tag,schemaItem.Deserialize with
  
negative.code:                         Some(line,reader.ReadLine())) (reader.ReadLine())
                  |> Seq.skip skipLines
                  |> Seq.filter ( fun line -> not (String.IsNullOrEmpty line) )
                  |> Seq.map    ( fun line -> this.ReadLine header separator line )  
  
              /// Reads from a StreamReader and returns typed rows in a sequence according to the schema
              member this.ReadTextReader(reader:#TextReader, separator:char, firstLineHasHeader:bool, ?SkipLines:int, ?SkipLinesBeforeHeader:int) = 
                  let skipLinesBeforeHeader = (defaultArg SkipLinesBeforeHeader 0) 
                  let header' = 
                      match firstLineHasHeader with
                      | true  ->
                          for i = 1 to skipLinesBeforeHeader do reader.ReadLine() |> ignore
                          let tmpLine = reader.ReadLine()
                          if tmpLine = null then 
                              reader.Close()
                              String.Empty
                          else
                              // Convert header according to SchemaReader Index type
                              tmpLine
                      | false -> String.Empty
                  
                  this.ReadTextReader(reader, separator, header', ?SkipLines=SkipLines)
  
              /// Reads in a file and returns typed rows in a sequence according to the schema and given header string
              member this.ReadFile(file, separator:char, header:string, ?SkipLines:int) =                                   
                  let reader = File.OpenText(file)
                  this.ReadTextReader(reader,separator,header, ?SkipLines=SkipLines)
             
              /// Reads in a file and returns typed rows in a sequence according to the schema
              member this.ReadFile(file, separator:char, firstLineHasHeader:bool, ?SkipLines:int, ?SkipLinesBeforeHeader:int) =                                   
                  let reader = File.OpenText(file)
                  this.ReadTextReader(reader,separator,firstLineHasHeader, ?SkipLines=SkipLines, ?SkipLinesBeforeHeader=SkipLinesBeforeHeader)
  
              /// Reads from a string and returns typed rows in a sequence according to the schema and given header string
              member this.ReadFromString(str:string, separator:char, firstLineHasHeader:bool, ?SkipLines:int,?SkipLinesBeforeHeader:int) =
                  let reader = new StringReader(str)
                  this.ReadTextReader(reader, separator, firstLineHasHeader, ?SkipLines=SkipLines, ?SkipLinesBeforeHeader=SkipLinesBeforeHeader)
  
  
          //#endregion Csv reader
  
  