Visual F# Team Blog

F# on FreeBSD

2013-05-13T10:42:00Z

Through Jack Pappas, the F# Software Foundation (the F# community group also known as fsharp.org) has recently made F# more readily available on FreeBSD. Some details below, taken from the discussion on the F# Open Source Google Group.

Since my original post, I've been contacted by a few people who wanted to try F# on FreeBSD but didn't know how to set it up (or who ran into trouble when they tried). So, I spent a couple of hours last weekend writing up detailed instructions for installing Mono 3.0, F# 3.0, and emacs on FreeBSD, and they're now available on fsharp.org:

http://fsharp.org/use/freebsd/

I tested the instructions on a fresh installation of FreeBSD 9.1-RELEASE (32-bit) in VirtualBox on 64-bit Windows 7, and everything worked as it should. If you try the instructions -- and you should :) -- and run into problems, please start a new thread here on the mailing list and I'll help you get it fixed. (In this case, conversing on the mailing list is preferable so the solution is available to everyone.)

Enjoy!

The Visual F# Team

F# for Machine Learning - a Gentle Introduction and Coding Dojo

2013-05-08T10:35:02Z

If you're in the Bay Area, don't miss F# for Machine Learning - a Gentle Introduction and Coding Dojo on Tuesday, May 14 at 6:00pm.

The F# Software Foundation also have a collection of links about F# and Machine Learning, as well as related topics including F# and Data Science and F# options for Maths and Statistics.

Machine Learning is the art of writing programs that get better at performing a task as they gain experience, without being explicitly programmed to do so. Feed your program more data, and it will get smarter at handling new situations.

Some machine learning algorithms use fairly advanced math, but simple approaches can be surprisingly effective. In this Session, we'll take a classic Machine Learning challenge from Kaggle.com, automatically recognizing hand-written digits (http://www.kaggle.com/c/digit-recognizer), and build a classifier, from scratch, using F#. So bring your laptop, and let's see how smart we can make our machines!

This session will be organized as an interactive workshop. Come over, and learn yourself a Machine Learning and F# for great good! No prior experience with Machine Learning required, and F# beginners are very welcome - it will be a great opportunity to see F# in action, and why it's awesome.

To get the most from the session please try and bring a laptop along with F# installed (ideally either MonoDevelop, Xamarin Studio or Visual Studio Web Express/Full Edition).

Note: we'll have pizzas and drinks for this event!

Full details here, location Microsoft, 835 Market St Ste 700,San Francisco,CA(map)

Seattle DotNet Startup Group: F# for Startups, Tuesday June 11 2013

2013-05-08T10:27:54Z

If you're in Seattle, Redmond or the Puget Sound Area, don't miss the Seattle DotNet Startup Group session on F# for Startups.

