F# Type Providers

I've worked with a decent handful of programming languages. Most recently I've picked up Elixir and it's a pleasure to build websites with the Phoenix framework. But my favorite language is by far F#. There was a steep learning curve to it (mostly related to functional programming concepts), and my problems at work usually require understanding of the business itself, so I don't have many opportunities to blog about how F# rules! But yesterday, I found a case where both the problem and solution are simple to follow.

The problem: I want hourly temperature forecasts for work. I looked into several APIs and Wunderground's seemed to be the best solution for us.

An easy problem in any language. But here's the entire solution in F#:

    [<Literal>]
    let private hourlySampleUrl = "http://api.wunderground.com/api/" + wundergroundKey + "/hourly10day/q/CA/San_Francisco.json"
    type private WeatherProvider = JsonProvider<hourlySampleUrl>
    type ForecastedData = {
        Time: DateTime
        Temperature: int
    }
    let private convertToForecastedData (x: WeatherProvider.HourlyForecast) =
        let convertFromEpoch e =
            DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(float e)
        { Time = convertFromEpoch x.Fcttime.Epoch
          Temperature = x.Temp.English }

    let getWeather (url: string) =
        WeatherProvider.Load(url).HourlyForecast
        |> Array.map(convertToForecastedData)

Let's start by looking at getWeather. This function takes a URL, downloads the content, grabs the HourlyForecast from the JSON, and converts this array to a format that we care about. We focus on what needs to be done, and not how it's done, a common theme in F# and Functional Programming.

Here's how it's done:

I used a JSON type provider and provided it with a sample JSON string. There are several ways to populate this provider. When I gave it "hourlySampleUrl," the compiler immediately fetched the URL and parsed the JSON response in order to get its structure (fields and types). I named this result WeatherProvider.

In getWeather, WeatherProvider.Load takes in the actual URL we are interested in. For our case, we only care about the HourlyForecast field (which is actually an array of type HourlyForecast)

Side note: When developing, I can see the fields appear during autocomplete. Since this is all checked by the compiler, there is no chance of runtime errors from having typos. This is a big, big win in my book.

For each hourly forecasted item, the business only cares about the time and the temperature. The conversion is handled in convertToForecastedData.

Note: Because of the data in the sample provided, the compiler has correctly determined that the Fcttime's "Epoch" and Temp's "English" values are integers.

I have not explicitly defined the return type, but since F# is statically typed, I can see in the IDE that the compiler has figured out that "getWeather" is a function that takes in a string and returns ForecastedData[].

The return type being inferred is a huge bonus to me. It enables me to constantly refactor as much as I want. Originally, I had convertToForecastedData return a tuple of DateTime and int, which would mean that getWeather would return (DateTime * int)[]. Having the input and return types determined by compiler encourages me to make changes frequently while also avoiding runtime errors.

I hope you've enjoyed this article. I've used Type Providers numerous times before (XML, JSON, SQL Server, and recently Excel, which I considered blogging about). They are all relatively easy to use and lets you focus on what you need to do (and not how to do it). In the past, I've used a similar Wunderground API for my personal site (using Elixir). Doing something similar in F# was so incredibly simple that I just had to write about it.