CSV reader

I've modified the CSV sample from Expert F# to my needs. I don't wann be forced to use the csv schema as defined by column rows. Therefore I've done two major modifications. 1. remove the permutation 2. added a new column name option to the ColumnAttribute 3. added a name to csv index mapping So basically you now have 3 options. 1. Don't annotate your record at all and use it as POCO. The order of the record fields is mapped directly to the order in the csv. UPDATE: I don't recommend this any more. As of the writing of this snippet I wasn't aware of the fact, that field order isn't guaranted by the reflection mechanism. 2. Use the index option of the ColumnAttribute. Same as before. 3. Use the name option. This is what I've looked for. I've to deal with tons of csv that has more columns I'm interested in. Have a look at the sample usage below. I've moved the type conversion out of the CsvReader class in order to be easyly expandable with custom type conversation (i.e. for combined column values - denormalized data)

  1: module Csv
  2: 
  3: open System
  4: open System.IO
  5: open System.Reflection
  6: open Microsoft.FSharp.Reflection
  7: 
  8: type ColumnAttribute(index:int option,name:string option) =     
  9:     inherit Attribute()     
 10:     let mutable index = index
 11:     let mutable name = name
 12:     new () = ColumnAttribute (None, None)
 13:     member x.Index          
 14:         with get() = match index with | Some i -> i | None -> -1
 15:         and set value = index <- Some value         
 16:     member x.Name          
 17:         with get() = match name with | Some n -> n | None -> ""
 18:         and set value = name <- Some value     
 19: 
 20: type CsvReader<'a>(typeConverter:Type -> (string -> obj)) = 
 21:     let mutable header = Map.empty
 22:     let recordType = typeof<'a>  
 23:     let fields = FSharpType.GetRecordFields(recordType)
 24:     let objectBuilder = FSharpValue.PreComputeRecordConstructor(recordType)
 25:     let split (delim:char) (line:string) = 
 26:        line.Split([|delim|]) |> Array.map( fun s -> s.Trim())
 27: 
 28:     member x.CreateRecord(header:Map<string,int>, delim, line) = 
 29:         let lookupFromHeader (column:ColumnAttribute) = 
 30:             match column.Name with
 31:             | name when name <> String.Empty ->
 32:                 try
 33:                     Some header.[name]
 34:                 with e -> failwithf "no"  
 35:             | _ -> None
 36:              
 37:         let schema = fields |> Array.mapi( fun fieldIndex field -> 
 38:             let propertyInfo = recordType.GetProperty(field.Name)
 39:             let deserializeColumnData = typeConverter field.PropertyType
 40:             let columnIndex = 
 41:                 match propertyInfo.GetCustomAttributes(typeof<ColumnAttribute>,false) with
 42:                 | [| (:? ColumnAttribute as col) |] -> 
 43:                     match col.Index with
 44:                     | i when i >= 0 -> i 
 45:                     | _ -> 
 46:                         match lookupFromHeader col with
 47:                         | Some(i) -> i
 48:                         | None -> fieldIndex 
 49:                 | _ -> fieldIndex
 50:                 
 51:             (fieldIndex, field.Name, columnIndex, deserializeColumnData) )
 52:         
 53:         let fieldContentFromSchema (words:string[]) = 
 54:             let deserializedData = 
 55:                 schema 
 56:                 |> Array.map( fun (fieldIndex, fieldName, columnIndex, deserializeColumnData) -> 
 57:                         deserializeColumnData words.[columnIndex])
 58:             deserializedData
 59: 
 60:         let words = line |> split delim |> fieldContentFromSchema
 61:         let convertColumn colText (fieldName, deserializeColumnData) =
 62:             try deserializeColumnData colText
 63:             with e ->
 64:                 failwithf "error converting '%s' to field '%s'" colText fieldName
 65: 
 66:         let obj = objectBuilder(words)
 67:         unbox<'a>(obj)
 68:     
 69:     member x.ReadFile(file, separator:char, firstLineHasHeader:bool) = 
 70:         seq { 
 71:             use textReader = File.OpenText(file)
 72:             if firstLineHasHeader then
 73:                 header <-
 74:                     textReader.ReadLine() 
 75:                     |> split separator
 76:                     |> Array.filter (fun name -> not (String.IsNullOrWhiteSpace name))
 77:                     |> Array.mapi (fun i name -> (name, i))
 78:                     |> Map.ofArray
 79:             while not textReader.EndOfStream do
 80:                 let line = textReader.ReadLine()
 81:                 if not (String.IsNullOrEmpty line) then
 82:                     yield x.CreateRecord(header, separator, line)
 83:         }
 84: 
 85: 
 86: //Examples:
 87: //the csv-header is mandatory for this case!
 88: type Substance = {
 89:     [<Column(Name="subst id")>] Id : int 
 90:     [<Column(Name="name")>] Name : string
 91:     [<Column(Name="sequence")>] Sequence : string
 92: }
 93: 
 94: // a one-to-one mapping to the column names
 95: // UPDATE: Dont' use this any more. As of the writing of this snippet I wasn't aware of the fact, that field order isn't guaranted by the reflection mechanism.
 96: type Probe = {
 97:     Name : string
 98:     Mismatches : int
 99:     Feature : string
100:     HitLocation : string
101:     Strain : string
102: } 
103: 
104: //0 based index mapping 
105: type ProbeAlt = {
106:     [<Column(Index=4)>]Strain : string
107:     [<Column(Index=0)>]Name : string
108: }
109: 
110: //read the csv
111: let typeConverter _type =
112:     match _type with
113:     | t when t = typeof<float>    -> (System.Double.Parse >> box)
114:     | t when t = typeof<int>      -> (System.Int32.Parse >> box)
115:     | t when t = typeof<string>   -> (fun(s:string) -> box s)
116:     | t when t = typeof<bool>     -> (System.Boolean.Parse >> box)
117:     | t -> failwithf "Unknown type %A" t
118: 
119: let path = "" //....
120: let reader = new CsvReader<Probe>(typeConverter)
121: let hasHeader = true
122: let separator = '\t'
123: let probes = reader.ReadFile(path, separator, hasHeader)

module Csv

namespace System

namespace System.IO

namespace System.Reflection

namespace Microsoft

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Reflection

type ColumnAttribute =
  class
    inherit Attribute
    new : unit -> ColumnAttribute
    new : index:int option * name:string option -> ColumnAttribute
    member Index : int
    member Name : string
    member Index : int with set
    member Name : string with set
  end

Full name: Csv.ColumnAttribute

  type: ColumnAttribute
  implements: Runtime.InteropServices._Attribute
  inherits: Attribute

val index : int option

  type: int option
  implements: Collections.IStructuralEquatable
  implements: IComparable<Option<int>>
  implements: IComparable
  implements: Collections.IStructuralComparable

Multiple items
val int : 'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------

type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

  type: int<'Measure>
  implements: IComparable
  implements: IConvertible
  implements: IFormattable
  implements: IComparable<int<'Measure>>
  implements: IEquatable<int<'Measure>>
  inherits: ValueType

--------------------

type int = int32

Full name: Microsoft.FSharp.Core.int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

type 'T option = Option<'T>

Full name: Microsoft.FSharp.Core.option<_>

  type: 'T option
  implements: Collections.IStructuralEquatable
  implements: IComparable<Option<'T>>
  implements: IComparable
  implements: Collections.IStructuralComparable

val name : string option

  type: string option
  implements: Collections.IStructuralEquatable
  implements: IComparable<Option<string>>
  implements: IComparable
  implements: Collections.IStructuralComparable

Multiple items
val string : 'T -> string

Full name: Microsoft.FSharp.Core.Operators.string

--------------------

type string = String

