Don Syme's WebLog on the F# Language and Related Topics : F# Announcements

Unleash those transistors! General Purpose GPU and x64 Data Parallel Multicore Programming with Accelerator from F#

dsyme — Tue, 15 Dec 2009 14:26:00 GMT

One of my colleagues at MSR Cambridge, Satnam Singh , has written his very first blog entry, and what a beauty it is ! Data parallel multicore programming from F# targeting both CPU and GPU - what joy! Microsoft recently released a preview of the Accelerator...(read more)

WebSharper: F#-based Rich Client/Server Web Applications

dsyme — Tue, 08 Dec 2009 20:40:00 GMT

My co-author on Expert F#, Adam Granicz, has been leading Intellifactory to develop the F#-based WebSharper platform for developing client-server applications that execute as Javascript in the browser and as compiled .NET code on the server.

Intellifactory seem to have set about answering the question of "just how simple, clean and productive can you make developing rich web applications that target Javascript?" (my words, not theirs). While still in beta, signs are that Intellifactory are putting together an impressive technology that makes really good use of F#'s unique facilities to simplify this class of applications. WebSharper seems to draw inspiration from LINKS and Tomas Petricek's AFAX project, with an added focus on simplicity and productivity.

Anton has a good introductory blog on developing with WebSharper here.

We also owe a huge thank you to Intellifactory (particularly Adam and Anton) for their excellent, timely high quality feedback on F# itself.

Here's an excerpt from the Intellifactory website:

The IntelliFactory WebSharper™ Platform

Writing good web applications is not an easy task today. It requires a mastery of numerous languages (JavaScript, HTML, CSS), and an acute awareness of existing standards and browser implementation quirks. Poor debugging tools, and the lack of compositionality and component reuse in the multi-tiered, multi-language web environment compound the problem even more.

With the IntelliFactory WebSharper™ Platform you can develop rich, client-based, and highly responsive web applications using F#, enjoying all the benefits of Visual Studio™ and IntelliSense™. Developing both the client and server-side functionality with F# gives you unrivaled productivity, a dramatically more compact code base, and powerful language features to get your tasks done quicker, more robustly than ever before.

F# related job at Future Social Experiences (FUSE) Lab UK

dsyme — Fri, 27 Nov 2009 23:44:00 GMT

Are you interested in using probabilistic techniques to analyze online data and build new social experiences around it? The FUSE group located at Microsoft Research in Cambridge is hiring. The group use F# a lot and have applied it successfully on many projects.

https://careers.microsoft.com/JobDetails.aspx?jid=9575

The Future Social Experiences (FUSE) Lab UK team is a newly founded group co-located with Microsoft Research Cambridge. It will focus on new social experiences in Microsoft’s Online Services through computational intelligence technologies and through exploitation, combination and analysis of available data sources within and outside of Microsoft. In addition, the team’s charter is to bridge between Microsoft Research Cambridge, FUSE Labs, and Microsoft’s Online Services teams, including teams in Search, Ads & Portal in the Online Services Division (“Information Seekers”), teams in Office & SharePoint in Microsoft Business Division (“Information Workers”) and teams in Xbox Live and Window Mobile in the Entertainment and Devices Division (“Gamers and Mobile Workers”).

We are looking for mathematically astute, online-savvy applied researchers and developers. Necessary skills for this position include:

Ø Fit within an applied and basic research lab

Ø Development experience in various programming languages, including C++, C#, Python, SQL, F# and JavaScript

Ø Familiarity with Windows design tools and frameworks

Ø Development knowledge and experience of cloud applications and web services

Ø Ability to build throw-away/rapid prototypes

The successful candidate will be working in a small, dynamic and fun team reporting directly to the director of FUSE Labs UK.

If you are interested or require further information, please contact Ruth Lenton at cambhr@microsoft.com.

A Great Blog Series on Algorithmic Programming in F#

dsyme — Sun, 08 Nov 2009 18:19:00 GMT

I've just discovered Julien's great blog series on algorithmic programming in F#, a very useful resource. And if that doesn't whet your appetite, he also has a series on food :-)

Here are some of his recent posts:

Technical analysis indicators in F#

This is the first part of a series on technical analysis indicators in F#. We will define the basic object holding the data series which will be used to compute the indicators. We will also describe some functions to check the integrity of the said data (and which will be useful when defining the indicators).

An immutable range library in F#

An immutable range library in F# where a range is only defined by a minimum and a maximum value (hence, there is no step).

An immutable queue in F#

An immutable queue library in F#. The queue is divided into two lists : one for dequeueing, and one for enqueueing. All operations are based on the List module.

A bitset library in F#

ReadWrite Requests for groups of files

In this post, we shall use read/write requests from a group of files considered as a single entity. We will also look at verifying the data. In our model, the group of files is defined by the files, and pieces. A piece is a chunk of data with a standardized size so that read/write requests are consistent. Of course, the last piece of the files stream could see its size differ from others since if the cumulative size of the files is not a multiple of the piece length.

Implementing Two-way TCP Traffic Control in F#

This post describes how to implement two-way (TCP for instance) traffic control in F# by modifying slightly a Trolltech article available at http://doc.trolltech.com/qq/qq17-ratecontrol.html.

Crème pâtissière – Pierre Hermé, “Larousse des desserts”

Pâte à choux

Le chocolat

Pâte sucrée – Pierre Hermé, “Larousse des desserts”

And the list goes on!

F# brush for Gorbatchev’s SyntaxHighlighter

Dual quicksort in F#

F# brush for Geshi

Batch image resizer

Tries and Anagrams with F#

F# 1.9.7 Language Specification Now Available

dsyme — Wed, 04 Nov 2009 17:46:00 GMT

