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)

Copy Source
Copy Link
Tools:
  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: 3 years ago
Author: Rainer Schuster (website)
Tags: CSV, deserialize, reader