events.csv

get_ids.fs

let getIds (events : Event list) =
    let ids = events |> List.map (fun e -> e.ID)
    let min = ids |> List.min
    let max = ids |> List.max
    { Start = min ; End = max }

make_csv.fsx

let file = openFile "C:\\users\\reedc\\desktop\\events.csv"
let csv = file |> Result.map openCsv

open_csv.fs

let openCsv (strm : Stream) =
    new CsvReader(new StreamReader(strm), Globalization.CultureInfo.InvariantCulture)

open_file.fs

let openFile filename =
    try
        File.OpenRead filename
        |> Result.Ok
    with
    | e -> 
        IO(message = "Could not open file", exn = e)
        |> Result.Error

read_rows.fsx

let readRow (reader : CsvReader) =
    if reader.Read () then
            let evt = { 
                        Date = reader.GetField<DateTime>(0) ;
                        ID = reader.GetField<int>(1) ;
                        Description = reader.GetField<string>(2)
                      }
            Some evt
    else None

let readRowsAndClose reader =
    try
        try
            let rows = 
                Seq.initInfinite (fun _ -> readRow reader)
                |> Seq.takeWhile (fun r -> r.IsSome)
                |> Seq.choose id
                |> Seq.toList
            if List.isEmpty rows then
                Result.Error DataMissing
            else Result.Ok rows
        with
        | e -> 
            DataMalformed ("Unable to parse data", e)
            |> Result.Error
    finally
        reader.Dispose ()

result.fs

let result = 
    openFile "C:\\users\\reedc\\desktop\\events.csv"
    |> Result.map openCsv
    |> Result.bind readRowsAndClose
    |> Result.map getIds

types.fs

// The data in our rows
type Event = { Date : DateTime ; ID : int ; Description : string }

// Our end result
type Range = { Start : int ; End : int }

// Our potential problems
type Issue =
    | IO of message : string * exn : Exception
    | DataMissing
    | DataMalformed of message : string * exn : Exception