Phillip Trelford's Array

POKE 36879,255

Foq 1.6

Foq is a mature open source .Net mocking library written in F#. It’s raison d'être is to enable F# as a unit testing language, for F#, C# or VB.Net code bases.

Foq is part a rich set of testing tools available to F# developers. Use Foq when unit testing in combination with staple .Net testing frameworks like NUnit and xUnit through to F# specific fluent assertion libraries like FsUnit and Unquote. Combine Foq with AutoFixture to simplify test setup even further.

The name Foq is derived from Moq, with Foq providing a familiar fluent interface:

// Moq from C#
var mock = new Mock<ILoveThisFramework>();
mock.Setup(framework => framework.DownloadExists(""))
ILoveThisFramework lovable = mock.Object;

// Foq from F#
let lovable = 
      .Setup(fun framework -> <@ framework.DownloadExists("") @>)

The main difference in the setups above is that Moq uses mutation where as Foq is thread safe, favouring method chaining to build an immutable representation of the type.

Foq takes advantage of F#’s code quotations and type inference for shorter setups:

// Mock succinctly with Foq
let lovable =
   Mock.With(fun (framework:ILoveThisFramework) ->
   <@ framework.DownloadExists("") --> true @>)

Getting Started

Get the latest version of Foq from Nuget or simply include Foq.fs in your test project. An F# script packed with examples is included when you install Foq via Nuget.

Then take a peek at some of the many Foq testing examples on CodePlex:

    New features

Back in April 2013, Foq’s API stabilized at version 0.9, since then new features and bug fixes have been requested via CodePlex, StackOverflow and Twitter.

Many of the requests have come from people testing C# codebases from F# and requiring extensive support for:

Testing C# Code

Foq can be used to mock both interfaces and abstract classes. For abstract classes arguments can be passed to the base constructor when the mock is created:

let mock = Mock<AbstractBaseClassWithConstructorArgs>().Create(7, "seven")
Assert.AreEqual("seven", mock.Name)

In F# multiple return values are easily specified using tuples, in C# out parameters are required. To setup C# methods with out parameters using Foq, simply specify the out arguments as tuples as you would normally from F#:

// Calling a method with out arguments from F#
let (success, value) = dict.TryGetValue("Fred")
// Setting up a method with out arguments using Foq
   .SetupByName("TryGetValue").Returns((true, 1))

Testing Events

In F# events are first class, meaning they can be created like objects and passed to functions. To setup an event on an interface:

// Arrange
let event = Event<_,_>() 
let instance = 
         .SetupEvent(fun x -> <@ x.PropertyChanged @>).Publishes(event.Publish) 
// Act 
event.Trigger(instance, PropertyChangedEventArgs("Name"))

Non-standard events can be setup using the SetupEventByName method.

Testing F# Code

Foq provides helpers for quickly mocking a single member be it a property:

Mock<MyAbstractBaseClass>.Property(fun x -> <@ x.MyProperty @>).Returns(1)

or a method (note that arguments do not need to be specified):

    .Method(fun gt -> <@ gt.GetGreeting @>)
    .Returns("Good Night")

Foq can now mock F# specific members with curried arguments e.g.

    .Setup(fun curry -> <@ curry.Fun (any()) (any()) @>)

Finally Mock.With now supports return values via functions:

Mock<IFoo>.With(fun foo -> 
        foo.Bar(1) --> 1
        foo.Bar(any()) ---> fun () -> 2

What next?

Try F# as a testing language for your .Net code bases and use Foq to mock F# and C# types with ease. Then try web testing with canopy, automated acceptance testing using NaturalSpec, TickSpec or SpecFlow or random testing via FsCheck.

Parsing C#

C# is a mainstream programming language based on Java, that runs on Windows via .Net and cross platform via Mono. On .Net , C# is used primarily in the enterprise for web and desktop applications. With Mono, C# can target a range of popular platforms including iOS and Andriod, and is primarily employed in mobile application development via Xamarin’s tools and game development via Unity.

Microsoft’s current shipping C# compiler is proprietary code written in C++. Mono’s C# compiler, is open source and written in C#. In 2008 Microsoft announced the development of a new proprietary C# compiler written in C#, codenamed Roslyn, with the last preview released back in 2012. One of Roslyn’s key aims to expose the output of the parser as an abstract syntax tree (AST) that can be inspected by third party developers for tooling.

To fill the void, it feels like every man and his dog has written a parser for C#, most commonly to provide developer productivity tools in Visual Studio.

Third party vendors with C# parsers include:

On the open source side, Irony is a particularly interesting project allowing grammars to be specified in C# and includes samples for parsing many languages including C# and Java.

Parsing C#

You can think of C# and Java as managed C with classes. That is C# at it’s core is an imperative programming language, composed of statement blocks with additional syntax for class declaration and a dot operator for invoking members on a class.

Under the hood instance members simply take the instance as the first argument:

C C#
struct Point { 
  float X; float Y; 
float length(Point p) {
  return sqrt(p.X*p.X + p.Y*p.Y);
class Point {
  float X; float Y;
  public float Length() {
    return Math.Sqrt(X * X + Y * Y);

The dot operator is probably *the* killer feature of class based languages like Java and C# as it allows developers to explore existing APIs via code completion in an IDE.

Parsing C# statements is not hugely dissimilar to parsing Small Basic statements which I have covered in a recent article. The only real difference is that C style languages typically employ semicolons between statements and curly braces to delimit statement blocks.

Parsing C# files involves finding using directives and namespace blocks. Then inside the namespace blocks finding type blocks including class, interface, struct, enum and delegate constructs. Inside the class blocks the member fields, properties, methods and constructors. Finally inside the members the statement blocks.

A few weeks back I was stuck on a a slow running train for a couple of hours, and had a go at writing a simple C# parser in F# using discriminated unions for the abstract syntax tree (AST) and FParsec for parsing. The same approach I’d used to parse Small Basic. I managed to sketch out a rough AST and a parser for namespaces and class declarations with around 100 lines of code. After a few more train journeys I managed to cover members and statement blocks, getting close to parsing C# 1.1. The prototype C# AST and parser is available as an F# snippet that can be run as a script inside F# interactive.

As an aside Neil Danson has recently constructed a compiler for the AST in F# that builds .Net assemblies. Basically this requires a number of passes, including building classes and members and then emitting IL code for statements, which is mostly a one-to-one mapping.


The smallest building block in the AST is an expression which includes values, variables, member invocations and operators:

type Expr = 
    | Value of Literal
    | Variable of VarName
    | MethodInvoke of MemberName * Arg list
    | PropertyGet of MemberName
    | Cast of TypeName * Expr
    | InfixOp of Expr * string * Expr
    | PrefixOp of string * Expr
    | PostfixOp of Expr * string
    | TernaryOp of Expr * Expr * Expr

Then comes statements including the standard imperative loops and control flow:

type Statement =
    | Assignment of Init
    | PropertySet of MemberName * Expr
    | Action of Expr
    | If of Expr * Block
    | IfElse of Expr * Block * Block
    | Switch of Expr * Case list
    | For of Init list * Condition * Iterator list * Block
    | ForEach of Define * Expr * Block
    | While of Expr * Block
    | DoWhile of Block * Expr
    | Throw of Expr
    | Try of Block
    | Catch of TypeName * Block
    | Finally of Block
    | Lock of Expr * Block    
    | Using of Expr * Block
    | Label of LabelName
    | Goto of LabelName
    | Break
    | Continue
    | Return of Expr

Statements are organized inside members with a myriad of optional modifiers:

// Modifiers
type Access = Public | Private | Protected | Internal
type Modifier = Static | Sealed | Override | Virtual | Abstract
type ParamType = ByValue | ByRef | Out | Params 
// Members
type Member =
    | Field of Access * Modifier option * IsReadOnly * 
               ReturnType * Name * Expr option
    | Property of MemberInfo * Block option * Block option
    | Method of MemberInfo * Param list * Block
    | Constructor of Access * Modifier option * Name * Param list * 
                     PreConstruct option * Block

Members are organized inside types:

type CSharpType = 
    | Class of Access * Modifier option * Name * Implements * Members
    | Struct of Access * Name * Member list
    | Interface of Access * Name * Implements * Member list
    | Enum of Access * TypeName * EnumValue list
    | Delegate of Access * Name * ReturnType * Param list    

Types are optionally organized inside namespaces:

type Import = 
    | Import of Name list
    | Alias of Name * Name list
type NamespaceScope =
    | Namespace of Import list * Name list * NamespaceScope list
    | Types of Import list * CSharpType list

You can see the full source for the AST and parser in the F# snippet.


The basic structure of the parser is very similar to the Small Basic parser implementation. The main difference I found is that C# has a lot more syntactic noise to support classes.

As an example the following code fragment parses property declarations:

let pget = str_ws "get" >>. pstatementblock
let pset = str_ws "set" >>. pstatementblock
let ppropertyblock =
    between (str_ws "{") (str_ws "}") ((opt pget) .>>. (opt pset))
let pproperty = 
    pipe2 pmemberinfo ppropertyblock
     (fun mi (gblock,sblock) -> Property(mi,gblock,sblock))

Building with FParsec iteratively in F# interactive made light work of sketching out a parser and refining the AST.


In the spirit of build one to throw away from the Mythical Man Month, it feels like the combination of F# and FParsec is ideal for quickly putting together an AST and proving it with a working prototype parser. Which I feel would be a good approach to take if you wanted to build a production C# compiler in a timely manner.

Sketching out an AST and parser has been an interesting, but not overly taxing exercise and has given me a few insights into C#’s syntax. My overriding feeling is that the original layout of the language was more influenced by ease of parsing than ease of use for the developer, with minimal type inference, and the use of constructs like ref and out parameters over support for returning multiple values via tuples.

C#’s var keyword gives simple type inference for local variables, however given the type of the right hand expression is already known inference here seems like a nop.

I don’t plan to take the C# parser any further, there is already a lot of offerings out there in this space. But if you’re interested in understanding how imperative languages can be constructed I think it’s probably a fun exercise to try.

Øredev 2013

Last week I travelled to Malmö in Sweden for Øredev, a large well established annual conference primarily covering enterprise development practices from programming to agile.

The first night at the event was probably the most surreal I’ve experienced at a developer conference. It began with a keynote from XKCD creator Randall Munroe covering their increasingly elaborate April fools’ day pranks and turning his lounge into a ball pit.


Then, along with Rachel Reese, Julie Lerman, Iris Classon and some enthusiastic locals, I found myself in a boxing ring at the hotel watching an impressive impromptu display of acroyoga and slacklining.

slack lining

The night continued on in to the early hours hacking F# with Iris, which attracted a small crowd of interested onlookers. Iris picked up F# really quickly and by the end of the night she had put together a great solution to a Kaggle machine learning competition task, while still finding time to squeeze in some tango dancing.


In the morning I woke to the entire room shaking, to the point that I thought the TV was going to come off the wall, later I learnt I was sleeping below the running machines in the gym.

Just about everyone at the conference was staying in the same hotel, just around the corner from the venue, which made it a very fun social event. It was really nice to catch up with Ashic Mahtab, Torbjörn Gyllebring and Paul Stack, and finally meet in person Jessica Kerr, Bodil Stokke, Richard and Carl from .Net Rocks, Shay Friedman and Steve Klabnik, to name just a few.

It was Rikard Ottosson who kindly invited me to give two talks at the conference, first F# Eye for the C# Guy and then F# for Trading. All the sessions were recorded and most are already available online. For some more functional love I’d highly recommend watching Rachel Reese, Bodil Stokke and Jessica Kerr’s talks.

F# Eye for the C# Guy

I first presented this talk at DDD Belfast back in 2011, and somehow it got a mention on Microsoft’s Channel 9! Since then it’s taken me to Seattle, San Francisco, Cambridge (twice), London, Norwich, Sunderland and now Malmö. Each one is slightly different but the overall theme has remained constant.

The title was borrowed from a presentation by Leon Bambrick made in 2008, and the F# logo complete with unicorn is courtesy of Chris Smith who is also responsible for the faux art work on the Learning F# 1.0 book. The not entirely genuine F# 3.0 in Action cover is all my own doing.

In the live demos I take an immutable C# class and transform it into equivalent F#, to show some of the syntactic differences. Then the focus turns to unit testing with NUnit, FsUnit, Unquote and Foq, followed by automated acceptance testing with TickSpec.

From there the focus switched to Type Providers including FSharp.Data’s JSON provider. Then accessing data from the World Bank and presenting it in a web page with High Charts using Tomas Petricek’s FunScript sample.

It was great to get a lot of questions at the end:


and some really encouraging feedback on Twitter:

The F in F# stands for fun. It's actually a keyword." - @ptrelford :) #oredev

Best talk so far F# for C# developers! Thanks @ptrelford #oredev

F# for Trading

After seeing a video of Rich Hickey’s Simple made Easy talk at Stangeloop back in 2011, I really wanted to make it to the next event, and submitted F# for Trading. I was both hugely grateful and a little surprised that it was accepted and was able to attend what is a fantastic alternative conference. Since then I’ve presented variants in San Francisco, New York, London and Amsterdam.


Thanks again to Torbjörn for the nice quotes he put up on Twitter during the session:

When you look at a language you will also get a community, with a special feel and specialization. ~ @ptrelford #oredev

Non programmers learn F# easily. Those with OOP background need to spend time un-learning first. ~ @ptrelford #oredev

The real performance gains are found by having time finding better algorithms. F# frees time up for that. ~ @ptrelford #oredev

Immutability and strong typing let's me relax and be confident things will work ~ @ptrelford #oredev ergonomics matter.

Yes, @ptrelford did just intellisense his way through open World Bank data. That's what F# type providers enables. #oredev

And to Rikard for inviting me over and to the whole Øredev team for putting on a fantastic event.

The fun continues over the coming weeks, next up I’ll be at: