F# Advent Calendar in English 2016

Update (11/28/2016): Dear writers, this year we are going to make an e-book from #FsAdvent posts and to raise money for a good cause (read more here). If you do not allow to use your post, please let me know.

F# Advent Calendar is an adorable idea, which has become a tradition:

Each year we’ve had an incredible Advent full of F# and Christmas spirit.

Advent 2016 is coming, do not to lose your chance to reserve a spot and spread your thoughts and love to F# with the community. Have you done something special this year? Do you have any unique experience you are willing to share? Have your project incredibly evolved this year? Are there any good ideas for the post, but you didn’t have time to write it? The time has come – it is right now! You have a chance to share your story with the globe! Join F# Advent Calendar and hurry up!


Rules are very simple:

  1. Choose F# related topic for your blog post and reserve the date on Twitter or leave a comment to this post. Please note that you do not have to announce the topic until the date.
  2. Prepare a blog post in English
  3. Publish your post on a specified date (according to the calendar)
  4. Post the link to your post on Twitter with hashtags #fsharp and #FsAdvent.


Date Author Post Title
Nov 27 (Sun) Anthony Lloyd Functional Event Sourcing meets The Elm Architecture
Nov 27 (Sun) Rick Pack  F# Data Visualization for a Neophyte – CDC Open Data
Nov 28 (Mon) Mark Seemann Easy domain modelling with types
Nov 28 (Mon) Bill Berry Introduction to Azure IoT with Fsharp
Nov 29 (Tue) Mikhail Shilkov Introducing Stream Processing in F#
Nov 29 (Tue) josesoyo Using OpenCL on F# via FSCL
Nov 30 (Wed) Alfonso Garcia-Caro Tree Shaking with Fable
Nov 30 (Wed) Jeremy Bellows NeuralFish – Evolving Neural Topologies in F#
Dec 01 (Thu) Steffen Forkmann Context matters
Dec 01 (Thu) Ramón Soto Mathiesen Semantic Versioning .NET libraries and NuGet packages
Dec 02 (Fri) Chet Husk A Host of Issues: Migrating from UserVoice To GitHub Issues with Canopy and OctoKit.net
Dec 02 (Fri) Kristian Schmidt F# in Production
Dec 03 (Sat) Henrik Feldt A gentle introduction to programming networked services on linux
Dec 04 (Sun) Jérémie Chassaing fck: Fake Construction Kit
Dec 04 (Sun) Phillip Trelford X-Platform Development With Xamarin.Forms And F#
Dec 05 (Mon) Scott Wlaschin Functional approaches to dependency injection
Dec 05 (Mon) Rachel Reese Using type providers to post slack messages
Dec 06 (Tue) Daniel Bachler Using F# on both the frontend and the backend
Dec 06 (Tue) Mark Heath  Asterisk Game in F# and WPF
Dec 07 (Wed) Edgar Sánchez Describing images in your favorite human language
Dec 07 (Wed) András Jankó Distributed web applications in F# with WebSharper
Dec 08 (Thu) Hussam Abu-Libdeh How F# delighted this newbie while experimenting with distributed systems
Dec 08 (Thu) Jonathan Leaver RdKafka for F# Microservices
Dec 09 (Fri) Doug Bruce Build Yourself a Robo-Advisor in F#. Part I : Domain Modelling
Dec 09 (Fri) Gergely Kalapos myTrades.Analytics – a netstandard compatible .NET technical analysis library written in F#
Dec 10 (Sat) Mårten Rånge F# Advent – December 10, 2016 – Implementing a persistent hash map
Dec 10 (Sat) Erik Schierboom Parsing text in F#
Dec 11 (Sun) Matt Olson An Introduction To Testing Suave WebParts
Dec 11 (Sun) Jeremy Abbott Merry Monad Xmas
Dec 12 (Mon) Pierre Irrmann Some advice to F# beginners
Dec 12 (Mon) Pierre-Luc Maheu Scripting in F# using Fake and Paket
Dec 13 (Tue) Roman Provazník Building F# community in Czech Republic
Dec 13 (Tue) Isak Sky Working with SQL syntax trees in F#
Dec 14 (Wed) Troy Kershaw The AsyncArrow
Dec 15 (Thu) Reed Copsey, Jr. Christmas Trees in WPF, 2016 Edition 
Dec 15 (Thu) Dustin Moris Gorski Running Suave in ASP.NET Core (and on top of Kestrel)
Dec 16 (Fri) Michael Newton Advent 2016 (It has a pretty d3 force graph at the end, FParsec examples and other good stuff)
Dec 17 (Sat) Kunjan Dalal Epic Adventure using F#
Dec 17 (Sat) Jan Schiefer Accessing native C libraries on Linux with F# and .Net Core
Dec 19 (Mon) Tomasz Heimowski Creating a tutorial from Git repo
Dec 19 (Mon) Tomasz Jaskuλa Data structures and algorithms – helping Santa Claus find his road to San Francisco
Dec 20 (Tue) Тэ дрэвэт утвикλэрэн Feeding On F#
Dec 20 (Tue) Vagif Abilov reF#actoring: rewriting an actor in F#
Dec 21 (Wed) Riccardo Terrell The Traveling Santa Problem… a Neural Network solution
Dec 21 (Wed) Elastic Inc Solidifying Releases with FAKE (F# MAKE)
Dec 22 (Thu) David Podhola Hello fable-import-sharepoint
Dec 23 (Fri) Carsten König Advent with a Star
Dec 23 (Fri) kekyo2 About Expandable F# Compiler project
Dec 24 (Sat) Roman Nevolin The magic of type providers
Dec 24 (Sat) Ross McKinlay + Andrea McAts When Playstation meets F#, PSX |> Pi
Dec 25 (Sun) Jamie Dixon Age and Sex Analysis Of Microsoft USA MVPs
Dec 25 (Sun) Leif Battermann Purity in an impure language with the free monad – by example of a Tic-Tac-Toe backend with CQRS and event sourcing
Dec 26 (Mon) Tamizh Vendan Implementing Two-Factor Authentication in Suave
Dec 26 (Mon) Marcel Schwark Implementing Pong in a functional manner with Fable
Dec 27 (Tue) Jon Wood Getting Up and Running with FsLab for Data Science 
Dec 29 (Thu) Eriawan Kusumawardho F# Advent: F# 4.0 function first constructor
Dec 30 (Fri) Paulmichael Blasucci Tips & Tricks to Improve Your F# Library’s Public API
Dec 31 (Sat) Adam Granicz Simple reactive scenarios with WebSharper
Jan 01 (Sun) F# Software Foundation Welcome to 2017! A retrospective of the past year

F# Type Providers Development Tips (not Tricks)

There are several tips that you probably would like to know if you plan to create a new F# Type Provider(TP) or to contribute to the existing one.

Tip #1: Use FSharp.TypeProviders.StarterPack

Latest version of ProvidedTypes SDK is stored in fsprojects/FSharp.TypeProviders.StarterPack repository and you have to use this version in most cases.

Community agreed to use this repository as master version for the SDK. You may find SDK files committed to other repositories, some of them (like files in FSharp.Data repository) may even be modified, contain new features or latest fixes. Once changes are tested and generalized enough, they will for sure be contributed back to FSharp.TypeProviders.StarterPack. So it is better to use a version from the official repository to be on the safe side.

Tip #2: Use Paket dependency manager

Paket allows you to reference files directly from GitHub and easily keep them up-to-date together with other NuGet dependencies.

All you need is to add two lines to your paket.dependecies files (that tell Paket to download files from GitHub to paket-files folder)

github fsprojects/FSharp.TypeProviders.StarterPack src/ProvidedTypes.fsi
github fsprojects/FSharp.TypeProviders.StarterPack src/ProvidedTypes.fs

and two lines to paket.references file (to tell Paket to insert files into corresponding fsproj files)


You can see how it works in ExcelProvider: paket.dependencies + paket.references

Tip #3: Create two solution files (*.sln)

You should not store TP project and projects that use TP in one solution, because when you reference TP dll, IDE/Intellisense loads this assembly and locks file on a disk. After that, you will not be able to rebuild your TP anymore until you close IDE.

So, it does not work in a long run and you have to separate your code to two solutions. The first one (let’s say SwaggerProvider.sln) will contain TP source code, tests for parser and for all components that don’t call TP directly. The second one (let’s say SwaggerProvider.TestsAndDocs.sln) will contain tests, which use TP directly and docs that may also use TP dll.


Tip #4: Automate build (using FAKE)

This tip is quite generic and you have to do it for all projects, but it becomes extremely useful for type providers. It’s tedious to open a new solution (IDE instance), when you want to test latest changes – it is much easier to have a build script that rebuilds and tests everything in one click.

The good start point here is fsprojects/ProjectScaffold that contains most useful generic build automation steps.

Tip #5: Yes, you can debug Type Providers

Debugging of TP does not look an easy task at first sight (and it is really slow in practice), but it is real.

You can start two instances of your IDE. The first one, for a solution with TP code and the second one for code that uses compiled type provider (here is important to check that the second one really references dll compiled by the first one). For the second IDE you can use TestAndDocs solution from Tip #4 or a simple *.fsx script that calls your TP. The last step is to set break point in the first IDE instance and to attach to the second IDE instance process.

This allows you to debug, but you will not be able to modify the code of TP. After each modification, you will need to close 2nd IDE, rebuild dll and repeat all these steps once again.

However, you can automate all manual steps:

  • Open project properties of TP project.
  • Open Debug tab.
  • Select start external program checkpoint
  • Enter path to your VS devenv.exe (For example: “C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe”)
  • Put path to your tests project (file) in command line arguments (For example “d:\GitHub\SwaggerProvider\SwaggerProvider.TestsAndDocs.sln”)

After that, when you press F5 from your TP project, VS will automatically build your TP, start your instance of VS, attach to a new VS process and open your tests solution in it.


Tip #6: Write tests using FSharp.Compiler.Service

Usefulness of this tip really depends on the TP you are working on, but if you are lucky enough (like I am) and you have an access to a large collection of schemes for your type provider, you can automate testing of compilation of provided types.

There is an awesome resource called APIs.guru (Wikipedia for WEB APIs) that provides an access to several hundred Swagger schemes of real-world Web APIs. For sure, SwaggerProvider uses these schemes to test schema parser and it is relatively easy to do.

But we can go further and check that provided types are “compilable” by F# compiler (there is no collisions in type names, property names, field names and method names).

The one way to do this is to use “Hosted Compiler” feature of F# Compiler Services. This allows us to create a simple script that just instantiates TP for each schema and asks F# Compiler to compile this generated script.

Here is source code from tests:

[<Test; TestCaseSource("JsonSchemasSource")>]
let ``Compile TP`` url =
  let tempFile = Path.GetTempFileName()
  let fs = Path.ChangeExtension(tempFile, ".fs")
  let dll = Path.ChangeExtension(tempFile, ".dll")

  File.WriteAllText(fs, sprintf """
  module TestModule
  open SwaggerProvider
  type ProvidedSwagger = SwaggerProvider<"%s">
  let instance = ProvidedSwagger()
  """ url)

  let errors, exitCode =
      (["fsc.exe"; "-o"; dll; "-a"; fs] @ asms))

  [tempFile; fs; dll]
  |> List.filter File.Exists
  |> List.iter File.Delete

  if exitCode <> 0 then
    let strs = errors |> Array.map(fun x->x.ToString())
    failwithf "Error:\n%s" (String.Join("\n", strs )) 