The F# 1.9.7 Language Specification is now available, in PDF and HTML, matching the recent release of F# in Visual Studio 2010 Beta2, with matching CTP udpate for Mono and Visual Studio 2008. The latest language specification can also always be found via www.fsharp.net

Many thanks to all those who sent so much helpful feedback on the specification during Beta1. And for those using 1.9.7 already, thanks for your patience in the last couple of weeks - it took us a little longer to get this out the door than we had planned, since a development deadline for Visual Studio 2010 intervened.

We plan on making a second update to the 1.9.7 spec to polish some areas of the text in the next few weeks.

thanks,

don

F# in Visual Studio 2010 Beta2 is now available ( plus matching F# CTP Update for VS2008)

dsyme — Mon, 19 Oct 2009 21:12:00 GMT

The latest release of F# is now out! This is included in Visual Studio 2010 Beta2 , released today for MSDN Subscribers, with the matching release of the F# CTP for Visual Studio 2008, and a compiler ZIP for Mono. The detailed release notes are here. (Note: general download availability of Visual Studio 2010 Beta2 will begin in the next few days.)

This is an incremental release, supporting the vision outlined by the F# team, the Microsoft Developer Division and Microsoft Research of including F# as a supported language in Visual Studio. The focus of the release has been to address some design issues necessary to improve F# and put it on a long-term stable, reliable and supported basis.

With this release, we are enabling F# support for multi-targeting with VS2010. This means that VS2010 projects can be targeted to produce binaries for any of .NET 2.0-4.0, for example if you are a library vendor building 2.0 dlls for use on 2.0-4.0, or working in an environment where .NET 2.0-3.5 development is the norm. Additionally, we will be supporting development of F# components targeting Silverlight, through the inclusion of a template for Silverlight library components. In line with the philosophy we outlined in the previous release of F#, we expect the focus of F# in this domain to be components that handle the algorithmic and communication patterns common in client-side programming, particularly in enterprise scenarios.

We have also taken crucial steps towards our goal of ensuring binary compatibility for components across .NET 2.0-4.0. For example, in previous releases different copies of the F# Power Pack were required for .NET 2.0-3.5 and 4.0. However, in this release we have one version of the Power Pack which can be used on both .NET 2.0-4.0 (installed via the CTP MSI or ZIP). If you are authoring F# binary components, you can now build binary compatible components in a similar way (note: some important Beta2 caveats are in the release notes). As we have discussed with the F# community, full ongoing binary compatibility is expected starting with the version of F# that comes with the Visual Studio 2010 RTM release.

At the source level, we are now aiming for no more changes to FSharp.Core.dll before the Visual Studio 2010 RTM release, apart from removing deprecated functionality. Existing F# users should pay careful attention to deprecation warnings since we will be removing deprecated functionality with the version of F# that will come with the Visual Studio 2010 RTM release.

There are also some simplifications to the F# language. For example, the OverloadID attribute is no longer needed when defining method overloads, we have added support for placing definitions in the global namespace and simplified conversion operators such as int32. Some important restrictions have been lifted with regard to object oriented programming, and discriminated unions now have a cleaner code generation pattern when used from other .NET languages. We’ve also made F# programming safer by adding a new feature called equality and comparison constraints used to ensure that F# types such as Map and Set are only used with types supporting the necessary operations. This is documented further in the F# release notes, and an update to the F# language specification will follow in the next week.

This release also includes final, relatively modest improvements to the F# Core Library. These include simplifications to F# asynchronous programming. For example, using asynchronous programming with WPF, Silverlight and ASP.NET components is now even easier, as described in the release notes. We have included the array2D operator for creating 2D arrays. We’ve also addressed version-stable serialization of Map and Set, and aligned F# lazy values and cancellation with the designs of .NET 4.0. F# first class events now support the IObservable interface (new in .NET 4.0, also supported by F# 2.0, and also used by the Reactive Framework). The F# library also includes a modest library of Observable operators, following the pattern of the Event operators already present in F#.

F# now supports reusable script components through the support of #load on .fsx components. By taking the closure of script references, common code can now by factored into reusable .fsx components. These components can be executed with F# Interactive, or compiled with the command line F# compiler.

For F# in Visual Studio, we have addressed a multitude of issues, including F1 support, improvements for the Error List, issues in the Project System and better debugger display of unions and other F# types. For F# documentation, the F# Core Library docs have been integrated into MSDN.

Many thanks to everyone in the F# community for so much great feedback and encouragement during the last few months. The F# core team have worked hard to ensure a good release, and as always we’re very keen to hear your continued feedback. Please report any issues or problems you spot as soon as possible, to ensure we can act on it in time for Visual Studio 2010 RTM! (really, I mean that – try it now, and please send us feedback!)

Don, for the F# team!

Release notes

Release Notes for the F# October 2009 release

dsyme — Mon, 19 Oct 2009 08:44:00 GMT