Full name: Microsoft.FSharp.Core.string

  type: string
  implements: IComparable
  implements: ICloneable
  implements: IConvertible
  implements: IComparable<string>
  implements: seq<char>
  implements: Collections.IEnumerable
  implements: IEquatable<string>

type Attribute =
  class
    member Equals : obj -> bool
    member GetHashCode : unit -> int
    member IsDefaultAttribute : unit -> bool
    member Match : obj -> bool
    member TypeId : obj
    static member GetCustomAttribute : System.Reflection.MemberInfo * System.Type -> System.Attribute
    static member GetCustomAttribute : System.Reflection.ParameterInfo * System.Type -> System.Attribute
    static member GetCustomAttribute : System.Reflection.Module * System.Type -> System.Attribute
    static member GetCustomAttribute : System.Reflection.Assembly * System.Type -> System.Attribute
    static member GetCustomAttribute : System.Reflection.MemberInfo * System.Type * bool -> System.Attribute
    static member GetCustomAttribute : System.Reflection.ParameterInfo * System.Type * bool -> System.Attribute
    static member GetCustomAttribute : System.Reflection.Module * System.Type * bool -> System.Attribute
    static member GetCustomAttribute : System.Reflection.Assembly * System.Type * bool -> System.Attribute
    static member GetCustomAttributes : System.Reflection.MemberInfo -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.ParameterInfo -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.Module -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.Assembly -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.MemberInfo * System.Type -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.MemberInfo * bool -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.ParameterInfo * System.Type -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.ParameterInfo * bool -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.Module * System.Type -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.Module * bool -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.Assembly * System.Type -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.Assembly * bool -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.MemberInfo * System.Type * bool -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.ParameterInfo * System.Type * bool -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.Module * System.Type * bool -> System.Attribute []
    static member GetCustomAttributes : System.Reflection.Assembly * System.Type * bool -> System.Attribute []
    static member IsDefined : System.Reflection.MemberInfo * System.Type -> bool
    static member IsDefined : System.Reflection.ParameterInfo * System.Type -> bool
    static member IsDefined : System.Reflection.Module * System.Type -> bool
    static member IsDefined : System.Reflection.Assembly * System.Type -> bool
    static member IsDefined : System.Reflection.MemberInfo * System.Type * bool -> bool
    static member IsDefined : System.Reflection.ParameterInfo * System.Type * bool -> bool
    static member IsDefined : System.Reflection.Module * System.Type * bool -> bool
    static member IsDefined : System.Reflection.Assembly * System.Type * bool -> bool
  end

Full name: System.Attribute

  type: Attribute
  implements: Runtime.InteropServices._Attribute

val mutable index : int option

  type: int option
  implements: Collections.IStructuralEquatable
  implements: IComparable<Option<int>>
  implements: IComparable
  implements: Collections.IStructuralComparable

val mutable name : string option

  type: string option
  implements: Collections.IStructuralEquatable
  implements: IComparable<Option<string>>
  implements: IComparable
  implements: Collections.IStructuralComparable

union case Option.None: Option<'T>

Multiple items
val x : ColumnAttribute

  type: ColumnAttribute
  implements: Runtime.InteropServices._Attribute
  inherits: Attribute

--------------------

val x : ColumnAttribute

  type: ColumnAttribute
  implements: Runtime.InteropServices._Attribute
  inherits: Attribute

property ColumnAttribute.Index: int

union case Option.Some: 'T -> Option<'T>

val i : int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

val set : seq<'T> -> Set<'T> (requires comparison)

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.set

val value : int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

property ColumnAttribute.Name: string

val n : string

  type: string
  implements: IComparable
  implements: ICloneable
  implements: IConvertible
  implements: IComparable<string>
  implements: seq<char>
  implements: Collections.IEnumerable
  implements: IEquatable<string>

val value : string

  type: string
  implements: IComparable
  implements: ICloneable
  implements: IConvertible
  implements: IComparable<string>
  implements: seq<char>
  implements: Collections.IEnumerable
  implements: IEquatable<string>

type CsvReader<'a> =
  class
    new : typeConverter:(Type -> string -> obj) -> CsvReader<'a>
    member CreateRecord : header:Map<string,int> * delim:char * line:string -> 'a
    member ReadFile : file:string * separator:char * firstLineHasHeader:bool -> seq<'a>
  end

Full name: Csv.CsvReader<_>

val typeConverter : (Type -> string -> obj)

