Introducing F# Snippets

This web site allows you to easily share F# source code snippets. It is similar to other Pastebin services, but focuses only on F#. On the other hand, it uses the F# language service to provide colorization and also generates HTML tool tips that show results of background type checking. This makes the F# code significantly more readable.

Unlike other Pastebin sites, this web page has two purposes:

• Publish snippets - You can use this web site to easily post your F# snippets to the web, have them nicely formatted with tool tips and link to them from micro-blogging services, your blog posts etc.
• Repository - In addition, the site supports tagging and stores information like the name of the author. The goal is to provide a repository of useful F# snippets that people can browse and use.

When posting a code snippet, please take the time to fill the additional information such as brief description and tags. This will make this site not only useful for you (to host your snippet), but also for others (looking for F# tutorials and snippets).

Formatting source code

The web uses F# compiler service to do the formatting and to get tool tip texts. This means that you'll see exactly the same information as in Visual Studio. In order to use it, your snippet needs to be F# script (from a .fsx file) that the compiler can type-check (so that it can generate correct tool tips). Obviously, the tool needs a complete and correct script file and it cannot process a snippet without the full script context.

Marking snippets

You can just paste an F# snippet into the text box and the compiler will process the whole source. However, sometimes you may want to hide a part of the code (e.g. uninteresting open sections). In this case, you can use special meta-comments to mark parts of code that you want to process. For example, the following script file generates snippet available here. Note that you can see tool tips with informations about functions that are not visible in the snippet.

 1: let isEven n = n%2 = 0
 2: let formatInt n = (string n) + "N"
 3: 
 4: // [snippet:Filtering and projection]
 5: let res = 
 6:   [ 1 .. 10 ] 
 7:   |> List.filter isEven
 8:   |> List.map formatInt
 9: // [/snippet]

The meta-comment syntax is quite simple - you can enclose any block of code between [snippet:<Title>] and [/snippet] tags. As the screenshot demonstrates, F# Web Snippets tool will generate HTML only for snippets marked using meta-comments. It also picks the title of a snippet from the comment so that you can easily see which snippet is which.

Omitting blocks of code

When presenting a code snippet, it is often useful to hide some part of the code. For example when we have a type declaration and want to demonstrate just the structure of the type without looking at the actual implementation. When using F# Web Snippets, we can use another form of meta-comments to hide a block of code:

1: /// Mutable counter that can be incremented and decremented
2: type Counter(init) = 
3:   (private fields omitted)
4:   member x.Increment = (...)
5:   member x.Decrement = (...)

When hiding a block of code, we can provide a replacement text that will be displayed in the gray box (the look can be, of course, changed by modifying a CSS style). When you place a mouse pointer over the box, you'll see the original code (without unnecessary indentation and line breaks). The following snippet shows the code that we need to write to produce the above snippet:

 1: /// Mutable counter that can be incremented and decremented
 2: type Counter(init) = 
 3:   (*[omit:(private fields omitted)]*)
 4:   let mutable n = init(*[/omit]*)
 5:   member x.Increment = (*[omit:(...)]*)
 6:     n <- n + 1
 7:     n(*[/omit]*)
 8:   member x.Decrement = (*[omit:(...)]*)
 9:     n <- n - 1
10:     n(*[/omit]*)

The syntax of the meta-comments is again quite simple. One notable difference is that snippets are marked using a // comment that needs to be a single thing on the whole line. When specifying omission, we may want to specify a region that starts in the middle of a line and spans over a part of a line or over several lines and then ends somewhere in the middle of another line. To enable this, we need to use inline comments, which are written as (* ... *). In the starting tag, we specify the replacement text, so we can write [omit:<Replacement>]. Note that the replacement text doesn't have to be wrapped in parentheses (this is just a convention that I used in the previous example). The ending tag is simply written as [/omit].