(These notes apply to the F# October 2009 CTP update and Visual Studio 2010 Beta2)

Summary

Release

F# in Visual Studio2010 Beta2 can build applications for .NET 2.0/3.0/3.5/4.0 and Silverlight 2/3.
Updated F# CTP for Visual Studio 2008
F# PowerPack available as part of the CTP Update, and can be used with either CTP Update of VS2010 Beta2

F# Language

OverloadID no longer required for defining overridden methods
Require module/namespace at top of files
‘comparison’ and ‘equality’ constraints
Core conversion operators use .NET standard op_Implicit/op_Explicit instead or ToInt32, etc.
Support for global namespace qualification, “global.A.B.C” and “namespace global”
More flexibility in defining yield! and return! in computation expressions using YieldFrom and ReturnFrom
Extension methods can participate in overload resolution
Support for volatile fields using [<Volatile>]
Support for letting F# types allow “null” using [<AllowNullLiteral>]
Interface implementations can now be inherited
Private type abbreviations (type private X = int)
More flexibility for list literals and subtyping
Recursive type inference improvement

F# Compiler

HTML doc generation moved from compiler to PowerPack
Discriminated Union code generation provides simpler .NET view

F# Core Libraries

Complete the under_score -> camelCase name standardization, of_list -> ofList
Async API Additions for Web Requests
Async API Additions for Reactive Applications
Array2D enables easily creating 2D arrays
Observable module
Version-stable serialization of Map and Set
[.NET 4.0] Lazy, CancellationToken, BigInteger in .NET4.0
CompiledName used to ensure .NET view is C#/VB friendly

Visual Studio

Multitargeting for VS2010: 2.0-4.0 + Silverlight
Error list improvements
Much improved debug display of unions and other F# types.
F1 support

F# Interactive

#load .fsx

F# PowerPack

Async additions
FsHtmlDoc.exe

Miscellaneous

Deletion of features deprecated in previous F# releases
Plus many minor fixes and improvements

F# Language

OverloadID no longer required for defining overridden methods

Overloaded methods can now be defined without the need for the OverloadID attribute.

type Foo() =

member this.CountChars(s : string ) = s.Length

member this.CountChars(c : char) = 1

Require module/namespace at top of files

All .fs files, except the last file in an application project, must begin with either a module or namespace declaration. Previously files were put in a default module named after the file. Files can be structured to define an F# module:

module Widgets

type T() =

member this.X = 12

let x = 12

Or a namespace:

namespace Widgets

type T() =

member this.X = 12

Nested modules and namespace may be defined as before.

Note: Code of the form

namespace Widgets

module Module1

…

should be rewritten as

module Widgets.Module1

…

‘comparison’ and ‘equality’ constraints

Two new F#-specific constraints are added:

ty : comparison

ty : equality

Note: Equality includes "hashing"

A type satisfies ty : equality under these conditions

Ø if the type has dependencies T1, ..., TN then each of these must satisfy equality; AND

Ø the type doesn't have the NoEquality attribute; AND

Ø the type is not inferred to be NoEquality (for record, union and struct types)

A type satisfies ty : comparison under these conditions

Ø if the type has dependencies T1, ..., TN then each of these must satisfy comparison; AND

Ø the type doesn't have the NoComparison attribute; AND

Ø the type implements IComparable, or the type is an array/IntPtr/UIntPtr; AND

Ø the type is not inferred to be NoComparison (for record, union and struct types)

One ramification of this is that most .NET types satisfy equality, even if this defaults to reference equality.

These constraints are used on some common parts of the F# library:

val max : 'T[] -> 'T when 'T : comparison

val min : 'T[] -> 'T when 'T : comparison

val sort : 'T[] -> ‘T[] when 'T : comparison

val sortInPlace: 'T[] -> unit when 'T : comparison

val maxBy : ('T -> 'Key) -> ‘T[] -> 'T when 'Key : comparison

val minBy : ('T -> 'Key) -> ‘T[] -> 'T when 'Key : comparison

val sortBy : ('T -> 'Key) -> ‘T[] -> ‘T[] when 'Key : comparison

val sortInPlaceBy: ('T -> 'Key) -> ‘T[] -> unit when 'Key : comparison

val countBy : ('T -> 'Key) -> seq<'T> -> seq<'Key*int> when 'Key : equality

val distinct : seq<'T> -> seq<'T> when 'T : equality

val distinctBy : ('T -> 'Key) -> seq<'T> -> seq<'T> when 'Key : equality

val ( < ) : 'T -> 'T -> bool when 'T : comparison

val ( > ) : 'T -> 'T -> bool when 'T : comparison

val ( >= ) : 'T -> 'T -> bool when 'T : comparison

val ( <= ) : 'T -> 'T -> bool when 'T : comparison

val ( = ) : 'T -> 'T -> bool when 'T : equality

val ( <> ) : 'T -> 'T -> bool when 'T : equality

val compare : 'T -> 'T -> int when 'T : comparison

val hash : 'T -> int when 'T : equality

val max : 'T -> 'T -> 'T when 'T : comparison

val min : 'T -> 'T -> 'T when 'T : comparison

In some cases, code may need to be updated to take into account these constraints.

F# types may indicate how they participate in generic comparison or equality using attributes NoEquality/Comparison, StructuralEquality/Comparison. These are used on some F# library types, for example:

[<NoEquality>]

[<NoComparison>]

type Async<'T>

In some circumstances it is also useful to make equality and comparison of a collection type conditional on a type parameter having equality/comparison. This is done using the EqualityConditionalOn and ComparisonConditionalOn attributes:

type Set<[<ComparisonConditionalOn>] 'T when 'T : comparison>

These attributes are inferred for structural types:

// inferred: [<EqualityConditionalOn>] for T1, T1

// inferred: [<ComparisonConditionalOn>] for T1, T2

type Choice<'T1,'T2> =

| Choice1Of2 of 'T1

| Choice2Of2 of 'T2

Two new functions are available to access an "Unchecked" implementation of equality and comparison that is equivalent to the regular equality and comparison implementations, as used in previous implementations of F#, but may be used with any types without constraint

Unchecked.compare

Unchecked.equals

Further details of the equality/comparison constraint feature will be contained in the updated F# specification, to be released after these notes are posted.

Core conversion operators use .NET standard op_Implicit/op_Explicit instead or ToInt32, etc.

Overloaded conversion operators such as ‘int’, ‘char’ and ‘float’ which previously provided custom overloading via ToXXX conversion functions now use .NET standard op_Implicit/op_Explicit instead. Any type defining an op_Implicit or op_Explicit returning the expected type can be used with these conversion operators.

type MyInt(x : int) =

member this.X = x

static member op_Explicit(myint : MyInt) = myint.X

let myInt = new MyInt(3)

// The 'int' conversion function calls the op_Explicit method on MyInt

let oldInt = int myInt

Support for global namespace qualification, “global.A.B.C” and “namespace global”

Types can now be defined in the .NET “global” namespace using:

namespace global

type T() =

member this.X = 12

Additionally, in cases where partially-qualified names clash, name lookup can be qualified to the global namespace environment:

let line = global.System.Console.ReadLine()

More flexibility in defining yield! and return! in custom computation expressions

To support more flexible uses of computation expressions, the two computation expression forms yield! and return! are now de-sugared as follows:

yield! expr -> builder.YieldFrom expr

return! expr -> builder.ReturnFrom expr

Extension methods can participate in overload resolution

Extension methods can be defined as overloads of existing methods. These are given a lower priority in overload resolution. See the F# spec for full details.

type System.String with

member this.Split(seps : string) =

this.Split(

[|seps|],

System.StringSplitOptions.RemoveEmptyEntries)

let parts = "a b c d".Split(" ")

Support for letting F# types allow “null” using [<AllowNullLiteral>]

Types defined in F# do not generally allow the use of the ‘null’ literal as a proper value. However, null values can be passed in for these types from non-F# .NET callers, and sometimes it is necessary to write F# types that naturally do support a null proper value.

type T1() =

member this.X = 12

[<AllowNullLiteral>]

type T2() =

member this.X = 12

let t1 : T1 = null // Error

let t2 : T2 = null // No error

Interface implementations can now be inherited

Interfaces implemented by inherited classes can be used to satisfy interface implementation requirements on a derived class. Code such as the following now compiles without the need to explicitly implement I1 in C2.

type public I1 =

abstract V1 : string

type public I2 =

inherit I1

abstract V2 : string

type public C1() =

interface I1 with

member this.V1 = "C1"

type public C2() =

inherit C1()

interface I2 with

member this.V2 = "C2"

More flexibility for list literals and subtyping

List and array literals may now be used to create collections from elements that are subtypes of the collection element type. For example:

let myControls: (Control list) = [ new Button() ; new TextBox() ]

F# Compiler

HTML doc generation moved from compiler to PowerPack

The --generatehtml compiler option has been removed, and the functionality moved into a separate tool in the F# PowerPack (see below). This enables decaoupling documentation generation from compilation, and more customization of doc generation.

F# Binary Compatibility 2.0-4.0

As we have discussed with the F# community, full ongoing binary compatibility is expected starting with the version of F# that comes with the Visual Studio 2010 RTM release.

This release has taken crucial steps towards the F# team goal of ensuring binary compatibility for components across .NET 2.0-4.0. For example, in previous releases different copies of the F# Power Pack were required for .NET 2.0-3.5 and 4.0. However, in this release we have one version of the Power Pack which can be used on both .NET 2.0-4.0 (installed via the CTP MSI or ZIP).

If you are authoring F# binary components, you can now build binary compatible components in a similar way. There are some important caveats to this due to two missing type forwarders in FSharp.Core.dll, notably

Ø DLLs using Array2D.* or 2D arrays in public API surface area are not automatically binary compatible across 2.0/4.0. With care these DLLs can be made binary compatible across 2.0/4.0, and this has been done for the F# Power Pack, but normally these APIs will not be binary compatible across 2.0/4.0 until Visual Studio 2010 RTM

Ø Likewise DLLs using F# lazy values (System.Lazy<_>) are not automatically binary compatible. With care, these DLLs can be made binary compatible across 2.0/4.0 by using a private copy of the F# lazy implementation from .NET 2.0, and this has been done for the F# Power Pack. However in the absence of special attention these APIs will not be binary compatible across 2.0/4.0 until Visual Studio 2010 RTM

Binary compatibility can be checked in part by running peverify for .NET 2.0 and .NET 4.0 after installing Visual Studio 2010, a version of Visual Studio 2008 and the F# CTP.

F# Core Libraries

Async API Additions for Web Programming

The extension methods webClient.AsyncDownloadString and webRequest.AsyncGetResponse are now defined in FSharp.Core.dll, and accessed via

open Microsoft.FSharp.Control.WebExtensions

For example:

open System.Windows.Forms

open System.Net

open System.IO

open Microsoft.FSharp.Control.WebExtensions

/// Fetch the contents of a web page, asynchronously

let httpAsync (url:string) =

async { let req = WebRequest.Create(url)

let! resp = req.AsyncGetResponse()

// the rest is a callback

use stream = resp.GetResponseStream()

use reader = new StreamReader(stream)

return reader.ReadToEnd() }

Async API Additions for WinForms, WPF, Silverlight and ASP.NET applications

The Async API has a number of new additions and design extensions to better enable writing “single-primary-thread-of-control” reactive applications using F# asyncs. This is a commonly used idiom for Windows Forms, WPF, Silverlight and ASP.NET programming.

These applications are I/O parallel, but only use CPU parallelism in constrained ways. In this kind of application, CPU processing is done on a single thread of control, but multiple I/O requests may be overlapped.

In .NET, these applications will typically have a non-null, dedicated value for System.Threading.SynchronizationContext.Current on the main “thread”.

Waiting for .NET Events

The method Async.AwaitEvent is now defined in FSharp.Core.dll. This method runs the continuation of the async the first time .NET event fires.

open System.Windows.Forms

let form = new Form(Visible=true,TopMost=true)

async { let! firstClick = Async.AwaitEvent form.Click

form.Text <- "I got clicked once!"

let! nextClick = Async.AwaitEvent form.Click

form.Text <- "I got clicked twice!" }

|> Async.StartImmediate

Starting Asyncs on the Current Thread

The methods Async.StartImmediate and Async.StartWithContinuations are now defined in FSharp.Core.dll. These methods start the async immediately on the current thread, until the first point where the thread yields through an operation such as Async.AwaitEvent or an I/O operation.

These methods are particularly useful for starting async operations on the GUI or ASP.NET thread.

A use of StartImmediate is shown above.

Automatic Return to Context

F# library async I/O and waiting primitives can now be used from GUI or ASP.NET threads in a simpler fashion. Conceptually, if you start an async I/O operation or an async wait operation on a GUI thread, then it will “complete” on the GUI or ASP.NET thread.

If a primitive async operation is started on a thread where SynchronizationContext.Current is set, then the continuation of such an async is posted using SynchronizationContext.Post.

In the following example the overall async is started on the GUI thread using StartImmediate. As the click happens and the asynchronous fetches of the web pages return, the overall async is in each instance continued on the GUI thread. This means the GUI components can be safely updated from the async.

open System.Windows.Forms

let form = new Form(Visible=true,TopMost=true)

async { let! firstClick = Async.AwaitEvent form.Click

form.Text <- "I got clicked!"

let! firstPage = httpAsync "http://www.google.com"

form.Text <- "I got the first page!"

let! secondPage = httpAsync "http://www.bing.com"

form.Text <- "I got the second page!" }

|> Async.StartImmediate

F# asyncs built using the following API operations implement “automatic return to context”:

Async.Parallel

Async.Sleep

Async.AwaitEvent

Async.AwaitIAsyncResult

Async.AwaitTask

Async.AwaitWaitHandle

Async.FromBeginEnd

Async.FromContinuations

type System.Net.WebRequest with

member AsyncGetResponse()

type System.Net.WebClient with

member AsyncDownloadString()

type System.IO.Stream with

member AsyncRead()

member AsyncWrite()

Async API Renamings

System.Threading.AsyncSleep -> Async.Sleep

extension waitHandle.AsyncWaitOne -> Async.AwaitWaitHandle

Async.BuildPrimitive -> Async.FromBeginEnd

Async.SwitchToGuiThread -> Async.SwitchToContext

Async.RunWithContinuations -> Async.StartWithContinuations

Complete the under_score -> camelCase name standardization, of_list -> ofList

The naming normalization across the F# core libraries is finalized in this release, with the following removals of underscores and abbreviations:

to_list -> toList

to_array -> toArray

to_seq -> toSeq

of_list -> ofList

of_array -> ofArray

of_seq -> ofSeq

of_nativeint -> ofNativeInt

to_nativeint -> toNativeInt

hd -> head

tl -> tail

Observable module and F# events

The IObservable and IObserver interfaces provide a general interface over observable data, which can be easily composed. These interfaces are provided in .NET4.0, and are available in F# for .NET2.0.

1^st class events in F# now implement the IObservable interface, enabling them to interoperate with other IObservable programming models. A new Observable module in the F# library provides compositional functions for manipulating general Observable data:

Observable.merge

Observable.map

Observable.filter

Observable.partition

Observable.split

Observable.choose

Observable.scan

Observable.add

Observable.subscribe

Observable.pairwise

array2D enables easily creating 2D arrays

A new ‘array2D’ function converts data into 2d arrays:

let matrix = array2D [[1;2;3];

[2;3;4];

[3;4;5]]

[.NET 4.0] Lazy, CancellationToken, BigInteger in .NET4.0

Some F# types have moved into mscorlib in .NET4.0, making it easier to reuse these types between F# and other .NET languages. On .NET2.0, these F# types have been moved to corresponding namespaces within FSharp.Core.dll. The following important F# types have moved to System namespaces:

Lazy -> System.Lazy

Tuple -> System.Tuple

BigInt -> System.Numerics.BigInteger

AsyncGroup -> System.Threading.CancellationTokenSource and System.Threading.CancellationToken

CompiledName used to ensure .NET view is C#/VB friendly

The .NET-visible names of types and members in FSharp.Core.dll are modified to align with standard .NET naming conventions. This makes it easier to use FSharp.Core defined types from other .NET languages. For example:

Seq.iteri -> Microsoft.FSharp.Collections.SeqModule.IterateIndexed

failwith -> Microsoft.FSharp.Core.Operators.FailWith

Visual Studio

[VS2010] Multitargeting support for 2.0-4.0 + Silverlight

With VS2010, F# users can target .NET 2.0, 3.0, 3.5, 3.5 Client, 4.0 and 4.0 Client. F# libraries can also be built targeting Silverlight 2 and 3. F# libraries built against .NET2.0 can also be used as part of F# applications targeting later versions of .NET.

Error list improvements

The Visual Studio error list is populated with F# errors both during editing of F# files, and during building of F# projects. This release ensures that errors are tracked between these two sources when they are available in both.

F1 support

F1 contextual help support is available in the F# editor. This will open documentation for the type or member reference at the cursor. In addition, in VS2010, F1 help on F# keywords or F# library functions will go to the new MSDN documentation on these subjects.

F# Interactive

#load .fsx

When building complex F# scripts, it is sometimes necessary to split a script into multiple .fsx files. F# scripts now support the ability to load other F# scripts, enabling factoring of scripts into source components.

F# PowerPack

FsHtmlDoc.exe

A new tool called fshtmldoc.exe is now available in the F# Power Pack. This replaces the HTML doc functionality in the F# compiler. The command line options are shown using “fshtmldoc.exe --help"

F# Tutorial Code and Slides (JAOO 2009 Edition)

dsyme — Sat, 10 Oct 2009 17:31:00 GMT

One of the great pleasures of my job is to go to conferences like JAOO and present on F# and other topics. This year I presented both a tutorial and a lecture at JAOO 2009, and I've included the tutorial and lecture slides below! Thanks to everyone who came along - I really enjoyed giving this one!

Some highlights of the code are:

Foundational material on F# async programming, and samples including:

Fetching web pages in parallel
The Bing translator sample using async programming
A Graphical, asynchronous twitter client in 50 lines
A Twitter feed example that uses F# first class reactive event processing to process the stream of feeds
An asynchronous web crawler
Processing images in parallel, using a mixture of I/O and CPU parallelism

An updated version of the famous Interactive DirectX demo
Lots of great micro samples on foundational topics such as

object oriented programming
language oriented programming
function composition
design patterns
discriminated unions
records
units of measure

The tutorial slides include important new slides on asynchronous programming. Over the next few blog entries I'll be taking a closer look at some of the material, especially in the areas of parallel and asynchronous programming.

I'd really appreciate your input on how we can make this tutorial even better. Giving an F# tutorial is enormously enjoyable and if you'd like to give a tutorial, please drop me a note (dsyme at microsoft dot com) and I'll send you the latest copy of the slides and code - we're already planning to add a few more , including a section on the standard F# "functional programming operators" such as List.map, List.fold etc.Send us your suggestions for further topics to cover!

Some of this material comes from Chris Smith, Matthew Podwysocki, Luke Hoban, Brian McNamara and James Margetson from the F# core team at Microsoft. Some snippets of the async samples showing the use of the PeriodicTable web service were co-developed with Robert Pickering (thanks Robert!)

Enjoy!

Don

F# Job: Credit Suisse GMAG seek Trader Tools Project Lead

dsyme — Tue, 22 Sep 2009 16:16:00 GMT

Over the last few years the F# team at Microsoft have been very glad to work with the Credit Suisse GMAG group . GMAG (Global Modelling and Analytics)are successful adopters of F#, as they reported on at CUFP 2008. This continues strongly and the group continue to provide essential feedback on the design and implementation of the F# language and its related Visual Studio tools.

The group is now looking for an outstanding project lead for a new initiative where they expect F# to play a significant role. A snippet of the job description is below, contact Howard Mansell (howard.mansell@credit-suisse.com) for more details.

THE POSITION: Trader Tools Project Lead (London)

One of the core activities of GMAG is to deliver tools to sales & trading that allow them to analyse markets and portfolios, and price trades. We employ a number of technologies and frameworks, developed in GMAG-AD, for this purpose. Our trader tools are currently deployed with an Excel front-end, with some amount of calculation implemented in Excel. We intend to transition the delivery of these tools to a non-Excel environment. We are looking for an outstanding individual to lead this effort.

Key requirements for the role are:

·         Experience of leading teams of highly-skilled technical specialists, and a demonstrated ability to deliver outstanding solutions to difficult problems.

·         Very strong understanding of commercial software development processes and distributed team development of complex code bases.

·         Ability to communicate well and understand the requirements of modellers and traders.

·         Expert-level hands-on knowledge of the Microsoft .NET framework.

·         Knowledge of functional and object-oriented programming paradigms.

·         Ideally the candidate will have experience with F#, WPF, COM, C++, C# and web development.

·         Experience in the finance sector is highly desirable but not essential.

Don

Keynote at EclipseCon Europe, 2009: Taking Functional Programming Into the Mainstream

dsyme — Fri, 18 Sep 2009 16:47:00 GMT

Just to mention that I'll be giving a keynote lecture at the Eclipse Summit in Ludwigsburg, Germany on Wed 28 Oct. 2009.

I haven't been to EclipseCon before. am looking forward to learning a lot about the Eclipse community. In the past few years, my work has been in the context of Visual Studio, but I've definitely learned that there is much that the various IDE communities can share and learn from each other.

If you're planning on attending, drop me a note or stop by after the talk.

F# at JAOO 2009, Aarhus, 4-6 October

dsyme — Fri, 18 Sep 2009 16:38:00 GMT

I’m excited to be giving a tutorial, a presentation and a panel at JAOO 2009 in Aarhus in early October. I’ve had the good fortune to be involved with JAOO and QCon a few times over the last few years, and am honoured to be presenting in Aarhus, the home of it all.

I’ve copied details below – hope to see you there!

Tutorial: "Getting Started With F#"

Time: Sunday, 4 Oct, 9:00 – 12:00

Abstract: F# is a succinct and expressive typed functional programming language for the .NET platform, and Microsoft will be supporting F# as a first class language in Visual Studio 2010. In this tutorial you'll get a taste or F# programming from the basics through to some parallel and asynchronous programming with F#. You'll learn how to get started with the functional, imperative and object-oriented programming in F#, how to use shaped functional data to reduce the amount of state in your application, and how to use units of measure to bring sanity and checking to your numerical code. You'll also get a taste for some parallel and asynchronous programming, and take a look at some more advanced techniques in reflection.

Target Audience: Developers, architects and anyone interested in learning how to apply functional techniques in practice and have fun along the way

Presentation: "An Introduction to F#"

Track: Programming Languages

Time: Monday, 5 Oct, 13:30 - 14:30

Abstract: F# is a succinct and expressive typed functional programming language for the .NET platform, and Microsoft will be supporting F# as a first class language in Visual Studio 2010. We'll take a look at what you need to know to start having fun with F#, and how to use it productively. We'll also look at some sample applications of F# and functional programming and cover aspects of parallel, reactive and asynchronous programming with F#.

Target Audience: Developers, architects and anyone interested in learning how to apply functional techniques in practice and have fun along the way

Panel: "Concurrency Expert Panel"

Track: The Concurrency challenge

Time: Tuesday, 6 Oct, 13:30 - 14:30

Abstract: One theme of the panel is concurrent programming models. Specifically; classic locking, transactional memory and actors. And with concurrency we mean parallel systems (e.g. shared-memory multicore, cluster)

The goal is performance
One trust domain
Latencies are small and predicable
One failure => kill the program is just about tolerable
One of the goals for the discussion would be to get a better understanding of strengths and weaknesses; advice and discussion about when to use which model.

Another goal is:

for the audience to get to "pick the brains of the experts"
to get a good discussion going amongst the experts
to get concrete advice on choice of programming language (hence model) for certain problems.
advice on solving common problems that appear when using a particular model

Visual Studio 2010 Beta1 with F# is now available, plus matching F# CTP Update for VS2008

dsyme — Wed, 20 May 2009 20:57:00 GMT

The F# team are thrilled to announce that Visual Studio 2010 Beta1 is now available , including the latest version of F#. Today we are also releasing a matching F# May 2009 CTP for use with Visual Studio 2008 (MSI, ZIP). Further below is a screen shot, more here.

If you’re new to F#, consider watching the PDC presentation on F# by Luca Bolognese, and the live demo of F# and other new language technologies at JAOO by Anders Hejlsberg, Where are Programming Languages Going, or else download, start playing and take the MSDN walkthrough of F# in Visual Studio 2010.

This release is a landmark in the process of making F# a language officially supported by Microsoft, being the first release where F# installs as part of Visual Studio 2010. Using Visual Studio 2010 you can build F# applications for .NET 4.0 Beta1, which has been released today. Likewise, using the F# CTP Update for Visual Studio 2008, you can build F# applications for .NET 2.0/3.0 and 3.5. The F# language itself is the same in both releases, with some additional library functions (e.g. Array.Parallel.map) available with .NET 4.0/Visual Studio 2010 Beta1 (see the detailed release notes).

As with our previous CTP release, one team focus of the last 6 months has been on refining the F# language and taking feedback from the wonderful and growing F# community. For example, we have now made the F# lightweight syntax option the default for the language (i.e. for .fs/.fsi/.fsx files). We have added support for custom numeric type literals, which allows F# to interoperate nicely with the BigInteger type on .NET 4.0, and have improved aspects of .NET interoperability such as smoother calling of .NET param array methods. You can also use F#'s support for units-of-measure with integer types, e.g. to qualify integer types by annotations such as <Pixels> or <Clicks>. Additionally, we have been focusing on the performance of F# language constructs in this release. In particular, we have made performance improvements to F# sequence expressions, using a state machine compilation for sequence expressions that provides substantial performance improvements for code that generates data using these constructs. Similarly, if you disassemble some F# code you will notice that F# classes have compact representations, and that some other constructs such as F# members taking arguments in curried form are compiled more efficiently. Taken together our aim has been to ensure a predictability in the performance characteristics of related language constructs. More detail in the detailed release notes.

One area we have done considerable work is the F# library, and existing users will notice this when they move their code to this release. The consistent feedback we've had is that the F# library support must be consistent , powerful and simple to use. As a result, we have completed an end-to-end review of the library and made some revisions to ensure standard naming conventions and standard, simpler operator names . The library also now uses uppercase type variable names. More details are available in the detailed release notes, including details of two small breaking changes and some simple ways to cope with these. The Visual Studio 2008 release also provides versions of FSharp.Core.dll to use when developing F# applications for Silverlight 2.0 and the .NET Compact Framework 2.0/3.5.

This release also sees major improvements in F# debugging. First, in Visual Studio 2010 F# benefits from amazing new technology such as time-travel debugging (ok, it’s officially called historical debugging, but I grew up in the eighties). This a product-quality realization of a long term dream of many language implementations. Next, in both Visual Studio 2008 and Visual Studio 2010 you will see major improvements in data visualization for F# language constructs such as records and discriminated unions and F# library types such as lists, maps and sets. Breakpoint and stepping have also greatly improved, and in Visual Studio 2010 breakpoints can be more accurately positioned inside lambda functions. Some library support also aids in adhoc debugging, e.g. the printf format "%+A" can now be used to print the private, internals of and F# structured object (when running code as full-trust), and a width parameter can be specified to fit the formatted text within a visual display, e.g. "%+128A".

We have not neglected the F# Language Service and F# Project System. For example, when you build from Visual Studio you will notice that the error list is now populated with errors from the build process. We have also made many performance and reactivity improvements to the F# language service, eliminating points where the Visual Studio user interface became less reactive due to background computations and increasing the number of cases where intellisense is made available. There are also nice additional touches for scripting with F#, such as hovering over a #r declaration now reveals the exact resolution of an assembly reference.

Next, we now have preliminary documentation for the F# language on the MSDN website (yippee!). These are preliminary, and yes there are glitches, so please have patience and send us your feedback J There is also a minor known bug in the walkthroughs where the code snippets all have extra leading whitespace. Since F# is whitespace-significant by default, be sure to delete this leading whitespace when copying snippets. These new docs are another good F# reference, as well as a resource for getting started with the language.

Finally, we have done considerable work towards aligning F# with .NET 4.0 additions , with the aim of ensuring a long, bright, compatible future for functional, reactive and parallel programming on the .NET platform. For example, you will see that when using .NET 4.0, F# record, tuple and union types now implement the .NET 4.0 standard types IStructuralEquatable and IStructuralComparable. Furthermore F# tuples are compiled using the standard .NET 4.0 type System.Tuple. We've also added some lovely operators to the F# library for .NET 4.0, in the Microsoft.FSharp.Collections.Array.Parallel module, building on the .NET Parallel Extensions library. For example Array.Parallel.map can be used to perform a parallel map of a function over a large data array. Finally, you'll notice the addition of Async.CreateAsTask and the extension property .AwaitTask as ways to create and wait for .NET 4.0 tasks, meaning you can program .NET tasks directly using the F# asynchronous programming support!

Details of all this and more is in the detailed release notes, and look for more blogging by the F# team and community about all this and more. As always we are very glad to hear your feedback on all aspects of F#, and the above updates especially. We trust you enjoy your F# programming!

Don Syme, for the F# team

Talks I'm Giving This Week: Göteborg, Aarhus, Copenhagen

dsyme — Mon, 23 Mar 2009 18:35:00 GMT

I’ve a busy week ahead!

Tuesday (tomorrow!), 10am: Informal talk at Chalmers University, Göteborg: F# in Visual Studio 2010, courtesy of John Hughes

Tuesday (tomorrow!), 1pm: SDC 2009, Scandinavian Developers Conference, Göteborg: Functional and Parallel Programming with F#

Wednesday, 12noon-2pm: Aarhus University: Why is Microsoft Investing in Functional Programming? And A Look at Some Technical Aspects of F#

Thursday, 10am: Copenhagen University: likewise

Thursday, 3pm-5pm: Microsoft Copenhagen Development Center: open talk on F# for Developers

The last will be recorded!

If you’re in the area and can make it to a talk, then do introduce yourself. Hope to see you there!

Kind regards

don

Specify your C# and F# code using NaturalSpec, from the Dynamics NAV team

dsyme — Fri, 27 Feb 2009 19:01:00 GMT

Some members of the Dynamics NAV team have announced NaturalSpec, a DSL/language/tool/methodology you can use to specify and test .NET code, e.g. code written in C# or F#. The tool is implemented in F#, and looks like a great addition to the .NET ecosystem.

The idea of NaturalSpec is to give domain experts the possibility to express their scenarios directly in compilable Unit Test scenarios by using a Domain-specific language (DSL) for Unit Tests. NaturalSpec is completely written in F# – but you don’t have to learn F# to use it. You don’t even have to learn programming at all.

...

Of course you can use NaturalSpec to specify C# objects. I see my post "Using NaturalSpec to create a spec for C# projects" for a small sample.

You can download NaturalSpec at GoogleCode and follow the “Getting started” tutorial in order to write your first automatically testable spec.

I am very interested in your feedback. Do you like the syntax? What should I change? Do you consider using a spec tool like NaturalSpec?

F# Programming Contest, by Kean at AutoDesk

dsyme — Sun, 11 Jan 2009 22:20:00 GMT

Kean over at AutoDesk (think AutoCAD etc.) is running an F# programming contest!

I've included his post below:

F# programming contest

...

So to start 2009 with a bang (or a pop, at least) I'm going to run a programming contest. The basic idea is to generate some cool examples of using functional programming (more specifically F#) with design applications (more specifically those developed by Autodesk :-). See below for some ideas on what areas people might be interested in looking into.

Up for grabs are three copies of Don Syme's book, Expert F#, which have been kindly donated by Apress, its publisher. I've mentioned this excellent book in the past, when I introduced my interview with Don (the interview itself is here). With any luck I'll find a way to get Don to sign the books before sending them to the lucky winners.

So, now for some ground-rules...

To enter the contest you need to email me a source project which uses F# for a particular task within one or more of Autodesk's products.

The project should be accompanied with a description of what it does and how to use it. Please provide sample models, if they're needed to make the code work.

I do need to see the full source, as I can't assess the quality of the code otherwise.

There's no limit on the size, as long as I can get the code to work easily.

F# code has the potential to be extremely succinct, so please don't assume that bigger means better. Code will be assessed for its elegance as well as what it does.

The code submitted must be considered non-confidential and license-free.

Which means it can be published (with appropriate credit) via this blog and potentially used by people in commercial applications.

I will act as the sole judge, although I may include other people if assessing the use of APIs with which I'm unfamiliar. The judge's decision is final.

I can feel the power coursing through my fingertips as I write this... :-)

