Currently I’m trying to implement some of the standard monads in F#. If you want to read about the theory behind monads and their implementation (in Haskell) it’s a good start to look into “All about Monads” on haskell.org.
In this blog post series I don’t care about mathematical details. Instead I will try to show how monads can help to simplify our code.
Motivation
We have a generic binary tree with some test data:
type Tree<‘a> =
| Leaf of ‘a
| Branch of Tree<‘a> * Tree<‘a>
let tree =
Branch(
Leaf "Max",
Branch(
Leaf "Bernd",
Branch(
Branch(
Leaf "Holger",
Leaf "Ralf"),
Branch(
Leaf "Kerstin",
Leaf "Steffen"))))
If we want to print this tree we can use the following recursive function:
/// prints a binary tree
let printTree t =
let rec print t level =
let indent = new String(‘ ‘, level * 2)
match t with
| Leaf l -> printfn "%sLeaf: %A" indent l
| Branch (left,right) ->
printfn "%sBranch:" indent
print left (level+1)
print right (level+1)
print t 0
printfn "Unlabeled:"
printTree tree
And what we get is something like this:
Unlabeled:
Branch:
Leaf: "Max"
Branch:
Leaf: "Bernd"
Branch:
Branch:
Leaf: "Holger"
Leaf: "Ralf"
Branch:
Leaf: "Kerstin"
Leaf: "Steffen"
Labeling the tree with mutable state
Now we want to give every tree a unique label. This can be easily done by another recursive function:
let mutable label = -1
let rec labelTreeMS t =
match t with
| Leaf l ->
label <- label + 1 // changing the state
Leaf(l,label)
| Branch(oldL,oldR) ->
let newL = labelTreeMS oldL
let newR = labelTreeMS oldR
Branch(newL,newR)
let treeMS = labelTreeMS tree
printfn "Labeled (with global mutable state):"
printTree treeMS
And the output would look like this:
Labeled (with global mutable state):
Branch:
Leaf: ("Max", 0)
Branch:
Leaf: ("Bernd", 1)
Branch:
Branch:
Leaf: ("Holger", 2)
Leaf: ("Ralf", 3)
Branch:
Leaf: ("Kerstin", 4)
Leaf: ("Steffen", 5)
The only problem with labelTreeMS is that it uses global state, which is very bad because we can’t be sure if the mutable label variable is changed (from maybe another thread) or not.
Labeling the tree without global state
If we want to remove this side effect, we can pass the state directly into the function:
// non-monadic version
// passing the state around explicitly
let rec labelTreeNM t s =
match t with
| Leaf l -> s+1,Leaf(l,s) // changing the state
| Branch(oldL,oldR) ->
let stateL,newL =
labelTreeNM oldL s
let stateR,newR =
labelTreeNM oldR stateL // passing the state around
stateR,Branch(newL,newR)
let _,treeNM = labelTreeNM tree 0
printfn "Labeled (non-monadic):"
printTree treeNM
Labeling the tree by using the State Monad
With the help of the State Monad we get a very similar function:
/// labels a tree by using the state monad
/// (uses F#’s sugared syntax)
let rec labelTree t = state {
match t with
| Leaf l ->
let! s = getState
do! setState (s+1) // changing the state
return Leaf(l,s)
| Branch(oldL,oldR) ->
let! newL = labelTree oldL
let! newR = labelTree oldR
return Branch(newL,newR)}
printfn "Labeled (monadic):"
let treeM = Execute (labelTree tree) 0
printTree treeM
Thanks to the F# sugared syntax this labelTree and labelTreeMS are visually nearly the same. Every time we are dealing with state we use the exclamation mark. There is only one point (in the Leaf case) where have to use (and change) the state.
The nice thing is, that we can write the function like the first version, but we don’t have to perform the side effect on the shared state.
If we want to use the de-sugared version we have to write it like this:
/// labels a tree and uses de-sugared syntax
/// (implementation looks different to labelTreeNM)
let rec labelTreeDesugared t =
match t with
| Leaf l -> (fun s -> Leaf(l,s),(s+1))
| Branch(oldL,oldR) ->
labelTreeDesugared oldL >>=
(fun newL ->
labelTreeDesugared oldR >>=
(fun newR ->
Branch(newL,newR) |> returnS))
State monad implementation
In order to use the state monad, of course we have to implement it first. Here is my version, which allows to use the de-sugared and sugared version:
module StateMonad
let (>>=) x f =
(fun s0 ->
let a,s = x s0
f a s)
let returnS a = (fun s -> a, s)
type StateBuilder() =
member m.Bind(x, f) = x >>= f
member m.Return a = returnS a
let state = new StateBuilder()
let getState = (fun s -> s, s)
let setState s = (fun _ -> (),s)
let Execute m s = m s |> fst
If you want to learn more about the State Monad I recommend watching Brian Beckman’s Channel 9 video “The Zen of Stateless State – The State Monad".
Tags:
F#,
monad,
state monad
In the last article I showed how to filter and combine events via the Reactive Framework and how to deal with errors. This time we will create our own observables.
I got the idea for this sample from a very good Expert to Expert video (“Reactive Framework (Rx) Under the Hood”) with Erik Meijer and Wes Dyer.
We want to implement an asynchronous dictionary lookup. Whenever sometimes types something into the Textbox, our application starts looking into a dictionary and searches for words starting with the given prefix.
Let’s start with generating this simple form:
open System.Windows.Forms
let form = new Form(Visible=true, Text="Async dict",
TopMost=true)
let textBox1 =
new TextBox(
Location = new System.Drawing.Point(12, 12),
Size = new System.Drawing.Size(260, 20))
form.Controls.Add textBox1
let resultsBox =
new ListBox(
Location = new System.Drawing.Point(13, 39),
Size = new System.Drawing.Size(259, 211))
form.Controls.Add resultsBox
// create a list with common words
// this might be very large
let data =
["hell"; "Hello"; "Halle"; "Html";
"Bonn"; "Bonjour"; "Steffen"]
// create observable for text changes
let textChanged =
textBox1.TextChanged
|> Observable.map (fun _ -> textBox1.Text)
Now we have to define a base class for observables. This class will help our dictionary lookup function to use the IObservable<T> interface:
module Observable
/// A Observable base class which notifies
/// all observers in parallel
type ‘a Observable() =
let mutable observers = []
/// Notifies all observers in parallel about the new value
let notifyObservers f =
observers
|> Seq.map (fun (observer:IObserver<‘a>) –>
async { return f observer})
|> Async.Parallel
|> Async.RunSynchronously
|> ignore
interface IObservable<‘a> with
member observable.Subscribe(observer) =
// subscribe observer
observers <- observer :: observers
// create Disposable to unsubscribe observer later
{new IDisposable with
member this.Dispose() =
observers <-
observers |> List.filter ((<>) observer)}
/// Notifies all observers in parallel about the new value
member observable.OnNext value =
notifyObservers (fun observer -> observer.OnNext value)
/// Notifies all observers in parallel about the error
/// and finishes all observations
member observable.OnError error =
notifyObservers (fun observer -> observer.OnError error)
observers <- []
/// Notifies all observers in parallel about the completion
/// and finishes all observations
member observable.Completed =
notifyObservers (fun observer -> observer.OnCompleted())
observers <- []
I hope there will be a similar base class in the .NET Framework 4.0 RTM.
Now we are able to use this class and to build our dictionary lookup observable:
let wordsObservable = new Observable.Observable<_>()
let findWords prefix =
if prefix <> "" then
let prefix’ = prefix.ToUpper()
for word in data do
if word.ToUpper().StartsWith(prefix’) then
wordsObservable.OnNext (prefix,word)
The last step is to create observers and subscribe them to the observables:
// create observers
let clean =
textChanged
|> Observable.subscribe (fun _ -> resultsBox.Items.Clear())
let searchForWords =
// Every time the text changes
// we start our wordsObservable to push words
textChanged
|> Observable.subscribe (fun text -> findWords text)
let wordFound =
// subscribe to the "word found"-event
wordsObservable
|> Observable.subscribe
(fun (_,word) -> resultsBox.Items.Add word |> ignore)
Tags:
F#,
IObservable,
Reactive Framework,
Reactive Programming
One of the nice new features in .NET 4.0 beta 2 is the IObservable<T>/IObserver<T> support from the Reactive Framework (“Rx Framework” or sometimes “LinqToEvents”). It is a really powerful way to use reactive programming in .NET and especially in F# developed by Erik Meijer and his team.
If you want to see some of the beautiful math behind the Reactive Framework you should definitely watch this Expert to Expert video on Channel 9. You can see Brian Beckman and Erik Meijer showing that IObservable<T> is the mathematical dual of IEnumerable<T>.
What can I do with the Rx Framework?
Consider this small sample (it is taken from Matthew Podwysocki’s blog): We want to get notified whenever a user clicks on our form and moves the mouse within a special area (XPos and YPos smaller than 100px).
First of all we define our observable by merging and filtering .NET events:
open System.Windows.Forms
let form = new Form(Visible=true, TopMost=true)
/// Creates two observables
/// – left is triggered when the left mouse button is down
and the mouse is in the area (x < 100 && y < 100)
/// – right is triggered when the right mouse button is down
and the mouse is in the area (x < 100 && y < 100)
let left,right =
form.MouseDown
|> Observable.merge form.MouseMove
|> Observable.filter (fun args ->
args.Button = MouseButtons.Left ||
args.Button = MouseButtons.Right)
|> Observable.map (fun args -> args.X, args.Y, args.Button)
|> Observable.filter (fun (x,y,b) -> x < 100 && y < 100)
|> Observable.partition (fun (_,_,button) -> button = MouseButtons.Left)
Now it’s easy to subscribe a function to this observable:
let leftSubscription =
left
|> Observable.subscribe
(fun (x,y,_) -> printfn "Left (%d,%d)" x y)
If we want to unsubscribe we only have to dispose the object:
// unsubscribe
leftSubscription.Dispose()
We couldn’t unsubscribe this way with “classic” .NET events. Remember the –= operator in C# doesn’t work with lambda expressions.
Exception handling
We have seen an easy way to subscribe and unsubscribe to complicated observables but what should we do if an error occurs? As far as I know this case is not implemented for F# at the moment, but we can easily add this functionality:
module Observable
/// Creates an observer with the given functions
let createObserver next error completed =
{new System.IObserver<_> with
member this.OnCompleted() = completed()
member this.OnError(e) = error e
member this.OnNext(args) = next args}
/// Subscribes an observer with the given functions
/// param1: OnNext (T -> unit)
/// param2: OnError (Exception -> unit)
/// param3: OnCompleted (unit -> unit)
/// param4: observable
let subscribeComplete next error completed (observable:System.IObservable<_>) =
createObserver next error completed
|> observable.Subscribe
Now we are able to create a complete IObserver<T> object and register the 3 functions:
let rightSubscription =
right
|> Observable.subscribeComplete
(fun (x,y,_) -> printfn "Right (%d,%d)" x y)
(fun error -> printfn "Error: %s" error.Message)
(fun () -> printfn "Ready.")
Tags:
F#,
Reactive Framework,
Reactive Programming
Yesterday I released “FAKE – F# Make” version 0.14 with xUnit.net support. The usage is very easy and similar to the usage of NUnit:
Target "xUnitTest" (fun () ->
let testAssemblies =
!+ (testDir + @"\Test.*.dll")
|> Scan
xUnit
(fun p ->
{p with
ShadowCopy = false;
HtmlPrefix = testDir})
testAssemblies
)
This sample works perfectly with TeamCity and creates a html-page per test project in addition:
If you want to publish the xUnit.net test results in CruiseControl.NET just modify the build script a little:
Target "xUnitTest" (fun () ->
let testAssemblies =
!+ (testDir + @"\Test.*.dll")
|> Scan
xUnit
(fun p ->
{p with
ShadowCopy = false;
HtmlPrefix = testDir;
XmlPrefix = testDir })
testAssemblies
)
Now follow the steps in the CrusieControl.NET documentation. You will need to download the xUnitSummary.xsl file and save it to your webdashboard directory. If everything works correctly you should see something like this:
Tags:
CruiseControl.NET,
F#,
F-sharp Make,
Fake,
nunit,
xUnit.net. TeamCity
Last week I talked about F# and functional programming at .NET User Group Paderborn. Here are the dates for my upcoming F# talks:
Abstract (in german):
Funktionale Programmiersprachen nehmen seit geraumer Zeit einen hohen Stellenwert in der Wissenschaft ein. Demnächst könnte es eine dieser Sprachen sogar aus dem Forschungsbereich direkt in den Mainstream schaffen. Visual Studio 2010 wird neben C# und VB.NET die funktionale Programmiersprache F# als dritte Hauptsprache anbieten. Der Vortrag soll einen Einblick in funktionale Konzepte und deren Umsetzung in F# geben. Insbesondere soll auf “Funktionen höherer Ordnung”, Typinferenz, Currying, Pattern Matching, “Unveränderlichkeit” und parallele Programmierung eingegangen werden.
Tags:
.NET User Group Hamburg,
.NET User Group Paderborn,
.NET Usergroup Frankfurt,
Bonn-To-Code.NET,
F#
Since version 0.12 the FAKE build system provides an easy way to setup build configurations for CruiseControl.NET.
“CruiseControl.NET is an Automated Continuous Integration server, implemented using the Microsoft .NET Framework.”
[thoughtworks.org]
In this article I will show you how you can set up a FAKE build script in CruiseControl.NET. We will use the CalculatorSample which you can download from the FAKE Download page.
If you want to know how this build script works and how you could create one for your own projects please read the “Getting started with FAKE”-tutorial.
If you want to set up “FAKE – F# Make” build configurations in TeamCity please read “Integrating a "FAKE – F# Make" build script into TeamCity”.
Installing CruiseControl.NET
You can download CruiseControl.NET from thoughtworks.org. After the installation process (further instructions) you should see an empty dashboard:
Installing Subversion
The CalculatorSample is using Subversion (SVN) for SourceControl, so we need to download SVN from subversion.tigris.org. I’m using the “Windows MSI installer with the basic win32 binaries” and installed them under “c:\Program Files (x86)\Subversion\”.
Installing FxCop
The CalculatorSample is using FxCop, so we need to download and install it next.
“FxCop is an application that analyzes managed code assemblies (code that targets the .NET Framework common language runtime) and reports information about the assemblies, such as possible design, localization, performance, and security improvements. Many of the issues concern violations of the programming and design rules set forth in the Design Guidelines for Class Library Developers, which are the Microsoft guidelines for writing robust and easily maintainable code by using the .NET Framework.”
[MSDN]
Creating a FAKE Project
Now create a new folder for the CalculatorSample sources. I’m using “d:\Calculator\” for the rest of the article.
The next step is to modify the CruiseControl.NET config file (“c:\Program Files (x86)\CruiseControl.NET\server\ccnet.config” on my machine):
<cruisecontrol>
<project>
<name>CalculatorExample</name>
<triggers>
<intervalTrigger name="continuous" seconds="30" initialSeconds="30"/>
</triggers>
<sourcecontrol type="svn">
<executable>c:\Program Files (x86)\Subversion\bin\svn.exe</executable>
<workingDirectory>d:\Calculator\</workingDirectory>
<trunkUrl>http://fake.googlecode.com/svn/trunk/Samples/Calculator/</trunkUrl>
</sourcecontrol>
<tasks>
<exec>
<executable>d:\Calculator\tools\Fake\Fake.exe</executable>
<baseDirectory>d:\Calculator\</baseDirectory>
<buildArgs>completeBuild.fsx</buildArgs>
</exec>
</tasks>
<publishers>
<merge>
<files>
<file>d:\Calculator\test\FXCopResults.xml</file>
<file>d:\Calculator\test\TestResults.xml</file>
<file>d:\Calculator\output\Results.xml</file>
</files>
</merge>
<xmllogger />
</publishers>
</project>
</cruisecontrol>
In this configuration I set up a trigger which checks every 30 sec. for changes in my CalculatorSample project.
If SVN finds changes FAKE.exe is called with my build script (completeBuild.fsx).
After the build I want to merge the FxCop and NUnit output files with my build results to create a build report.
Configuring the dashboard
In order to provide a nicer output on the dashboard we need to modify the BuildPlugins section in the dashboard.config file (“c:\Program Files (x86)\CruiseControl.NET\webdashboard\dashboard.config” on my machine):
<buildPlugins>
<buildReportBuildPlugin>
<xslFileNames>
<xslFile>xsl\header.xsl</xslFile>
<xslFile>xsl\modifications.xsl</xslFile>
<xslFile>xsl\NCoverSummary.xsl</xslFile>
<xslFile>xsl\fxcop-summary_1_36.xsl</xslFile>
<xslFile>xsl\unittests.xsl</xslFile>
<xslFile>xsl\nant.xsl</xslFile>
</xslFileNames>
</buildReportBuildPlugin>
<buildLogBuildPlugin />
<xslReportBuildPlugin
description="NCover Report"
actionName="NCoverBuildReport"
xslFileName="xsl\NCover.xsl"></xslReportBuildPlugin>
<xslReportBuildPlugin description="FxCop Report"
actionName="FxCopBuildReport"
xslFileName="xsl\fxcop-report_1_36.xsl" />
<xslReportBuildPlugin description="NUnit Report"
actionName="NUnitBuildReport"
xslFileName="xsl\tests.xsl" />
</buildPlugins>
As you can see we use the nant.xsl to transform the FAKE output to HTML.
Starting the build
Now if everything is configured correctly, you can tell CruiseControl.NET to run your build (press “Start” for your build project on the dashboard):
Now CruiseControl.NET should use SVN to checkout the CalculatorSample sources and run the build. The output on the project page for build 1 should look like this:
You can also inspect the NUnit and FxCop results:
Please feel free to give feedback if you have any problems with this article.
Tags:
CC.NET,
Continuous Integration,
CruiseControl,
CruiseControl.NET,
F#,
F-sharp Make,
Fake
Today I had some trouble to redirect the default and error output from a created process. So here is my final solution:
open System.Diagnostics
open System.Threading
// outputF: string -> unit
// errorF: string -> unit
let runProcess outputF errorF =
use p = new Process()
p.StartInfo.UseShellExecute <- false
// …
p.StartInfo.RedirectStandardOutput <- true
p.StartInfo.RedirectStandardError <- true
p.ErrorDataReceived.Add
(fun d –> if d.Data <> null then errorF d.Data)
p.OutputDataReceived.Add
(fun d –> if d.Data <> null then outputF d.Data)
p.Start() |> ignore
p.BeginErrorReadLine()
p.BeginOutputReadLine()
p.WaitForExit()
p.ExitCode
Tags:
F#,
Process
I just released a new version of my Open Source Build Automation Framework “FAKE – F# Make”. You can read more about FAKE on the project website or in the Getting started with "FAKE – F# Make"-article.
Although the new release contains many bugfixes, I only want to show the two major improvements here.
1. FAKE 0.10 uses FSI instead of FSC
From now on FAKE uses the “F# Interactive” (fsi.exe) instead of the F# Compiler (fsc.exe) to run the build scripts, which brings two major improvements.
No TempPath for compiled binaries needed
Due to the fact that FAKE scripts are no longer compiled at the beginning of the build process, we don’t need a temporary folder for the created binaries.
Loading modules at runtime
The #load command in F# scripts allows us to load modules at runtime. Now we are able to put reusable Targets or TargetTemplates (see below) into external build script files.
2. TargetTemplates
TargetTemplates provide an easy way to reuse common Targets. Let’s consider a (very) small sample:
Target "TraceHello" (fun () ->
trace "Hello World from FAKE"
)
This Target “TraceHello” traces a “Hello World” string into our build log. Now we want it to be slightly more generic and to trace a custom string. We can do this by using a TargetTemplate:
/// createTraceTarget: string -> string -> Target
let createTraceTarget = TargetTemplate (fun s ->
trace s
)
Now we have a template (or a function which generates targets) that gets a string for the target name and a string for the trace text and generates a usable target:
createTraceTarget "TraceHello" "Hello World from FAKE"
createTraceTarget "Trace2" "Trace another text"
Of course the TargetTemplate function is generic and can be used with any tuple as parameter:
/// createTraceTarget: string -> string*int -> Target
let createTraceTarget = TargetTemplate (fun (s,d) ->
trace s
trace <| sprintf "my int: %d" d
)
createTraceTarget "TraceHello" ("Hello World from FAKE",2)
createTraceTarget "Trace2" ("Trace another text",42)
Tags:
F#,
F#,
F-sharp Make,
Fake