Tip #7: Handling 3rd party NuGet dependencies

You face a dilemma when your TP needs 3rd party dlls: “How to deliver these dlls to a user?” This is a dilemma, because your IDE will not be able to resolve 3rd party dependencies without your participation if you just add them as dependencies to your NuGet package.

This is the case, for example, when your schema is in JSON format and you decided to use JSON.NET to parse it, or in Yaml format and you want to use YamlDotNet.

Option 1. Pack all dependencies inside your NuGet package.

The simplest solution is to put all required dlls in the folder with your TP dll in NuGet package. In this case, there is nothing to do with assembly resolution and it is definitely a good option to start from.

For example, FSharp.Configuration uses this option and packs SharpYaml.dll inside.

BUT, you have to remember that in this case you limit your users to the exact version of dll packed with your TP. If they reference a newer version from NuGet, it may lead to a run-time error.

Option 2. Uses AssemblyResolve event handler.

If I am not wrong, this solution was firstly developed in RProvider.

Actually, you split your TP into three assemblies:

  • TP.dll that setups AssemblyResolve event handler that helps IDE find assemblies on a hard drive and tells the compiler that TP will be in TP.DesignTime.dll (but doesn’t reference this assembly directly).
  • TP.DesignTime.dll that contains implementation of TP.
  • TP.Runtime.dll that contains the code that should exist in run-time and may be used by provided methods.