Each of the best three entries will win a copy of "Expert F#".
Absolutely anyone can enter, including Autodesk employees, their family members and pets.

I'll be publishing the winners' names and probably some information provided by them, so please don't expect to remain completely anonymous if you enter the competition.

The closing date for the contest is February 28th, 2009.

Here are some thoughts on areas that might prove interesting...

Data-centric problems

Functional programming is very good at managing (parsing, analysing, even creating) large sets of data. One previous, simple example was to gather and sort all the words found in an AutoCAD drawing. Here's the original post showing this, but an update was provided in my F# AU handouts.

Control flow-centric problems

If you have tasks that can easily be parallelized - in that they can safely be run asynchronously and/or concurrently - then functional programming provides a clean way to capture and execute the logic behind them. An example being a simple application that went away and queried RSS feeds asynchronously, using the results to generate AutoCAD entities. Here are the original posts showing this, but an update was provided in my F# AU handouts.

Domain Specific Languages (DSLs)

Implementing new, custom-purpose programming languages can be an efficient way to control the subset of language features used by a non-programmers to implement code. An example of this was the 3D LOGO implementation inside AutoCAD.

Units of measure

One F# language feature that I also see as being very relevant to our domain is the units of measure implementation. I haven't yet worked with this, myself, but I have certainly been meaning to.

I think that's everything... if I've missed something or you need clarification, please email me or post a comment and I'll respond. Hopefully some of you find this a fun challenge for the (often quite gloomy) start of the year.