type Type =
  class
    inherit System.Reflection.MemberInfo
    member Assembly : System.Reflection.Assembly
    member AssemblyQualifiedName : string
    member Attributes : System.Reflection.TypeAttributes
    member BaseType : System.Type
    member ContainsGenericParameters : bool
    member DeclaringMethod : System.Reflection.MethodBase
    member DeclaringType : System.Type
    member Equals : obj -> bool
    member Equals : System.Type -> bool
    member FindInterfaces : System.Reflection.TypeFilter * obj -> System.Type []
    member FindMembers : System.Reflection.MemberTypes * System.Reflection.BindingFlags * System.Reflection.MemberFilter * obj -> System.Reflection.MemberInfo []
    member FullName : string
    member GUID : System.Guid
    member GenericParameterAttributes : System.Reflection.GenericParameterAttributes
    member GenericParameterPosition : int
    member GetArrayRank : unit -> int
    member GetConstructor : System.Type [] -> System.Reflection.ConstructorInfo
    member GetConstructor : System.Reflection.BindingFlags * System.Reflection.Binder * System.Type [] * System.Reflection.ParameterModifier [] -> System.Reflection.ConstructorInfo
    member GetConstructor : System.Reflection.BindingFlags * System.Reflection.Binder * System.Reflection.CallingConventions * System.Type [] * System.Reflection.ParameterModifier [] -> System.Reflection.ConstructorInfo
    member GetConstructors : unit -> System.Reflection.ConstructorInfo []
    member GetConstructors : System.Reflection.BindingFlags -> System.Reflection.ConstructorInfo []
    member GetDefaultMembers : unit -> System.Reflection.MemberInfo []
    member GetElementType : unit -> System.Type
    member GetEnumName : obj -> string
    member GetEnumNames : unit -> string []
    member GetEnumUnderlyingType : unit -> System.Type
    member GetEnumValues : unit -> System.Array
    member GetEvent : string -> System.Reflection.EventInfo
    member GetEvent : string * System.Reflection.BindingFlags -> System.Reflection.EventInfo
    member GetEvents : unit -> System.Reflection.EventInfo []
    member GetEvents : System.Reflection.BindingFlags -> System.Reflection.EventInfo []
    member GetField : string -> System.Reflection.FieldInfo
    member GetField : string * System.Reflection.BindingFlags -> System.Reflection.FieldInfo
    member GetFields : unit -> System.Reflection.FieldInfo []
    member GetFields : System.Reflection.BindingFlags -> System.Reflection.FieldInfo []
    member GetGenericArguments : unit -> System.Type []
    member GetGenericParameterConstraints : unit -> System.Type []
    member GetGenericTypeDefinition : unit -> System.Type
    member GetHashCode : unit -> int
    member GetInterface : string -> System.Type
    member GetInterface : string * bool -> System.Type
    member GetInterfaceMap : System.Type -> System.Reflection.InterfaceMapping
    member GetInterfaces : unit -> System.Type []
    member GetMember : string -> System.Reflection.MemberInfo []
    member GetMember : string * System.Reflection.BindingFlags -> System.Reflection.MemberInfo []
    member GetMember : string * System.Reflection.MemberTypes * System.Reflection.BindingFlags -> System.Reflection.MemberInfo []
    member GetMembers : unit -> System.Reflection.MemberInfo []
    member GetMembers : System.Reflection.BindingFlags -> System.Reflection.MemberInfo []
    member GetMethod : string -> System.Reflection.MethodInfo
    member GetMethod : string * System.Type [] -> System.Reflection.MethodInfo
    member GetMethod : string * System.Reflection.BindingFlags -> System.Reflection.MethodInfo
    member GetMethod : string * System.Type [] * System.Reflection.ParameterModifier [] -> System.Reflection.MethodInfo
    member GetMethod : string * System.Reflection.BindingFlags * System.Reflection.Binder * System.Type [] * System.Reflection.ParameterModifier [] -> System.Reflection.MethodInfo
    member GetMethod : string * System.Reflection.BindingFlags * System.Reflection.Binder * System.Reflection.CallingConventions * System.Type [] * System.Reflection.ParameterModifier [] -> System.Reflection.MethodInfo
    member GetMethods : unit -> System.Reflection.MethodInfo []
    member GetMethods : System.Reflection.BindingFlags -> System.Reflection.MethodInfo []
    member GetNestedType : string -> System.Type
    member GetNestedType : string * System.Reflection.BindingFlags -> System.Type
    member GetNestedTypes : unit -> System.Type []
    member GetNestedTypes : System.Reflection.BindingFlags -> System.Type []
    member GetProperties : unit -> System.Reflection.PropertyInfo []
    member GetProperties : System.Reflection.BindingFlags -> System.Reflection.PropertyInfo []
    member GetProperty : string -> System.Reflection.PropertyInfo
    member GetProperty : string * System.Reflection.BindingFlags -> System.Reflection.PropertyInfo
    member GetProperty : string * System.Type [] -> System.Reflection.PropertyInfo
    member GetProperty : string * System.Type -> System.Reflection.PropertyInfo
    member GetProperty : string * System.Type * System.Type [] -> System.Reflection.PropertyInfo
    member GetProperty : string * System.Type * System.Type [] * System.Reflection.ParameterModifier [] -> System.Reflection.PropertyInfo
    member GetProperty : string * System.Reflection.BindingFlags * System.Reflection.Binder * System.Type * System.Type [] * System.Reflection.ParameterModifier [] -> System.Reflection.PropertyInfo
    member GetType : unit -> System.Type
    member HasElementType : bool
    member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj [] -> obj
    member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj [] * System.Globalization.CultureInfo -> obj
    member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj [] * System.Reflection.ParameterModifier [] * System.Globalization.CultureInfo * string [] -> obj
    member IsAbstract : bool
    member IsAnsiClass : bool
    member IsArray : bool
    member IsAssignableFrom : System.Type -> bool
    member IsAutoClass : bool
    member IsAutoLayout : bool
    member IsByRef : bool
    member IsCOMObject : bool
    member IsClass : bool
    member IsContextful : bool
    member IsEnum : bool
    member IsEnumDefined : obj -> bool
    member IsEquivalentTo : System.Type -> bool
    member IsExplicitLayout : bool
    member IsGenericParameter : bool
    member IsGenericType : bool
    member IsGenericTypeDefinition : bool
    member IsImport : bool
    member IsInstanceOfType : obj -> bool
    member IsInterface : bool
    member IsLayoutSequential : bool
    member IsMarshalByRef : bool
    member IsNested : bool
    member IsNestedAssembly : bool
    member IsNestedFamANDAssem : bool
    member IsNestedFamORAssem : bool
    member IsNestedFamily : bool
    member IsNestedPrivate : bool
    member IsNestedPublic : bool
    member IsNotPublic : bool
    member IsPointer : bool
    member IsPrimitive : bool
    member IsPublic : bool
    member IsSealed : bool
    member IsSecurityCritical : bool
    member IsSecuritySafeCritical : bool
    member IsSecurityTransparent : bool
    member IsSerializable : bool
    member IsSpecialName : bool
    member IsSubclassOf : System.Type -> bool
    member IsUnicodeClass : bool
    member IsValueType : bool
    member IsVisible : bool
    member MakeArrayType : unit -> System.Type
    member MakeArrayType : int -> System.Type
    member MakeByRefType : unit -> System.Type
    member MakeGenericType : System.Type [] -> System.Type
    member MakePointerType : unit -> System.Type
    member MemberType : System.Reflection.MemberTypes
    member Module : System.Reflection.Module
    member Namespace : string
    member ReflectedType : System.Type
    member StructLayoutAttribute : System.Runtime.InteropServices.StructLayoutAttribute
    member ToString : unit -> string
    member TypeHandle : System.RuntimeTypeHandle
    member TypeInitializer : System.Reflection.ConstructorInfo
    member UnderlyingSystemType : System.Type
    static val FilterAttribute : System.Reflection.MemberFilter
    static val FilterName : System.Reflection.MemberFilter
    static val FilterNameIgnoreCase : System.Reflection.MemberFilter
    static val Missing : obj
    static val Delimiter : char
    static val EmptyTypes : System.Type []
    static member DefaultBinder : System.Reflection.Binder
    static member GetType : string -> System.Type
    static member GetType : string * bool -> System.Type
    static member GetType : string * bool * bool -> System.Type
    static member GetType : string * System.Func<System.Reflection.AssemblyName,System.Reflection.Assembly> * System.Func<System.Reflection.Assembly,string,bool,System.Type> -> System.Type
    static member GetType : string * System.Func<System.Reflection.AssemblyName,System.Reflection.Assembly> * System.Func<System.Reflection.Assembly,string,bool,System.Type> * bool -> System.Type
    static member GetType : string * System.Func<System.Reflection.AssemblyName,System.Reflection.Assembly> * System.Func<System.Reflection.Assembly,string,bool,System.Type> * bool * bool -> System.Type
    static member GetTypeArray : obj [] -> System.Type []
    static member GetTypeCode : System.Type -> System.TypeCode
    static member GetTypeFromCLSID : System.Guid -> System.Type
    static member GetTypeFromCLSID : System.Guid * bool -> System.Type
    static member GetTypeFromCLSID : System.Guid * string -> System.Type
    static member GetTypeFromCLSID : System.Guid * string * bool -> System.Type
    static member GetTypeFromHandle : System.RuntimeTypeHandle -> System.Type
    static member GetTypeFromProgID : string -> System.Type
    static member GetTypeFromProgID : string * bool -> System.Type
    static member GetTypeFromProgID : string * string -> System.Type
    static member GetTypeFromProgID : string * string * bool -> System.Type
    static member GetTypeHandle : obj -> System.RuntimeTypeHandle
    static member ReflectionOnlyGetType : string * bool * bool -> System.Type
  end

Full name: System.Type

  type: Type
  implements: ICustomAttributeProvider
  implements: Runtime.InteropServices._MemberInfo
  implements: Runtime.InteropServices._Type
  implements: IReflect
  inherits: MemberInfo

type obj = Object

Full name: Microsoft.FSharp.Core.obj

val mutable header : Map<string,int>

  type: Map<string,int>
  implements: IComparable
  implements: Collections.Generic.IDictionary<string,int>
  implements: Collections.Generic.ICollection<Collections.Generic.KeyValuePair<string,int>>
  implements: seq<Collections.Generic.KeyValuePair<string,int>>
  implements: Collections.IEnumerable

Multiple items
module Map

from Microsoft.FSharp.Collections

--------------------

type Map<'Key,'Value (requires comparison)> =
  class
    interface Collections.IEnumerable
    interface IComparable
    interface Collections.Generic.IEnumerable<Collections.Generic.KeyValuePair<'Key,'Value>>
    interface Collections.Generic.ICollection<Collections.Generic.KeyValuePair<'Key,'Value>>
    interface Collections.Generic.IDictionary<'Key,'Value>
    new : elements:seq<'Key * 'Value> -> Map<'Key,'Value>
    member Add : key:'Key * value:'Value -> Map<'Key,'Value>
    member ContainsKey : key:'Key -> bool
    override Equals : obj -> bool
    member Remove : key:'Key -> Map<'Key,'Value>
    member TryFind : key:'Key -> 'Value option
    member Count : int
    member IsEmpty : bool
    member Item : key:'Key -> 'Value with get
  end

Full name: Microsoft.FSharp.Collections.Map<_,_>

  type: Map<'Key,'Value>
  implements: IComparable
  implements: Collections.Generic.IDictionary<'Key,'Value>
  implements: Collections.Generic.ICollection<Collections.Generic.KeyValuePair<'Key,'Value>>
  implements: seq<Collections.Generic.KeyValuePair<'Key,'Value>>
  implements: Collections.IEnumerable

val empty<'Key,'T (requires comparison)> : Map<'Key,'T> (requires comparison)

Full name: Microsoft.FSharp.Collections.Map.empty

val recordType : Type

  type: Type
  implements: ICustomAttributeProvider
  implements: Runtime.InteropServices._MemberInfo
  implements: Runtime.InteropServices._Type
  implements: IReflect
  inherits: MemberInfo

val typeof<'T> : Type

Full name: Microsoft.FSharp.Core.Operators.typeof

val fields : PropertyInfo []

  type: PropertyInfo []
  implements: ICloneable
  implements: Collections.IList
  implements: Collections.ICollection
  implements: Collections.IStructuralComparable
  implements: Collections.IStructuralEquatable
  implements: Collections.Generic.IList<PropertyInfo>
  implements: Collections.Generic.ICollection<PropertyInfo>
  implements: seq<PropertyInfo>
  implements: Collections.IEnumerable
  inherits: Array

type FSharpType =
  class
    static member GetExceptionFields : exceptionType:Type * ?bindingFlags:BindingFlags -> PropertyInfo []
    static member GetFunctionElements : functionType:Type -> Type * Type
    static member GetRecordFields : recordType:Type * ?bindingFlags:BindingFlags -> PropertyInfo []
    static member GetTupleElements : tupleType:Type -> Type []
    static member GetUnionCases : unionType:Type * ?bindingFlags:BindingFlags -> UnionCaseInfo []
    static member IsExceptionRepresentation : exceptionType:Type * ?bindingFlags:BindingFlags -> bool
    static member IsFunction : typ:Type -> bool
    static member IsModule : typ:Type -> bool
    static member IsRecord : typ:Type * ?bindingFlags:BindingFlags -> bool
    static member IsTuple : typ:Type -> bool
    static member IsUnion : typ:Type * ?bindingFlags:BindingFlags -> bool
    static member MakeFunctionType : domain:Type * range:Type -> Type
    static member MakeTupleType : types:Type [] -> Type
  end

Full name: Microsoft.FSharp.Reflection.FSharpType

static member FSharpType.GetRecordFields : recordType:Type * ?bindingFlags:BindingFlags -> PropertyInfo []

val objectBuilder : (obj [] -> obj)

type FSharpValue =
  class
    static member GetExceptionFields : exn:obj * ?bindingFlags:BindingFlags -> obj []
    static member GetRecordField : record:obj * info:PropertyInfo -> obj
    static member GetRecordFields : record:obj * ?bindingFlags:BindingFlags -> obj []
    static member GetTupleField : tuple:obj * index:int -> obj
    static member GetTupleFields : tuple:obj -> obj []
    static member GetUnionFields : value:obj * unionType:Type * ?bindingFlags:BindingFlags -> UnionCaseInfo * obj []
    static member MakeFunction : functionType:Type * implementation:(obj -> obj) -> obj
    static member MakeRecord : recordType:Type * values:obj [] * ?bindingFlags:BindingFlags -> obj
    static member MakeTuple : tupleElements:obj [] * tupleType:Type -> obj
    static member MakeUnion : unionCase:UnionCaseInfo * args:obj [] * ?bindingFlags:BindingFlags -> obj
    static member PreComputeRecordConstructor : recordType:Type * ?bindingFlags:BindingFlags -> (obj [] -> obj)
    static member PreComputeRecordConstructorInfo : recordType:Type * ?bindingFlags:BindingFlags -> ConstructorInfo
    static member PreComputeRecordFieldReader : info:PropertyInfo -> (obj -> obj)
    static member PreComputeRecordReader : recordType:Type * ?bindingFlags:BindingFlags -> (obj -> obj [])
    static member PreComputeTupleConstructor : tupleType:Type -> (obj [] -> obj)
    static member PreComputeTupleConstructorInfo : tupleType:Type -> ConstructorInfo * Type option
    static member PreComputeTuplePropertyInfo : tupleType:Type * index:int -> PropertyInfo * (Type * int) option
    static member PreComputeTupleReader : tupleType:Type -> (obj -> obj [])
    static member PreComputeUnionConstructor : unionCase:UnionCaseInfo * ?bindingFlags:BindingFlags -> (obj [] -> obj)
    static member PreComputeUnionConstructorInfo : unionCase:UnionCaseInfo * ?bindingFlags:BindingFlags -> MethodInfo
    static member PreComputeUnionReader : unionCase:UnionCaseInfo * ?bindingFlags:BindingFlags -> (obj -> obj [])
    static member PreComputeUnionTagMemberInfo : unionType:Type * ?bindingFlags:BindingFlags -> MemberInfo
    static member PreComputeUnionTagReader : unionType:Type * ?bindingFlags:BindingFlags -> (obj -> int)
  end

Full name: Microsoft.FSharp.Reflection.FSharpValue

static member FSharpValue.PreComputeRecordConstructor : recordType:Type * ?bindingFlags:BindingFlags -> (obj [] -> obj)

val split : (char -> string -> string [])

val delim : char

  type: char
  implements: IComparable
  implements: IConvertible
  implements: IComparable<char>
  implements: IEquatable<char>
  inherits: ValueType

Multiple items
val char : 'T -> char (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.char

--------------------

type char = Char

Full name: Microsoft.FSharp.Core.char

  type: char
  implements: IComparable
  implements: IConvertible
  implements: IComparable<char>
  implements: IEquatable<char>
  inherits: ValueType

val line : string

  type: string
  implements: IComparable
  implements: ICloneable
  implements: IConvertible
  implements: IComparable<string>
  implements: seq<char>
  implements: Collections.IEnumerable
  implements: IEquatable<string>

Multiple overloads
String.Split(separator: char []) : string []
String.Split(separator: string [], options: StringSplitOptions) : string []
String.Split(separator: char [], options: StringSplitOptions) : string []
String.Split(separator: char [], count: int) : string []
String.Split(separator: string [], count: int, options: StringSplitOptions) : string []
String.Split(separator: char [], count: int, options: StringSplitOptions) : string []

type Array =
  class
    member Clone : unit -> obj
    member CopyTo : System.Array * int -> unit
    member CopyTo : System.Array * int64 -> unit
    member GetEnumerator : unit -> System.Collections.IEnumerator
    member GetLength : int -> int
    member GetLongLength : int -> int64
    member GetLowerBound : int -> int
    member GetUpperBound : int -> int
    member GetValue : int [] -> obj
    member GetValue : int -> obj
    member GetValue : int64 -> obj
    member GetValue : int64 [] -> obj
    member GetValue : int * int -> obj
    member GetValue : int64 * int64 -> obj
    member GetValue : int * int * int -> obj
    member GetValue : int64 * int64 * int64 -> obj
    member Initialize : unit -> unit
    member IsFixedSize : bool
    member IsReadOnly : bool
    member IsSynchronized : bool
    member Length : int
    member LongLength : int64
    member Rank : int
    member SetValue : obj * int -> unit
    member SetValue : obj * int [] -> unit
    member SetValue : obj * int64 -> unit
    member SetValue : obj * int64 [] -> unit
    member SetValue : obj * int * int -> unit
    member SetValue : obj * int64 * int64 -> unit
    member SetValue : obj * int * int * int -> unit
    member SetValue : obj * int64 * int64 * int64 -> unit
    member SyncRoot : obj
    static member AsReadOnly<'T> : 'T [] -> System.Collections.ObjectModel.ReadOnlyCollection<'T>
    static member BinarySearch : System.Array * obj -> int
    static member BinarySearch<'T> : 'T [] * 'T -> int
    static member BinarySearch : System.Array * obj * System.Collections.IComparer -> int
    static member BinarySearch<'T> : 'T [] * 'T * System.Collections.Generic.IComparer<'T> -> int
    static member BinarySearch : System.Array * int * int * obj -> int
    static member BinarySearch<'T> : 'T [] * int * int * 'T -> int
    static member BinarySearch : System.Array * int * int * obj * System.Collections.IComparer -> int
    static member BinarySearch<'T> : 'T [] * int * int * 'T * System.Collections.Generic.IComparer<'T> -> int
    static member Clear : System.Array * int * int -> unit
    static member ConstrainedCopy : System.Array * int * System.Array * int * int -> unit
    static member ConvertAll<'TInput,'TOutput> : 'TInput [] * System.Converter<'TInput,'TOutput> -> 'TOutput []
    static member Copy : System.Array * System.Array * int -> unit
    static member Copy : System.Array * System.Array * int64 -> unit
    static member Copy : System.Array * int * System.Array * int * int -> unit
    static member Copy : System.Array * int64 * System.Array * int64 * int64 -> unit
    static member CreateInstance : System.Type * int -> System.Array
    static member CreateInstance : System.Type * int [] -> System.Array
    static member CreateInstance : System.Type * int64 [] -> System.Array
    static member CreateInstance : System.Type * int * int -> System.Array
    static member CreateInstance : System.Type * int [] * int [] -> System.Array
    static member CreateInstance : System.Type * int * int * int -> System.Array
    static member Exists<'T> : 'T [] * System.Predicate<'T> -> bool
    static member Find<'T> : 'T [] * System.Predicate<'T> -> 'T
    static member FindAll<'T> : 'T [] * System.Predicate<'T> -> 'T []
    static member FindIndex<'T> : 'T [] * System.Predicate<'T> -> int
    static member FindIndex<'T> : 'T [] * int * System.Predicate<'T> -> int
    static member FindIndex<'T> : 'T [] * int * int * System.Predicate<'T> -> int
    static member FindLast<'T> : 'T [] * System.Predicate<'T> -> 'T
    static member FindLastIndex<'T> : 'T [] * System.Predicate<'T> -> int
    static member FindLastIndex<'T> : 'T [] * int * System.Predicate<'T> -> int
    static member FindLastIndex<'T> : 'T [] * int * int * System.Predicate<'T> -> int
    static member ForEach<'T> : 'T [] * System.Action<'T> -> unit
    static member IndexOf : System.Array * obj -> int
    static member IndexOf<'T> : 'T [] * 'T -> int
    static member IndexOf : System.Array * obj * int -> int
    static member IndexOf<'T> : 'T [] * 'T * int -> int
    static member IndexOf : System.Array * obj * int * int -> int
    static member IndexOf<'T> : 'T [] * 'T * int * int -> int
    static member LastIndexOf : System.Array * obj -> int
    static member LastIndexOf<'T> : 'T [] * 'T -> int
    static member LastIndexOf : System.Array * obj * int -> int
    static member LastIndexOf<'T> : 'T [] * 'T * int -> int
    static member LastIndexOf : System.Array * obj * int * int -> int
    static member LastIndexOf<'T> : 'T [] * 'T * int * int -> int
    static member Resize<'T> : 'T [] * int -> unit
    static member Reverse : System.Array -> unit
    static member Reverse : System.Array * int * int -> unit
    static member Sort : System.Array -> unit
    static member Sort<'T> : 'T [] -> unit
    static member Sort : System.Array * System.Array -> unit
    static member Sort : System.Array * System.Collections.IComparer -> unit
    static member Sort<'TKey,'TValue> : 'TKey [] * 'TValue [] -> unit
    static member Sort<'T> : 'T [] * System.Collections.Generic.IComparer<'T> -> unit
    static member Sort<'T> : 'T [] * System.Comparison<'T> -> unit
    static member Sort : System.Array * int * int -> unit
    static member Sort : System.Array * System.Array * System.Collections.IComparer -> unit
    static member Sort<'T> : 'T [] * int * int -> unit
    static member Sort<'TKey,'TValue> : 'TKey [] * 'TValue [] * System.Collections.Generic.IComparer<'TKey> -> unit
    static member Sort : System.Array * System.Array * int * int -> unit
    static member Sort : System.Array * int * int * System.Collections.IComparer -> unit
    static member Sort<'TKey,'TValue> : 'TKey [] * 'TValue [] * int * int -> unit
    static member Sort<'T> : 'T [] * int * int * System.Collections.Generic.IComparer<'T> -> unit
    static member Sort : System.Array * System.Array * int * int * System.Collections.IComparer -> unit
    static member Sort<'TKey,'TValue> : 'TKey [] * 'TValue [] * int * int * System.Collections.Generic.IComparer<'TKey> -> unit
    static member TrueForAll<'T> : 'T [] * System.Predicate<'T> -> bool
  end

Full name: System.Array

  type: Array
  implements: ICloneable
  implements: Collections.IList
  implements: Collections.ICollection
  implements: Collections.IEnumerable
  implements: Collections.IStructuralComparable
  implements: Collections.IStructuralEquatable

val map : ('T -> 'U) -> 'T [] -> 'U []

Full name: Microsoft.FSharp.Collections.Array.map

val s : string

  type: string
  implements: IComparable
  implements: ICloneable
  implements: IConvertible
  implements: IComparable<string>
  implements: seq<char>
  implements: Collections.IEnumerable
  implements: IEquatable<string>

Multiple overloads
String.Trim() : string
String.Trim(trimChars: char []) : string

val x : CsvReader<'a>

member CsvReader.CreateRecord : header:Map<string,int> * delim:char * line:string -> 'a

Full name: Csv.CsvReader`1.CreateRecord

val header : Map<string,int>

  type: Map<string,int>
  implements: IComparable
  implements: Collections.Generic.IDictionary<string,int>
  implements: Collections.Generic.ICollection<Collections.Generic.KeyValuePair<string,int>>
  implements: seq<Collections.Generic.KeyValuePair<string,int>>
  implements: Collections.IEnumerable

val lookupFromHeader : (ColumnAttribute -> int option)

val column : ColumnAttribute

  type: ColumnAttribute
  implements: Runtime.InteropServices._Attribute
  inherits: Attribute

val name : string

  type: string
  implements: IComparable
  implements: ICloneable
  implements: IConvertible
  implements: IComparable<string>
  implements: seq<char>
  implements: Collections.IEnumerable
  implements: IEquatable<string>

type String =
  class
    new : char -> string
    new : char * int * int -> string
    new : System.SByte -> string
    new : System.SByte * int * int -> string
    new : System.SByte * int * int * System.Text.Encoding -> string
    new : char [] * int * int -> string
    new : char [] -> string
    new : char * int -> string
    member Chars : int -> char
    member Clone : unit -> obj
    member CompareTo : obj -> int
    member CompareTo : string -> int
    member Contains : string -> bool
    member CopyTo : int * char [] * int * int -> unit
    member EndsWith : string -> bool
    member EndsWith : string * System.StringComparison -> bool
    member EndsWith : string * bool * System.Globalization.CultureInfo -> bool
    member Equals : obj -> bool
    member Equals : string -> bool
    member Equals : string * System.StringComparison -> bool
    member GetEnumerator : unit -> System.CharEnumerator
    member GetHashCode : unit -> int
    member GetTypeCode : unit -> System.TypeCode
    member IndexOf : char -> int
    member IndexOf : string -> int
    member IndexOf : char * int -> int
    member IndexOf : string * int -> int
    member IndexOf : string * System.StringComparison -> int
    member IndexOf : char * int * int -> int
    member IndexOf : string * int * int -> int
    member IndexOf : string * int * System.StringComparison -> int
    member IndexOf : string * int * int * System.StringComparison -> int
    member IndexOfAny : char [] -> int
    member IndexOfAny : char [] * int -> int
    member IndexOfAny : char [] * int * int -> int
    member Insert : int * string -> string
    member IsNormalized : unit -> bool
    member IsNormalized : System.Text.NormalizationForm -> bool
    member LastIndexOf : char -> int
    member LastIndexOf : string -> int
    member LastIndexOf : char * int -> int
    member LastIndexOf : string * int -> int
    member LastIndexOf : string * System.StringComparison -> int
    member LastIndexOf : char * int * int -> int
    member LastIndexOf : string * int * int -> int
    member LastIndexOf : string * int * System.StringComparison -> int
    member LastIndexOf : string * int * int * System.StringComparison -> int
    member LastIndexOfAny : char [] -> int
    member LastIndexOfAny : char [] * int -> int
    member LastIndexOfAny : char [] * int * int -> int
    member Length : int
    member Normalize : unit -> string
    member Normalize : System.Text.NormalizationForm -> string
    member PadLeft : int -> string
    member PadLeft : int * char -> string
    member PadRight : int -> string
    member PadRight : int * char -> string
    member Remove : int -> string
    member Remove : int * int -> string
    member Replace : char * char -> string
    member Replace : string * string -> string
    member Split : char [] -> string []
    member Split : char [] * int -> string []
    member Split : char [] * System.StringSplitOptions -> string []
    member Split : string [] * System.StringSplitOptions -> string []
    member Split : char [] * int * System.StringSplitOptions -> string []
    member Split : string [] * int * System.StringSplitOptions -> string []
    member StartsWith : string -> bool
    member StartsWith : string * System.StringComparison -> bool
    member StartsWith : string * bool * System.Globalization.CultureInfo -> bool
    member Substring : int -> string
    member Substring : int * int -> string
    member ToCharArray : unit -> char []
    member ToCharArray : int * int -> char []
    member ToLower : unit -> string
    member ToLower : System.Globalization.CultureInfo -> string
    member ToLowerInvariant : unit -> string
    member ToString : unit -> string
    member ToString : System.IFormatProvider -> string
    member ToUpper : unit -> string
    member ToUpper : System.Globalization.CultureInfo -> string
    member ToUpperInvariant : unit -> string
    member Trim : unit -> string
    member Trim : char [] -> string
    member TrimEnd : char [] -> string
    member TrimStart : char [] -> string
    static val Empty : string
    static member Compare : string * string -> int
    static member Compare : string * string * bool -> int
    static member Compare : string * string * System.StringComparison -> int
    static member Compare : string * string * System.Globalization.CultureInfo * System.Globalization.CompareOptions -> int
    static member Compare : string * string * bool * System.Globalization.CultureInfo -> int
    static member Compare : string * int * string * int * int -> int
    static member Compare : string * int * string * int * int * bool -> int
    static member Compare : string * int * string * int * int * System.StringComparison -> int
    static member Compare : string * int * string * int * int * bool * System.Globalization.CultureInfo -> int
    static member Compare : string * int * string * int * int * System.Globalization.CultureInfo * System.Globalization.CompareOptions -> int
    static member CompareOrdinal : string * string -> int
    static member CompareOrdinal : string * int * string * int * int -> int
    static member Concat : obj -> string
    static member Concat : obj [] -> string
    static member Concat<'T> : System.Collections.Generic.IEnumerable<'T> -> string
    static member Concat : System.Collections.Generic.IEnumerable<string> -> string
    static member Concat : string [] -> string
    static member Concat : obj * obj -> string
    static member Concat : string * string -> string
    static member Concat : obj * obj * obj -> string
    static member Concat : string * string * string -> string
    static member Concat : obj * obj * obj * obj -> string
    static member Concat : string * string * string * string -> string
    static member Copy : string -> string
    static member Equals : string * string -> bool
    static member Equals : string * string * System.StringComparison -> bool
    static member Format : string * obj -> string
    static member Format : string * obj [] -> string
    static member Format : string * obj * obj -> string
    static member Format : System.IFormatProvider * string * obj [] -> string
    static member Format : string * obj * obj * obj -> string
    static member Intern : string -> string
    static member IsInterned : string -> string
    static member IsNullOrEmpty : string -> bool
    static member IsNullOrWhiteSpace : string -> bool
    static member Join : string * string [] -> string
    static member Join : string * obj [] -> string
    static member Join<'T> : string * System.Collections.Generic.IEnumerable<'T> -> string
    static member Join : string * System.Collections.Generic.IEnumerable<string> -> string
    static member Join : string * string [] * int * int -> string
  end

Full name: System.String

  type: String
  implements: IComparable
  implements: ICloneable
  implements: IConvertible
  implements: IComparable<string>
  implements: seq<char>
  implements: Collections.IEnumerable
  implements: IEquatable<string>

field String.Empty

Multiple items
val e : exn

  type: exn
  implements: Runtime.Serialization.ISerializable
  implements: Runtime.InteropServices._Exception

--------------------

val e : exn

  type: exn
  implements: Runtime.Serialization.ISerializable
  implements: Runtime.InteropServices._Exception

val failwithf : Printf.StringFormat<'T,'Result> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.failwithf

val schema : (int * string * int * (string -> obj)) []

  type: (int * string * int * (string -> obj)) []
  implements: ICloneable
  implements: Collections.IList
  implements: Collections.ICollection
  implements: Collections.IStructuralComparable
  implements: Collections.IStructuralEquatable
  implements: Collections.Generic.IList<int * string * int * (string -> obj)>
  implements: Collections.Generic.ICollection<int * string * int * (string -> obj)>
  implements: seq<int * string * int * (string -> obj)>
  implements: Collections.IEnumerable
  inherits: Array

val mapi : (int -> 'T -> 'U) -> 'T [] -> 'U []

Full name: Microsoft.FSharp.Collections.Array.mapi

val fieldIndex : int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

val field : PropertyInfo

  type: PropertyInfo
  implements: ICustomAttributeProvider
  implements: Runtime.InteropServices._MemberInfo
  implements: Runtime.InteropServices._PropertyInfo
  inherits: MemberInfo

val propertyInfo : PropertyInfo

  type: PropertyInfo
  implements: ICustomAttributeProvider
  implements: Runtime.InteropServices._MemberInfo
  implements: Runtime.InteropServices._PropertyInfo
  inherits: MemberInfo

Multiple overloads
Type.GetProperty(name: string) : PropertyInfo
Type.GetProperty(name: string, returnType: Type) : PropertyInfo
Type.GetProperty(name: string, types: Type []) : PropertyInfo
Type.GetProperty(name: string, bindingAttr: BindingFlags) : PropertyInfo
Type.GetProperty(name: string, returnType: Type, types: Type []) : PropertyInfo
Type.GetProperty(name: string, returnType: Type, types: Type [], modifiers: ParameterModifier []) : PropertyInfo
Type.GetProperty(name: string, bindingAttr: BindingFlags, binder: Binder, returnType: Type, types: Type [], modifiers: ParameterModifier []) : PropertyInfo

property MemberInfo.Name: string

val deserializeColumnData : (string -> obj)

property PropertyInfo.PropertyType: Type

val columnIndex : int

  type: int
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

Multiple overloads
MemberInfo.GetCustomAttributes(inherit: bool) : obj []
MemberInfo.GetCustomAttributes(attributeType: Type, inherit: bool) : obj []

val col : ColumnAttribute

  type: ColumnAttribute
  implements: Runtime.InteropServices._Attribute
  inherits: Attribute

val fieldContentFromSchema : (string [] -> obj [])

val words : string []

  type: string []
  implements: ICloneable
  implements: Collections.IList
  implements: Collections.ICollection
  implements: Collections.IStructuralComparable
  implements: Collections.IStructuralEquatable
  implements: Collections.Generic.IList<string>
  implements: Collections.Generic.ICollection<string>
  implements: seq<string>
  implements: Collections.IEnumerable
  inherits: Array

val deserializedData : obj []

  type: obj []
  implements: ICloneable
  implements: Collections.IList
  implements: Collections.ICollection
  implements: Collections.IStructuralComparable
  implements: Collections.IStructuralEquatable
  implements: Collections.Generic.IList<obj>
  implements: Collections.Generic.ICollection<obj>
  implements: seq<obj>
  implements: Collections.IEnumerable
  inherits: Array

val fieldName : string

  type: string
  implements: IComparable
  implements: ICloneable
  implements: IConvertible
  implements: IComparable<string>
  implements: seq<char>
  implements: Collections.IEnumerable
  implements: IEquatable<string>

val words : obj []

  type: obj []
  implements: ICloneable
  implements: Collections.IList
  implements: Collections.ICollection
  implements: Collections.IStructuralComparable
  implements: Collections.IStructuralEquatable
  implements: Collections.Generic.IList<obj>
  implements: Collections.Generic.ICollection<obj>
  implements: seq<obj>
  implements: Collections.IEnumerable
  inherits: Array

val convertColumn : (string -> string * (string -> 'b) -> 'b)

val colText : string

  type: string
  implements: IComparable
  implements: ICloneable
  implements: IConvertible
  implements: IComparable<string>
  implements: seq<char>
  implements: Collections.IEnumerable
  implements: IEquatable<string>

val deserializeColumnData : (string -> 'b)

Multiple items
val obj : obj

--------------------

type obj = Object

Full name: Microsoft.FSharp.Core.obj

val unbox : obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

member CsvReader.ReadFile : file:string * separator:char * firstLineHasHeader:bool -> seq<'a>

Full name: Csv.CsvReader`1.ReadFile