TP.dll references TP.Runtime.dll but uses nothing from it. Such dependencies do not break intellisense (because it does not need this assembly), but in the same time your provided code will be able to call code from TP.Runtime.dll.

Read more about this in RProvider Developer Notes (SwaggerProvider uses the same approach).


Tip #8: Use experience of other TP developers

Google Cloud Vision API from .NET\F# (OAuth2 with ServiceAccount.json)

Google Cloud Platform provides a wide range of APIs, one of which is Cloud Vision API that allows you to detect faces in images, extract sentiments, detect landmark, OCR and etc.

One of available annotators is “Logo Detection” that allows you to find company logo in your image and recognize it.

.NET is not the part of mainstream Google Cloud SDK. Google maintains google-api-dotnet-client that should allow you to authenticate to and call all available services. API design looks slightly not intuitive for .NET world (at least from my point of view).

I spent some time on Google/SO/Github trying to understand how to use OAuth2 in server-to-server authentication scenario with ServiceAccount.json file generated by Google API Manager.


You cannot use this API without billing account, so you have to put your credit card info, if you want to play with this API.

Also, note that you need to have two NuGet packages Google.Apis.Vision.v1Google.Apis.Oauth2.v2 (and a lot of their dependencies)

So, here is the full sample:

#load "Scripts/load-references-debug.fsx"