Joel Grus is Chief Scientist at VoloMetrix, where he develops and builds the algorithms for the core analytics platform (mostly in F#). Previously he worked in data science roles at Decide, Bing, and Farecast. He has degrees in math and economics, but he sort of wishes he'd studied computer science instead.

Agenda:

6:00 - 6:45 PM: Pizza, beer & Networking
6:45 - 7:00 PM: Intro & 15-seconds intros
7:00 - 7:45 PM: Joel Grus
7:45 - 8:15 PM: Networking

F# and QuantLib: An Introduction

2013-04-23T12:38:00Z

A Guest Blog in conjunction with Alexandre Radicchi (alex.radi@gmail.com)

F# is an attractive language to use in Financial Engineering because of its functional-first methodology, succinctness, strong typing, data-integration, stability, maturity, tooling and performance, as well as its supported editions in Visual Studio, its open-source edition, its cross-platform execution and its widespread availability. You can learn more about using F# for Financial Engineering through the excellent tutorials on Try F#.

QuantLib represents a unique project in the Financial Engineering panorama because of its maturity and of the vast quantity of tools implemented, all for free. In many situations it represents a sensible choice especially when starting a new project from scratch. QuantLib is written in C++ but wrappers to many other languages exist. You can take a look at the project home page for further information. The majority of these wrappers are implemented using SWIG.

This blog post explores how to use F# in conjunction with QuantLib.

Preparing to access QuantLib

To access QuantLib on Windows we need two DLLs: NQuantLib.dll (a .NET component) and NQuantLibc.dll (a native component). If working in a financial institution these may already be available to you. If not, the native component is built from .lib files, in turn built from C++ source and C++ header files:

Install Boost to get the .lib and header files Boost (or build the source in the official repositories for Boost or BoostPro).
Get and build QuantLib to build the .lib and header files for QuantLib (With VS2012, see these instructions, and reportedly you may need this fix to auto_link.hpp, see also the comment from pmcs below).
Download the QuantLib-SWIG zip file from the official repository (browse to the *other languages* directory on the QuantLib sourceforge repository).
Download SWIG and setup your environment so that the swig executable is visible.
Run the swig.cmd file located on the QuantLib-SWIG\CSharp directory. This will generate the C++ wrapper file.
Build NQuantLibc.dll and NQuantLib.dll using the given Visual Studio project.

Once done, place the NQuantLib.dll and NQuantLibc.dll in a directory under your F# scripting directory called references. If using a project then add NQuantLibc.dll as a file to the project and set to "Copy to Output" to "Copy if Newer"

The steps are slightly different if you need to compile for Mono. The following these steps targets Ubuntu/Linux:

Download Boost, compile and install it (./configure && make && sudo make install) or install it from package (e.g. sudo apt-get install libboost).
Install Swig using the package manager (sudo apt-get install swig) or download, compile and install it from sources.
Download QuantLib has seen before, uncompress it and launch ./configure && make && sudo make install.
Download QuantLib-SWIG, uncompress it and launch ./configure && make -C CSharp && sudo make install.
At this point you will end up with two libraries, the unmanaged one libNQuantLibc.so and the Mono wrapper NQuantLib.dll. As with the Windows libraries the managed extension must be able to invoke the unmanaged library.

Now let's F# QuantLib

Let's now compute something with our freshly compiled NQuantLib.dll.

We start by doing some F# scriptin from Visual Studio (or MonoDevelop, or Xamarin Studio, or whatever text editor you want).

When using F# Interactive you may need to set Tools --> Options --> F# Tools --> F# Interactive --> 64-bit --> False, or else build a 64-bit version of QuantLib.

In this first example we will create a simple QuantLib Date object containing the today's date and send its ISO string representation to the standard output.

#I "references"

#r "NQuantLib.dll"

let date = QuantLib.Date.todaysDate()

printfn "today is: %s" (date.ISO())

The output of this function on the fsharp interactive console is:

today is: 2013-03-24

Example 2: Pricing a Strip of European Call Options

In the next example we write a more financially meaningful example by computing the prices of a strip of European Call options. First of all, we define a series of hypothetical market observables (the underlying asset spot price, its implied volatility, a reference risk-free rate and a flat dividend yield) and then instantiate, for each strike, a *PlainVanillaPayoff* and a *BlackCalculator*. Then we call the *value* method which returns the price of each option.

open QuantLib

let T = 3.0

let r, divYield, vol = 0.01, 0.03, 0.5

let stdev = vol* sqrt T

let discount = exp (-r*T)

let spot = 100.0

let forward = spot * exp ((r-divYield)*T)

let strikes = [|10.0..10.0..200.0|]

for strike in strikes do

use payoff = new PlainVanillaPayoff(Option.Type.Call,strike)

use bcalculator = new BlackCalculator(payoff,forward,stdev,discount)

printfn "strike: %.5f, price: %.5f" strike (bcalculator.value())

The output of this script is:

strike: 10.0, price: 81.72475

strike: 20.0, price: 72.48247

strike: 30.0, price: 64.10232

strike: 40.0, price: 56.71391

strike: 50.0, price: 50.27881

strike: 60.0, price: 44.69816

strike: 70.0, price: 39.86036

strike: 80.0, price: 35.65964

strike: 90.0, price: 32.00237

strike: 100.0, price: 28.80815

strike: 110.0, price: 26.00889

strike: 120.0, price: 23.54731

strike: 130.0, price: 21.37533

strike: 140.0, price: 19.45254

strike: 150.0, price: 17.74493

strike: 160.0, price: 16.22378

strike: 170.0, price: 14.86477

strike: 180.0, price: 13.64725

strike: 190.0, price: 12.55360

strike: 200.0, price: 11.56872

This example is a simplification of reality in which we would use more complex structures such as:

yield curves instead of flat yield/dividend rates;
volatility surfaces instead of flat volatility value;
multi-payment or Bermudian payoffs;
multi-factorial models, and so on.

A lot of these features are already implemented into QuantLib and many of them are accessible through the .NET wrapper. See the reference manual for a full list of functionalities. You can also take a look at the Book which is a work in progress.

Example 3: Dates and Schedules

As a third example we use the Schedule class which, given a set of rules and a calendar, generates a list of dates. In this particular example, we tell Schedule to generate the set of dates starting from 2012-1-1 ending 3 years later with a 3 month interval. The dates are rolled forward if they corresponds to non-business days on the Target calendar.

First we add an extension member to act as a helper when converting dates:

open System

[<AutoOpen>]

module Conversion =

type DateTime with

member dt.AsQL = new Date(dt.ToOADate() |> int)

Now we set up our Schedule:

let today = new DateTime(2012,1,1)

let startdate = today.AsQL

let enddate = today.AddYears(3).AsQL

let tenor = new QuantLib.Period("3M")

let convention = QuantLib.BusinessDayConvention.ModifiedFollowing

let termination = convention

let eomonth = false

let scheduler = new QuantLib.Schedule(startdate,

enddate,tenor,new QuantLib.TARGET(),

convention,termination,

QuantLib.DateGeneration.Rule.Forward,

eomonth)

for i in [0u..scheduler.size()-1u] do

printfn "date.[%d] = %s" i <| scheduler.date(i).ISO()

The output of this script is

date.[0] = 2012-01-02

date.[1] = 2012-04-02

date.[2] = 2012-07-02

date.[3] = 2012-10-01

date.[4] = 2013-01-02

date.[5] = 2013-04-02

date.[6] = 2013-07-01

date.[7] = 2013-10-01

date.[8] = 2014-01-02

date.[9] = 2014-04-01

date.[10] = 2014-07-01

date.[11] = 2014-10-01

date.[12] = 2015-01-02

Using 'use'

Because QuantLib objects are generally native objects, you may need to use 'use' to ensure correct deterministic disposal of these objects. This doesn't apply so much to data scripting but more in project files. For example inside a function do this:

use date = QuantLib.Date.todaysDate()

Exploring Further

QuantLib contains a very large amount of functionality. An idea of the range of functionality can be seen from the following prefix of the tests run when building QuantLib. To explore further, see the reference manual for a full list of functionalities or the Book.

14> Testing Barone-Adesi and Whaley approximation for American options...

14> Testing Bjerksund and Stensland approximation for American options...

14> Testing Ju approximation for American options...

14> Testing finite-difference engine for American options...

14> Testing finite-differences American option greeks...

14> Testing finite-differences shout option greeks...

14> Testing array construction...

14> Testing analytic continuous geometric average-price Asians...

14> Testing analytic continuous geometric average-price Asian greeks...

14> Testing analytic discrete geometric average-price Asians...

14> Testing analytic discrete geometric average-strike Asians...

14> Testing Monte Carlo discrete geometric average-price Asians...

14> Testing Monte Carlo discrete arithmetic average-price Asians...

14> Testing Monte Carlo discrete arithmetic average-strike Asians...

14> Testing discrete-averaging geometric Asian greeks...

...

Summary

In summary, using F# with QuantLib is straight-forward once QuantLib is installed.

QuantLib is the most advanced open source library for Financial Engineering;
Interfacing it with F# is quite easy;
We can potentially extend the set of exposed classes through SWIG;
F# is well fitted for Financial applications.

Along the way, some routine code has to be written to instantiate QuantLib classes.

We hope you enjoy using F# with QuantLib. If you are interested in connecting with other users of this combination, please email Alexandre, join the QuantLib group and/or the F# Software Foundation and associated community groups.

Don Syme and Alexandre Radicchi

F# + GPGPU - Financial Services Developer Forum (.NET in the City) - Thursday 16th May 2013

2013-04-17T14:42:00Z

Join our Microsoft Developer Evangelist Team, and Financials Services Account team, at the next Developers and Architects Forum for the Finance Sector. Come together to talk all things Microsoft and development with peers across the industry

This exclusive Microsoft event is aimed at Developers and Architects from the Financial Services sector, providing an opportunity to learn about some of the new developer capabilities, and best practices, designed to help drive leading edge Microsoft Applications

Combining the computational power of GPUs with the functional elegance of F#, Dr Daniel Egloff from QuantAlea (www.quantalea.net)will talk about, and demo, F#, building CUDA accelerated GPU applications by compiling F# code to an executable GPU code. Maximising application performance with GPU acceleration is a hot topic and Daniel has successfully applied F# on GPUs in productive systems for derivative pricing, risk calculations and statistical analysis.

An Update to the F# Microsoft Dynamics CRM Type Provider Sample

2013-04-11T19:05:00Z

[ The CRM type provider sample is available as the FSharpx.TypeProviders.Xrm NuGet package. The namespace has changed from "Samples" to "FSharpx" The updates below are in the process of being transferred into FSharpx package ]

Part 1 - The Microsoft Dynamics CRM Type Provider Sample
Part 2 - The Microsoft Dynamics CRM Type Provider Sample - Static Parameters
Part 3 - The Microsoft Dynamics CRM Type Provider Sample - Updated Functionality

An update of the Microsoft Dynamics CRM type provider sample is now available. The new features from this update are demonstrated below.

CRUD Operations

You are now able to create entities and set their attributes using the properties provided by the type provider. The OrganizationService instance is exposed so that you can pass entities to the relevant create / update / delete methods. You can create entities either by calling the Create method on the relevant entity set, or you can call the constructor of the provided entity type from within the XrmService type.

let account = XRM.XrmService.account()
let account2 = dc.accountSet.Create()

account.name <- "John"
account2.name <- "Juan"

account.accountid <- dc.OrganizationService.Create account
account2.accountid <- dc.OrganizationService.Create account2

account.name <- "Jean"
dc.OrganizationService.Update account

dc.OrganizationService.Delete(account.LogicalName,account.accountid)
dc.OrganizationService.Delete(account2.LogicalName,account2.accountid)

Explicit Joins

You are now able to use the standard join syntax in the query expressions. This syntax is not supported when combined with the select many syntax, you must choose one or the other for the query.

let (contactName,accountName,leadName) =
     query{ for a in dc.accountSet do
            join c in dc.contactSet on (a.primarycontactid.Id = c.contactid)
            join l in dc.leadSet on (a.originatingleadid.Id = l.leadid)
            select (c.fullname, a.name, l.fullname )
            exactlyOne }

There is no support for outer joins using this syntax – the recommended approach is to use the select many syntax directly over the relationships where you can use the outer join operator (!!) if required.

Dot Individuals

All entity sets on the data context now have a new property named Individuals. This will return a type that contains a sample of the entities from the CRM system surfaced directly as properties. The name for each entity property is derived from the Primary Attribute as designated in the CRM metadata. You can adjust how many entities to load using the static parameter IndividualsAmount, the default is 1000.

let ben = dc.accountSet.Individuals.``Ben Smith``

This feature can be extremely useful in data scripting scenarios or where a lot of static data exists in the CRM system, allowing for clearer and easier access to common entities.

Option Sets

Enumerations are now generated for CRM Option Sets on entities. These can be used directly in queries and CRUD operations.

query { for a in dc.contactSet do
where (a.accountrolecode = XRM.XrmService.contact_accountrolecode.``Decision Maker`` )
select a }

If you have nullable types switched on, you will not be able to use the F# nullable operators with the provided enumerations due to a restriction in the provider mechanism. Instead, you can use a standard operator on the Value property. The type provider will transform this into a safe expression containing a null check.

where (c.accountrolecode.Value = XRM.XrmService.contact_accountrolecode.``Decision Maker``)

Formatted Values

The contents of the underlying Microsoft.Xrm.Sdk.Entity.FormattedValues dictionary is now projected directly into a new type, accessed via the Formatted property on the provided entity type. This type contains a string property for each attribute on the entity whose type can possibly have a formatted value. For example; Money, Dates, Integers and Option Sets are the most common. You can use the formatted values directly in the projection expression of a query.

query { for c in dc.contactSet do
select (c.address1_city,c.Formatted.accountrolecode) }

You can also use the original underlying formatted values in a dynamic fashion by indexing the dictionary like normal

query { for c in dc.contactSet do
select (c.address1_city,c.FormattedValues.["accountrolecode"]) }

If you use the dynamic approach you should assert the existence of the key first – the provided version handles this automatically and returns a blank string if the value does not exist.

query { for c in dc.contactSet do
        select
          (c.address1_city,
           if c.FormattedValues.ContainsKey "accountrolecode" then
             c.FormattedValues.["accountrolecode"]
           else
             "") }

Enumerating Relationships

Given an instance of an entity, you are now able to treat its relationships directly as sequences. The type provider will construct a query that uses the current entity ID as the primary or foreign key of the relationship and retrieves the results as normal.

let lead = dc.leadSet.Individuals.``Diogo Andrade``
let accounts = lead.``1:N account_originating_lead`` |> Seq.toList

In this case the relationship represents children. This code will always work because the query is using the primary key of lead to find matching children, and the primary key for an entity is always present no matter how you retrieve it. When enumerating a parent relationship, the related foreign key attribute must be present on the entity; otherwise the provider will not have enough information to retrieve the parent(s). For example, the following query works fine because no specific attributes were selected. The query returns all the entity's attributes including the foreign key we are interested in.

let lead = dc.accountSet.Individuals.``Contoso Ltd``.``N:1 account_originating_lead`` |> Seq.exactlyOne

The next query will not work, because the initial projection statement specifies the attribute name, thus the provider only returns that single attribute for reasons of efficiency.

let (name,acc) = query { for acc in dc.accountSet do
select (acc.name,acc)} |> Seq.head
let lead = acc.``N:1 account_originating_lead`` |> Seq.exactlyOne

For the subsequent query to work, the foreign key in question would need to be selected as well

let (name,leadId,acc) = query { for acc in dc.accountSet do
select (acc.name,acc.originatingleadid,acc)} |> Seq.head
let lead = acc.``N:1 account_originating_lead`` |> Seq.exactlyOne

It is also possible to write new query expressions directly over the relationships of entity instances, assuming the above criteria is met.

let cont = dc.contactSet.Individuals.``Brian Smith``
let (a,o,l) = query { for acc in cont.``1:N account_primary_contact``do
                      for lead in acc.``N:1 account_originating_lead`` do
                      for owner in acc.``N:1 owner_accounts`` do
                      where (l.firstname = "Diogo")
                      select (acc,owner,lead)
                      exactlyOne }

Data Binding

Provided entities can now be bound to any .NET data binding system that makes use of INotifyPropertyChanged and the TypeDescriptor. There are two different data binding modes you can select from, accessed via the static parameter DataBindingMode.

NormalValues is the default mode. All entity attributes will appear as get/set properties to the binding mechanism, directly passing the underlying type of each attribute value. This means that you can use this mode to perform full create / update behaviour, however, whilst most basic types will work just fine, a lot of the attributes will have types such as OptionSet and EntityReference from the XRM SDK. You will need to customise the UI for these types if you want to properly read and modify them - the nature of this work depends on the binding component in question.

FormattedValues is the other available binding mode. Entity attributes will appear as a mix of read/write properties for those that do not have formatted values associated with them, and read-only string properties for other attributes that do have formatted values. This means that types such as OptionSet will show the actual string representation of the option set value; dates appear in localized time, and so forth. Because the formatted values are provided by the server and are always strings, providing the ability to modify them would not impact the underlying entity data – therefore this mode is designed more for explorative code or an application which only needs to show data rather than modify it with a binding mechanism.

The following code shows a complete F# interactive sample script that binds all the account entities to a DataGridView on a Windows Form.

#r @"microsoft.xrm.sdk.dll"
#r @"Samples.XrmProvider.dll"
#r "System.Runtime.Serialization"
#r "System.Windows.Forms"

open Samples.XrmProvider
open Samples.XrmProvider.Runtime.Common
open System.Windows.Forms
open System.ComponentModel

type XRM = XrmDataProvider<"http://server/org/XRMServices/2011/Organization.svc",false,
DataBindingMode=DataBindingMode.FormattedValues,
Username="usernamne",Password="password",Domain="domain">

let dc = XRM.GetDataContext()

let data = BindingList(Seq.toArray dc.accountSet)
let form = new Form(Text="CRM Accounts")
let dg = new DataGridView(Dock = DockStyle.Fill,DataSource=data)
form.Controls.Add dg
form.Show()

The Microsoft Dynamics CRM Type Provider Sample: Static Parameters

2013-03-01T16:01:00Z

[ Update: the CRM type provider is now available as the FSharpx.TypeProviders.Xrm NuGet package. The namespace has changed from "Samples" to "FSharpx" ]

The CRM Type Provider Sample in the F# 3.0 Sample Pack supports several interesting static parameters that determine how CRM is integrated into the F# programming language.

The parameters are as follows:

OrganizationServiceUrl	The service URL for the CRM Organization Service	(required)
UseNullableValues	When true, attributes in CRM that are not required will be surfaced as Nullable<'T>. When false, all value-type, non required attributes will be returned as Unchecked.defaultOf<'T> whether they exist or not	default: false
RelationshipNamingType	Determines the naming convention of relationship properties used on entity types	default: ParentChildPrefix
CrmOnline	When true, Windows Live authentication will be used, allowing access to CRM Online deployments	default: false
CredentialsFile	Path to a plain text file that includes username, password and optionally the domain. In the case of CRM Online these would be the relevant Windows Live username and password	default: ""
Username	Can be used in explorative scripting scenarios instead of a credentials file	default: ""
Password	Can be used in explorative scripting scenarios instead of a credentials file	default: ""
Domain	Can be used in explorative scripting scenarios instead of a credentials file	default: ""
IndividualsAmount	The maximum number of sample individuals for each CRM entity set	default: 1000
DataBindingMode	Controls the behaviour of data bound entities	default: NormalValues

Some further rules of the authentication configuration are as follows:

If you do not supply credentials, Active Directory will be used for authentication. Where at all possible, this is the recommended approach.
At runtime, you are able to pass in a different service endpoint and / or credentials by using the various GetDataContext method overloads.
In a compiled application, passing credentials as static parameters will always require you to supply them again in the GetDataContext method. This is to ensure no credentials appear in the resulting binaries. This restriction does not apply whilst working in F# interactive.
If you require credentials as static parameters, but would like to use Active Directory at runtime, you can pass blank strings for username, password and domain into the GetDataContext method.

Of the static parameters only the service URL is required. You can supply others you need with the named parameter syntax:

type Xrm = XrmDataProvider<"http://server/org/XRMServices/2011/Organization.svc", CredentialsFile="Credentials.txt">

let dc = Xrm.GetDataContext()

The F# 3.0 Microsoft Dynamics CRM Type Provider Sample - Strongly-typed enterprise-scale customer data made simple

2013-02-14T16:28:00Z

[ Update: the CRM type provider is now available as the FSharpx.TypeProviders.Xrm NuGet package. The namespace has changed from "Samples" to "FSharpx" ]

We're pleased to announce that a new type provider sample has been added to the F# 3.0 Sample Pack: the Microsoft Dynamics CRM 2011 type provider. For those in a hurry, you can watch a short screencast here(a longer version is in the works).

This sample uses the F# 3.0 Type Provider mechanism to provide scalable access to strongly typed CRM entities without the need for code generation. You can read more about the various kinds of Type Providers here and check out the other samples in the samples pack. A technical report on F# type providers called Strongly-Typed Language Support for Internet-Scale Information Sourcesis available from Microsoft Research.

A default install of Microsoft Dynamics CRM 2011 contains a wealth of schematized data tables pertaining to the customer relations of a business. Additionally, the product suite allows the default data schema to be extended and heavily customised. This means Microsoft Dynamics CRM is frequently used to model the custom domain requirements of particular enterprises. From a developer perspective, the data can be accessed in a dynamic fashion using the CRM Organization Service with a QueryExpression or FetchXml. Later versions of CRM introduced a LINQ provider over the QueryExpression which works effectively but requires a large amount of generated code in order to function. The problems caused by this generated code can be very significant for CRM programming teams, even to the point where schema changes are avoided because of the need to regenerate massive code files.

The vision we are pursuing with this work is that someone working with Microsoft Dynamic CRM data should experience the same immediate, simple, scalable and intuitive access to massive enterprise schemas as we have achieved with many other data sources. Wouldn't it be nice if the various entities in CRM were automatically at your fingertips in a strongly typed fashion, and didn't require large amounts of generated code? Wouldn't it be nice if changes in the data schema would automatically reflect into programs and data scripts, removing the possibility of runtime errors due to mismatched code and data schema? This, amongst other nice features, is what this F# 3.0 type provider gives you.

To get going with this sample, you will first need a fully functioning CRM deployment and access to the OrganizationService endpoint. We understand that many of you won't have this, so you can also watch the screencast linked above to see the type provider sample in action. (The following steps assume the client is on the same domain as the service; if this is not the case, please see later blog posts on static parameters to address this)

To get going with the sample

You will need the Mircrosoft Identity Foundation in order to query the organization service (In Windows Server 2012 and Windows 8 this can be installed via "Add Windows Features")
Install F# 3.0, either through an evaluation copy of Visual Studio 2012 or using the Free F# Tools for Visual Studio 2012 Web Express
Download and unzip the latest HEAD copy of the F# 3.0 Sample Pack
Go to SampleProviders\Samples.Xrm. Open and build Samples. Xrm.Provider.sln
Create a new script referencing Samples.XrmProvider.dll

#r @"System.Runtime.Serializaation"
#r @"lib\Microsoft.Xrm.Sdk.dll"
#r @"bin\Debug\Samples.XrmProvider.dll"

open Samples.XrmProvider

let xrm =
    XrmDataProvider<"http://server/org/XRMServices/2011/Organization.svc">.GetDataContext()
let accounts = xrm.accountSet |> Seq.toList

Assuming everything has gone as intended, you will now have retrieved all the Account entities from the organization in just 2 lines of code! (Perhaps don't try this if you have millions of accounts..)

You can now use F# Query Expressions to create LINQ queries over the data. The provider currently supports a subset of the LINQ query operations and a few of the F# specific query expression keywords, with more to come in future releases. More information on building queries will be detailed in later blog posts. Additionally, you can look at the test project for to get a feel for different query compositions.

let accounts =
    query { for a in xrm.accountSet do
            where (a.name.Contains "Contoso")
            select a } |> Seq.toList

Some cool things implemented by the new sample include:

Standard LINQ functionality including filtering, projections, sorting, distinct
Paging via Skip and Take
Opt-in nullable values on appropriate CRM attributes and support for F# Nullable operators
Entity relationships can be queried without having to use explicit joins or know which attributes to join on
Support for many-to-many relationships
Custom operators allow you to use CRM conditional operators such as In and Not In

Some limitations of the provider are as follows:

Many to many relationships to/from the same entity type are not implemented
Aggregation operations are not implemented
There are some restrictions with the way parents / children can be selected (more on this in later posts)
A connection to the organization service is required during compilation

Here is a screenshot using IntelliSense to explore an account entity.

We hope you enjoy the sample and learn a lot from it.

F# + ServiceStack - F# Web Services on any platform in and out of a web server

2013-02-06T11:58:00Z

Demis Bellot has two excellent articles on using F# with ServiceStack:

To quote:

You now have a fully-fledged ServiceStack ASP.NET application that can be hosted in any ASP.NET compatible web server e.g:

IIS
Apache + mod_mono
Nginx + MonoFastCGI
XSP
WebDevServer.exe

Now that you know how to create functional F# web services, you can read more about the goodies you get for free when using Service Stack, complete with live links to all those juicy XML, JSON, SOAP, HTML, CSV and JSV Formats check out: http://www.servicestack.net/ServiceStack.Hello/

Enjoy!

Don, for the Visual F# team

Learn How to Create an Internet Game Using F#, C#, and ASP.NET

2013-02-05T01:08:00Z

We have just released a new MSDN sample and tutorial that shows how to use F# and C# in a Windows Azure cloud service. If you are interested in cloud programming with F# or any other language, we encourage you try out the sample!

The sample is a crossword game called WordGrid, which is reminiscent of Scrabble, Words with Friends and similar games. It shows some basic concepts of cloud programming in F#, such as using Windows Azure queues in F#, and using type providers to access a Windows Azure SQL database. It also demonstrates how you might use F# and C# together in an ASP.NET MVC 4 web role.

Get started with an overview and setup instructions here, and dive into the code by reviewing the article here. You can find the sample code itself on CodePlex.

Enjoy!

Gordon and Donna, for the Visual F# Team