val file : string

  type: string
  implements: IComparable
  implements: ICloneable
  implements: IConvertible
  implements: IComparable<string>
  implements: seq<char>
  implements: Collections.IEnumerable
  implements: IEquatable<string>

val separator : char

  type: char
  implements: IComparable
  implements: IConvertible
  implements: IComparable<char>
  implements: IEquatable<char>
  inherits: ValueType

val firstLineHasHeader : bool

  type: bool
  implements: IComparable
  implements: IConvertible
  implements: IComparable<bool>
  implements: IEquatable<bool>
  inherits: ValueType

type bool = Boolean

Full name: Microsoft.FSharp.Core.bool

  type: bool
  implements: IComparable
  implements: IConvertible
  implements: IComparable<bool>
  implements: IEquatable<bool>
  inherits: ValueType

Multiple items
val seq : seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Core.Operators.seq

--------------------

type seq<'T> = Collections.Generic.IEnumerable<'T>

Full name: Microsoft.FSharp.Collections.seq<_>

type: seq<'T>
inherits: Collections.IEnumerable

val textReader : StreamReader

  type: StreamReader
  implements: IDisposable
  inherits: TextReader
  inherits: MarshalByRefObject

type File =
  class
    static member AppendAllLines : string * System.Collections.Generic.IEnumerable<string> -> unit
    static member AppendAllLines : string * System.Collections.Generic.IEnumerable<string> * System.Text.Encoding -> unit
    static member AppendAllText : string * string -> unit
    static member AppendAllText : string * string * System.Text.Encoding -> unit
    static member AppendText : string -> System.IO.StreamWriter
    static member Copy : string * string -> unit
    static member Copy : string * string * bool -> unit
    static member Create : string -> System.IO.FileStream
    static member Create : string * int -> System.IO.FileStream
    static member Create : string * int * System.IO.FileOptions -> System.IO.FileStream
    static member Create : string * int * System.IO.FileOptions * System.Security.AccessControl.FileSecurity -> System.IO.FileStream
    static member CreateText : string -> System.IO.StreamWriter
    static member Decrypt : string -> unit
    static member Delete : string -> unit
    static member Encrypt : string -> unit
    static member Exists : string -> bool
    static member GetAccessControl : string -> System.Security.AccessControl.FileSecurity
    static member GetAccessControl : string * System.Security.AccessControl.AccessControlSections -> System.Security.AccessControl.FileSecurity
    static member GetAttributes : string -> System.IO.FileAttributes
    static member GetCreationTime : string -> System.DateTime
    static member GetCreationTimeUtc : string -> System.DateTime
    static member GetLastAccessTime : string -> System.DateTime
    static member GetLastAccessTimeUtc : string -> System.DateTime
    static member GetLastWriteTime : string -> System.DateTime
    static member GetLastWriteTimeUtc : string -> System.DateTime
    static member Move : string * string -> unit
    static member Open : string * System.IO.FileMode -> System.IO.FileStream
    static member Open : string * System.IO.FileMode * System.IO.FileAccess -> System.IO.FileStream
    static member Open : string * System.IO.FileMode * System.IO.FileAccess * System.IO.FileShare -> System.IO.FileStream
    static member OpenRead : string -> System.IO.FileStream
    static member OpenText : string -> System.IO.StreamReader
    static member OpenWrite : string -> System.IO.FileStream
    static member ReadAllBytes : string -> System.Byte []
    static member ReadAllLines : string -> string []
    static member ReadAllLines : string * System.Text.Encoding -> string []
    static member ReadAllText : string -> string
    static member ReadAllText : string * System.Text.Encoding -> string
    static member ReadLines : string -> System.Collections.Generic.IEnumerable<string>
    static member ReadLines : string * System.Text.Encoding -> System.Collections.Generic.IEnumerable<string>
    static member Replace : string * string * string -> unit
    static member Replace : string * string * string * bool -> unit
    static member SetAccessControl : string * System.Security.AccessControl.FileSecurity -> unit
    static member SetAttributes : string * System.IO.FileAttributes -> unit
    static member SetCreationTime : string * System.DateTime -> unit
    static member SetCreationTimeUtc : string * System.DateTime -> unit
    static member SetLastAccessTime : string * System.DateTime -> unit
    static member SetLastAccessTimeUtc : string * System.DateTime -> unit
    static member SetLastWriteTime : string * System.DateTime -> unit
    static member SetLastWriteTimeUtc : string * System.DateTime -> unit
    static member WriteAllBytes : string * System.Byte [] -> unit
    static member WriteAllLines : string * string [] -> unit
    static member WriteAllLines : string * System.Collections.Generic.IEnumerable<string> -> unit
    static member WriteAllLines : string * string [] * System.Text.Encoding -> unit
    static member WriteAllLines : string * System.Collections.Generic.IEnumerable<string> * System.Text.Encoding -> unit
    static member WriteAllText : string * string -> unit
    static member WriteAllText : string * string * System.Text.Encoding -> unit
  end