open System.IO
open Google.Apis.Auth.OAuth2
open Google.Apis.Services
open Google.Apis.Vision.v1
open Google.Apis.Vision.v1.Data

// OAuth2 authentication using service account JSON file
let credentials =
    let jsonServiceAccount = @"d:\ServiceAccount.json"
    use stream = new FileStream(jsonServiceAccount, 
                         FileMode.Open, FileAccess.Read)

let visionService = // Google Cloud Vision Service
        ApplicationName = "my-cool-app",
        HttpClientInitializer = credentials)
    |> VisionService

// Logo detection request for one image
let createRequest content = 
  let wrap (xs:'a list) = System.Collections.Generic.List(xs)
    Requests = wrap
        Features = wrap [Feature(Type = "LOGO_DETECTION")],
        Image = Image(Content = content))
  |> visionService.Images.Annotate

let call fileName = // Call and interpret results
    let request =
        File.ReadAllBytes fileName
        |> System.Convert.ToBase64String
        |> createRequest
    let response = request.Execute()

    [ for x in response.Responses do
        for y in x.LogoAnnotations do
          yield y.Description
    ] |> List.toArray

let x = call "D:\\fsharp256.png"
// val x : string [] = [|"F#"|]

FsShelter: a Storm shell for F#

I think, therefore I spam.

About a year ago Prolucid adopted Apache Storm as our platform of choice for event stream processing and F# as our language of choice for all of our “cloud” development.

FsStorm was an essential part that let us iterate, scale and deliver quickly, but even from the earliest days it was obvious that the developer experience could be improved. Unfortunately, it meant a complete rewrite of FsStorm:

  • FsStorm DSL is a really thin layer on top of Nimbus API model:
    • has explicit IDs when describing components in a topology
    • uses strings in all the names
    • matching of inputs/outputs is not guaranteed
  • FsStorm uses Json AST as it’s public API:
    • messages, tuples, configuration
    • serialization mechanism is hard-baked into the API

We’ve worked around some of the problems, usually by writing more code.

It actually makes sense that Storm itself doesn’t care about the type of the tuples/fields. It runs on JVM, which is very much typed…

View original post 220 more words

F#ools’ Day Party – April 1, 2016

AprilFools6301st April is coming, Mark Gray and I propose F# community to celebrate this day with funny posts about F#.

All you need is to write a blog post that incorporates the idea of April fool in the content or find out a new extraordinary use of F# and destroy the myth that “F# is for Math and Science”.

Rules are even simpler than in FsAdvent:

  1. Ping @sergey-tihon on Twitter and I will put your name in the table below
  2. Tweet link to your post with  tag on April 1 (+/- 1 day).

Happy F#ools’ Day,
Let’s joke together.

Author Post Title
 Pierre Irrmann  Making program behaviour explicit
 Ross McKinlay
 Phillip Trelford  Silverlight Resurrection
 Vicenç García-Altés  A Premier League team will win the Champions League this year

Application contracts with Swagger powered APIs for .NET or Why SwaggerProvider

This post is part of the F# Advent Calendar in English 2015 project.
And special thank you to Phillip Trelford for the idea of F# Advent in English year ago.

In this post I want to talk about how we design software, what we should care about and what we should not.

The story of The Contract

The initial thing is a problem. Nobody writes code without understanding what he/she is doing and what he/she expects to receive at the end. The task (problem description) may come from anywhere: it may be task from your boss or an awesome idea that pretty soon can change the world and bring you a lot of money or some tool / OSS project that will make your life easier in the future.

When you have a clear problem definition, you can start thinking about the solution. There are plenty of ways to solve any problem. You can choose any programming language, any operating system, any programming paradigm, any framework, any tool-set and so on. In order to choose one (the best in your case) solution you start applying real world constraints to reduce the number of solutions. You will probably decide to use a language and tools, which you are more familiar with or which suits better for this particular task. People do this because we all have very important real-life constraint – it is the time. Time-to-market is always important. Nobody starts writing a new operating system just because he/she can do it. We always try to minimize amount of work that should be done to speed up time-to-market.

When you actually start hacking, the thing you start with is `architecture`. Argh, I said that arch.. word. But architecture is nothing more than decomposition. If you do it right in terms of your constraints and limitations – you are almost done. After that, you should write code for small pieces and compose them to get the solution. But what defines the right decomposition? The answer is contracts!

Sounds really simple, does not it? However, it is not so far from the truth. Real-world solution architecture is always state of art, it cannot be super cool for all things, but it can fit your requirements to certain extent. All you can do mastering the architecture is to decompose your monolith idea to simple manageable components with clear responsibilities and clear contract.

The implementation of contract in programming language level is an interface (the promise of capabilities to the world). The implementation of interfaces in F#/C# is pretty good. You as a developer should only define an interface and implement it somewhere to provide a capability by contract. When you are on the other side and want to consume provided capabilities you should only reference component that defines contract and use it with almost zero overhead.

Based on the experience with interfaces, you have three ways of interaction with contract:

  1. Design (define) contract
  2. Provide (implement) contract
  3. Consume contract

But it is not so simple, when your application is larger than one executable file… What happens when you cross process and/or machine boundaries? In this case, we need a technology that allows us to setup the component that provides contract to one machine and consumes this contract on another machine with the same elegance as interfaces do this. At this moment, higher-level contracts (so called API) come to play.

There are plenty of technologies that can help you to develop some sort of API for your component. Probably first helpful thing that comes to mind is WSDL (Web Service Definition Language). When you choose WSDL as your contract language you receive plenty of tools that help you to manage your API, generate implementation from API contract, generate contract from your implementation, generate code that encapsulate all communication difficulties for consumers and so on. WSDL world is pretty mature and beautiful (I really love it), but it usually comes with SOAP and communication protocol that does not suitable for all types of cross-machine communication.

There are some real-world cases when you need more lightweight and fast communication mechanism that can be “easily” consumed from different languages and run-times. In such cases, people more often decide to provide RESTful APIs. BUT, all of you who design RESTful API for your systems and components SHOULD REMEMBER that technology that you use to design and implement contract SHOULD also provide a way to CONSUME your API. It is your responsibility to care about consumers, they should be focused on solving their own task using your API rather than writing boilerplate code to consume your API.


One of technologies that provide such goodness for developers is Swaggernlp-logo-navbar

Swagger is a simple yet powerful representation of your RESTful API. With the largest ecosystem of API tooling on the planet, thousands of developers are supporting Swagger in almost every modern programming language and deployment environment. With a Swagger-enabled API, you get interactive documentation, client SDK generation and discoverability.

Swagger Specification is able to describe pretty wide range of RESTful APIs. Swagger comes along with Swagger Edit that allows contract first API development. APIs that have Swagger schema can easily be integrated with Swagger UI – very powerful interface that dramatically simplify studying of new API (demo). Swagger ecosystem also has tools that generate client code for wide list of languages.

In the .NET world, exists a project called Swashbuckle, which generates Swagger schema to ASP.NET WebAPI services and plugs Swagger UI in your application. I’ve already blogged about how to use Swashbuckle from F# Web Apps.

Swagger is used in ASP.NET API app in Azure App Service and may come to Nancy very soon as well.

F# Swagger Provider

swaggerAs you may already understand, Swagger ecosystem looks very promising in general and Swagger Specification perfectly matches with F# Type Providers approach. So, I am glad to present the SwaggerProvider.

In order to start you need to add reference to SwaggerProvider NuGet package and pass Swagger JSON schema to it (for this example I will use a schema from Petstore – Swagger demo app).

#r "SwaggerProvider/SwaggerProvider.dll"
open SwaggerProvider

type PetStore = SwaggerProvider<"http://petstore.swagger.io/v2/swagger.json">

So, you are generally done. Type Provider parses provided schema and generates all required data types and methods to call API. Note that SwaggerProvider is generative type provider and generates types and methods that exist in run-time, so that means that it can be used from C# code as well.



Even if the RESTful API that you need to consume does not gently provide Swagger schema for you, you still can use SwaggerProvider to call it. It should be easier to manually describe schema once than to write and support source code for all REST calls.

Let’s say that we want to call GitHub API to get all fsprojects repositories. For this API call schema will look like this

    "swagger": "2.0",
    "info": {
        "description": "This is a Sample for GitHub API.",
        "version": "1.0.0",
        "title": "Swagger GitHub"
    "host": "api.github.com",
    "basePath": "/",
    "tags": [
            "name": "repos",
            "description": "Repositories API"
    "schemes": [ "https" ],
    "paths": {
        "orgs/{orgId}/repos": {
            "get": {
                "tags": [ "repos" ],
                "summary": "List organization repositories",
                "description": "",
                "operationId": "orgRepos",
                "consumes": [ "application/json" ],
                "produces": [ "application/json" ],
                "parameters": [
                        "name": "orgId",
                        "in": "path",
                        "description": "Organization name",
                        "required": true,
                        "type": "string"
                "responses": {
                    "200": {
                        "description": "successful operation",
                        "schema": {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/Repo"
    "definitions": {
        "Repo": {
            "type": "object",
            "properties": {
                "id": {
                    "type": "integer",
                    "format": "int64"
                "name": {
                    "type": "string"

If you use Visual Studio to edit Swagger schema, you will be pleasantly surprised by “Intellisense for JSON Schema in the JSON Editor


This JSON describes one data type Repo, that contains simplified version of GitHub Repository data type, and description of one API method /orgs/{orgId}/repos that does the job. Now you are able to use this schema to call GitHub API.



But if you really want to make a call to GitHub API, you need to specify real user agent header and SwaggerProvider allows you to do this:

open SwaggerProvider

let [<Literal>] schemaFile = __SOURCE_DIRECTORY__ + "\GitHub.json"
let [<Literal>] headers = "User-Agent=Googlebot/2.1 (+http://www.google.com/bot.html)"
type GitHub = SwaggerProvider< schemaFile, headers >;

let names =
    |> Array.map (fun x -> x.Name)


Note: SwaggerProvider does not support schemes in YAML format yet. But this feature is definitely will be implemented, because it dramatically simplifies manual schema creation.

Please share your thoughts about SwaggerProvider and do not be shy to try it and report issues if any.

Special thanks to APIs.guru project for maintenance of wide range of real-world Swagger schemes that were used to test SwaggerProvider.

Simple Web API OWIN host using F#

Very nice starter pack for OWIN Web API with F#. If you use Paket manager you need only one dependency to `Microsoft.AspNet.WebApi.OwinSelfHost` NuGet package

Also Web API can be easily configured to use Swagger UI.

Exception Caught

I thought it would be good to write a simple OWIN Web Api host using F# to show how easy it is to interop between the two languages and as a fun experiment. You can find all of the source code from this blog post at the FSharpWebApi github repository.

If you open the Program.fs solution in the github repository you will see the following two lines of code are reponsible for starting the web server:

The getAppBuilder function is defined in the WebServerBuilder module as follows:

The getAppBuilder function returns a function with the signature (IAppBuilder) -> (). This signature is the same as the one expected by the first parameter of WebApp.Start. The reason for breaking this function off into its own module is so that it can be tested.

The cool thing about the Web Api Owin Self host stack is that there is a nuget…

View original post 491 more words

F# Advent Calendar in English 2015


Update(10/27/2015): There are a lot of people, who want to participate, so we’ve decided to extend the timeline and double number of slots. Please do not be shy and books free slots.

Last year we ran an amazing event “F# Advent Calendar in English 2014“. It was incredible December full of F# and Christmas spirit. Every day astonishing authors around the globe posted new F#-related articles. It was an extraordinary time.

December is close enough, so it is a good time to plan something special for F# Advent Calendar. Have you done something special this year? Do you have any unique experience you are willing to share? Have your project incredibly evolved this year? Are there any good ideas for the post, but you didn’t have time to write it? The time has come – it is right now! You have a chance to share your story with the globe! Join F# Advent Calendar and hurry up!


Rules are very simple:

  1. Choose F# related topic for your blog post and reserve the date on Twitter or leave a comment to this post. Please note that you do not have to announce the topic until the date.
  2. Prepare a blog post in English
  3. Publish your post on specified date (according to the calendar)
  4. Post link to your post on Twitter with hashtags #fsharp and #FsAdvent.


Date Author Post Title
 Nov 29 (Sunday)  Rachel Reese  How Jet Build Microservices with F#
 Nov 29 (Sunday)  Jamie Dixon  Creating Dynamic Uris For Visual Studio Web Tests
 Nov 30 (Monday)  Steffen Forkmann  F# advent calendar: Using Async.Choice in Paket
 Nov 30 (Monday)  Bohdan Szymanik  Sharpen up your legacy app(s) performance with a bit of F#
 Dec 01 (Tuesday)  Mark Seemann  Recurse
 Dec 01 (Tuesday)  Kristian Schmidt  A roll of the Liar’s dice
 Dec 02 (Wednesday)  Mike Janger  Taking Ionide Out for a Spin
 Dec 02 (Wednesday)  Tomasz Jaskuλa  Data Science tools in F# through univariante linear regression
 Dec 03 (Thursday)  Phillip Trelford  Calendar Types
 Dec 03 (Thursday)  Jeremy Abbott  F# Events, Reactive Programming and Async Workflows
 Dec 04 (Friday)  Richard Dalton  Azure WTF#
 Dec 04 (Friday)  Edgar Sánchez  Calculating a cannon ball trajectory, the fun way
 Dec 05 (Saturday)  Scott Wlaschin  Thirteen ways of looking at a turtle
Thirteen ways of looking at a turtle (part 2)
Thirteen ways of looking at a turtle – addendum
 Dec 05 (Saturday)  Sean Trelford  No 1 at Christmas
 Dec 06 (Sunday)  Andrea Magnorsky  Computation expressions and microphones
More Computation expressions
 Dec 06 (Sunday)  Christopher Atkins  F# 2015 Advent Cookies
 Dec 07 (Monday)  Sergey Tihon  Application contracts with Swagger powered APIs for .NET or Why SwaggerProvider
 Dec 07 (Monday)  Aaron Powell  What’s the time Mr Wolf?
 Dec 08 (Tuesday)  Isaac Abraham  F#, .NET and the Open Source situation
 Dec 08 (Tuesday)  Jonathan Wood  A Quick Look At F# In Visual Studio Code
 Dec 09 (Wednesday)  Reed Copsey, Jr.  Christmas Trees in WPF using FSharp.ViewModule
 Dec 09 (Wednesday)  Peter Bayne  The trips and traps of creating a Generative Type Provider in F#
 Dec 10 (Thursday)  Daniel Egloff  Algo Trading with F# and GPUs
 Dec 11 (Friday)  @TeaDrivenDev  Making Busy Progress in F#
 Dec 11 (Friday)  Reid Evans  Providing Value with Trivial Abstraction in F#
 Dec 12 (Saturday)  Eriawan Kusumawardho  What’s new in F# 4.0 in Visual Studio 2015
 Dec 12 (Saturday)  Riccardo Terrell  Solving the Santa Claus Problem in F#
 Dec 13 (Sunday)  Marcus Griep  Chiron: JSON + Ducks + Monads
 Dec 13 (Sunday)  @lenadroid  Learn the machine! #fsharp #accord.net
 Dec 14 (Monday)  Tomas Jansson  F#, event sourcing and CQRS tutorial… and agents
 Dec 14 (Monday)  Alex Casquete  Building an Hypermedia REST API with F# and Suave.IO
 Dec 15 (Tuesday)  Evelina Gabasova  The Star Wars social network
 Dec 15 (Tuesday)  Stachu Korick  Pseudocode-Driven Development with F#
 Dec 16 (Wednesday)  Yan Cui  Advent of Code F# – Day 16
 Dec 16 (Wednesday)  Paulmichael Blasucci  A Mixed-Paradigm Recipe for Exposing Native Code
 Dec 17 (Thursday)  Kunjan Dalal  1729
 Dec 17 (Thursday)  Jérémie Chassaing  Ukulele Fun for XMas !
 Dec 18 (Friday)  Anton Tcholakov  Using F# for scientific instrument control
 Dec 18 (Friday)  Matt Hawkins  ReST vs CQRS: The Trigger Pattern
 Dec 19 (Saturday)  Michael Newton  Angels From the Realms of Glory
 Dec 19 (Saturday)  Steven Pemberton  Let It Snow! A basic particle system in F# and WPF
 Dec 20 (Sunday)  Juan M Gómez  Developing mobile apps at the speed of light
 Dec 20 (Sunday)  Jorge Fioranelli  Reactive Messaging Patterns with F# and Akka.NET
 Dec 21 (Monday)  Steffen Forkmann  Automatic re-build and background tasks for suave.io websites
 Dec 21 (Monday)  Tomasz Heimowski  Property-based testing XSLT
 Dec 22 (Tuesday)  Mathias Brandewinder  Hacking together @wbfacts, a World Bank Twitter Bot
 Dec 22 (Tuesday)  Chad Boyer  F# Advent Calendar 2015
 Dec 23 (Wednesday)  Carsten König  F# advent 2015 – some fun with lambda calculus
 Dec 23 (Wednesday)  Troy Kershaw  Getting Started with SignalR using F# and OWIN
 Dec 24 (Thursday)  Matthew Sottile  Comparing trees, functionally
 Dec 24 (Thursday)  Craig Stuntz  Designing for Problems Too Big to Test
 Dec 25 (Friday)  Richard Griffiths  Monogame SnowFlakes – 2015
 Dec 25 (Friday)  Louie Bacaj  F# Powered Realtime Dashboard
 Dec 26 (Saturday)  Adam Granicz  WebSharper – a year in review
 Dec 26 (Saturday)  Chris Dobson  F#, Minecraft and a Raspberry Pi
 Dec 27 (Sunday)  @squeekeeper  Generating Markov text from YouTube comments
 Dec 27 (Sunday)  Indy Garcia  Twitter Local
 Dec 28 (Monday)  Pierre Irrmann  Visualizing F# Advent Calendar contributors
 Dec 29 (Tuesday)  Tamizh Vendan  Implementing API Gateway in F# Using Rx and Suave
 Dec 31 (Thursday)  Tomas Petricek  Happy New Year 2016 around the World
Jan 1 (Friday)  F# Software Foundation  Welcome to 2016 – A Call to Action

Swagger for F# Web Apps

nlp-logo-navbarSwagger is a simple yet powerful representation of your RESTful API. With the largest ecosystem of API tooling on the planet, thousands of developers are supporting Swagger in almost every modern programming language and deployment environment. With a Swagger-enabled API, you get interactive documentation, client SDK generation and discoverability.

Swagger is very powerful framework that is able to generate schema and rich UI for your RESTful API. As I know, Swagger is very popular framework especially in the non-.NET world. You probably have already seen Swagger UI (like this) at several resources.

It turns out that it is not hard to use Swagger for .NET F# apps. There is a project called Swashbuckle, which adds Swagger to WebApi projects.

First of all, you need to create F# ASP.NET Web API project. You can do it using “F# Web Application templates (MVC 5 and Web API 2.2) by Ryan Riley and Daniel Mohl“. Choose “Web API 2.2 and Katana 3.0” option in project creation wizard.

So, now you have F# Web App with RESTful API: CarsController with two services ‘/api/cars‘ and ‘/api/car/{id}‘. Everything is awesome but we do not have UI that is able to show a list of available services, their parameters and return types. Swashbuckle will help us here, we need to install ‘Swashbuckle.Core‘ package to our web app.

Install-Package Swashbuckle.Core

The last step is to update HttpConfiguration in Startup.fs in proper way to register Swagger. Add following three lines to the end of RegisterWebApi method.

open Swashbuckle.Application

type Startup() =
    static member RegisterWebApi(config: HttpConfiguration) =
        // ...
        // Swagger configuration
          .EnableSwagger(fun c -> c.SingleApiVersion("v1", "My API") |> ignore)

That’s all! When you start your web application and open ‘/swagger/ui/index‘ URI you will see beautiful documentation for your RESTful API.