Full name: System.IO.File

File.OpenText(path: string) : StreamReader

TextReader.ReadLine() : string

val filter : ('T -> bool) -> 'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.filter

val not : bool -> bool

Full name: Microsoft.FSharp.Core.Operators.not

String.IsNullOrWhiteSpace(value: string) : bool

val ofArray : ('Key * 'T) [] -> Map<'Key,'T> (requires comparison)

Full name: Microsoft.FSharp.Collections.Map.ofArray

property StreamReader.EndOfStream: bool

String.IsNullOrEmpty(value: string) : bool

member CsvReader.CreateRecord : header:Map<string,int> * delim:char * line:string -> 'a

type Substance =
  {Id: int;
   Name: string;
   Sequence: string;}

Full name: Csv.Substance

  type: Substance
  implements: IEquatable<Substance>
  implements: Collections.IStructuralEquatable
  implements: IComparable<Substance>
  implements: IComparable
  implements: Collections.IStructuralComparable

Substance.Id: int

Substance.Name: string

Substance.Sequence: string

type Probe =
  {Name: string;
   Mismatches: int;
   Feature: string;
   HitLocation: string;
   Strain: string;}

Full name: Csv.Probe

  type: Probe
  implements: IEquatable<Probe>
  implements: Collections.IStructuralEquatable
  implements: IComparable<Probe>
  implements: IComparable
  implements: Collections.IStructuralComparable

Probe.Name: string

Probe.Mismatches: int

Probe.Feature: string

Probe.HitLocation: string

Probe.Strain: string

type ProbeAlt =
  {Strain: string;
   Name: string;}

Full name: Csv.ProbeAlt

  type: ProbeAlt
  implements: IEquatable<ProbeAlt>
  implements: Collections.IStructuralEquatable
  implements: IComparable<ProbeAlt>
  implements: IComparable
  implements: Collections.IStructuralComparable

ProbeAlt.Strain: string

ProbeAlt.Name: string

val typeConverter : Type -> (string -> obj)

Full name: Csv.typeConverter

val _type : Type

  type: Type
  implements: ICustomAttributeProvider
  implements: Runtime.InteropServices._MemberInfo
  implements: Runtime.InteropServices._Type
  implements: IReflect
  inherits: MemberInfo

val t : Type

  type: Type
  implements: ICustomAttributeProvider
  implements: Runtime.InteropServices._MemberInfo
  implements: Runtime.InteropServices._Type
  implements: IReflect
  inherits: MemberInfo

Multiple items
val float : 'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------

type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>

  type: float<'Measure>
  implements: IComparable
  implements: IConvertible
  implements: IFormattable
  implements: IComparable<float<'Measure>>
  implements: IEquatable<float<'Measure>>
  inherits: ValueType

--------------------

type float = Double

Full name: Microsoft.FSharp.Core.float

  type: float
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<float>
  implements: IEquatable<float>
  inherits: ValueType

type Double =
  struct
    member CompareTo : obj -> int
    member CompareTo : float -> int
    member Equals : obj -> bool
    member Equals : float -> bool
    member GetHashCode : unit -> int
    member GetTypeCode : unit -> System.TypeCode
    member ToString : unit -> string
    member ToString : string -> string
    member ToString : System.IFormatProvider -> string
    member ToString : string * System.IFormatProvider -> string
    static val MinValue : float
    static val MaxValue : float
    static val Epsilon : float
    static val NegativeInfinity : float
    static val PositiveInfinity : float
    static val NaN : float
    static member IsInfinity : float -> bool
    static member IsNaN : float -> bool
    static member IsNegativeInfinity : float -> bool
    static member IsPositiveInfinity : float -> bool
    static member Parse : string -> float
    static member Parse : string * System.Globalization.NumberStyles -> float
    static member Parse : string * System.IFormatProvider -> float
    static member Parse : string * System.Globalization.NumberStyles * System.IFormatProvider -> float
    static member TryParse : string * float -> bool
    static member TryParse : string * System.Globalization.NumberStyles * System.IFormatProvider * float -> bool
  end

Full name: System.Double

  type: Double
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<float>
  implements: IEquatable<float>
  inherits: ValueType

Multiple overloads
Double.Parse(s: string) : float
Double.Parse(s: string, provider: IFormatProvider) : float
Double.Parse(s: string, style: Globalization.NumberStyles) : float
Double.Parse(s: string, style: Globalization.NumberStyles, provider: IFormatProvider) : float

val box : 'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

type Int32 =
  struct
    member CompareTo : obj -> int
    member CompareTo : int -> int
    member Equals : obj -> bool
    member Equals : int -> bool
    member GetHashCode : unit -> int
    member GetTypeCode : unit -> System.TypeCode
    member ToString : unit -> string
    member ToString : string -> string
    member ToString : System.IFormatProvider -> string
    member ToString : string * System.IFormatProvider -> string
    static val MaxValue : int
    static val MinValue : int
    static member Parse : string -> int
    static member Parse : string * System.Globalization.NumberStyles -> int
    static member Parse : string * System.IFormatProvider -> int
    static member Parse : string * System.Globalization.NumberStyles * System.IFormatProvider -> int
    static member TryParse : string * int -> bool
    static member TryParse : string * System.Globalization.NumberStyles * System.IFormatProvider * int -> bool
  end

Full name: System.Int32

  type: Int32
  implements: IComparable
  implements: IFormattable
  implements: IConvertible
  implements: IComparable<int>
  implements: IEquatable<int>
  inherits: ValueType

Multiple overloads
Int32.Parse(s: string) : int
Int32.Parse(s: string, provider: IFormatProvider) : int
Int32.Parse(s: string, style: Globalization.NumberStyles) : int
Int32.Parse(s: string, style: Globalization.NumberStyles, provider: IFormatProvider) : int

type Boolean =
  struct
    member CompareTo : obj -> int
    member CompareTo : bool -> int
    member Equals : obj -> bool
    member Equals : bool -> bool
    member GetHashCode : unit -> int
    member GetTypeCode : unit -> System.TypeCode
    member ToString : unit -> string
    member ToString : System.IFormatProvider -> string
    static val TrueString : string
    static val FalseString : string
    static member Parse : string -> bool
    static member TryParse : string * bool -> bool
  end

Full name: System.Boolean

  type: Boolean
  implements: IComparable
  implements: IConvertible
  implements: IComparable<bool>
  implements: IEquatable<bool>
  inherits: ValueType

Boolean.Parse(value: string) : bool

val path : string

Full name: Csv.path

  type: string
  implements: IComparable
  implements: ICloneable
  implements: IConvertible
  implements: IComparable<string>
  implements: seq<char>
  implements: Collections.IEnumerable
  implements: IEquatable<string>

val reader : CsvReader<Probe>

Full name: Csv.reader

val hasHeader : bool

Full name: Csv.hasHeader

  type: bool
  implements: IComparable
  implements: IConvertible
  implements: IComparable<bool>
  implements: IEquatable<bool>
  inherits: ValueType

val separator : char

Full name: Csv.separator

  type: char
  implements: IComparable
  implements: IConvertible
  implements: IComparable<char>
  implements: IEquatable<char>
  inherits: ValueType

val probes : seq<Probe>

Full name: Csv.probes

type: seq<Probe>
inherits: Collections.IEnumerable

member CsvReader.ReadFile : file:string * separator:char * firstLineHasHeader:bool -> seq<'a>

More information

Link:	http://fssnip.net/3T
Posted:	2 years ago
Author:	Rainer Schuster (website)
Tags:	CSV, deserialize, reader

CSV reader

More information

Hosting

F# Snippets

License

Credits