Tim Ng

Where do you use F#?

Timothy Ng — Thu, 13 May 2010 12:50:49 GMT

Recently on StackOverflow there was a question asked about “what areas might the use of F# would be more appropriate then C#”. Some of the answers are very insightful – take a look and see if you agree or disagree! You’ll notice that my good friend Jared commented on his own experience using F# on his Vim project I posted about.

VS2010 + VIM

Timothy Ng — Fri, 07 May 2010 16:29:12 GMT

As you may know, I am a diehard VIM user. Thankfully, Jared, a big F# fan (Jared and I used to work on VB together), has written a plug-in for VS2010 called VsVim which supports VIM emulation in VS2010. If you are a VIM user, this plug-in is essential! I can’t imagine using VS without this plug-in.

To install VsVim, use the Visual Studio 2010 Extension Manager, and search for VsVim in the Online Gallery.

Jared has also released the source of VsVim - http://github.com/jaredpar/VsVim.

As a bonus, the core engine is written in F#!

F# + WPF + Events

Timothy Ng — Thu, 06 May 2010 18:46:23 GMT

I recently had to do some travelling for the VS launch event in Las Vegas and QCON event in Beijing. One of the things thats nice about travelling is that it gives you time to do some things you may not otherwise do - in my case, I had a chance to try to (re) learn WPF and see how I can use F# with WPF. This sample is a result of that.

This sample builds on the F# Twitter streaming sample that Don blogged about. Our goal will be to take the sample and modify it to build a WPF UI on top of the twitter event stream so that we can visualize the tweets.

Download the twitter streaming client sample.

Strategy

The overall implementation strategy is to implement an event handler for the twitter events and push updates into an observable collection, which is a WPF collection that can be data-bound to a UI control. XAML data binding is used to hook up the elements of the collection to the list box items.

Details

To start off, we have code loads the XAML file (which was compiled as a resource into the F# application) and then finds the controls we are interested in:

Loading XAML into F#
let w = Application.LoadComponent(new System.Uri("/twitterstream;component/Window.xaml", System.UriKind.Relative)) :?> Window
 let b = w.FindName("buttonToggle") :?> Button
 let imageList = w.FindName("imageList") :?> ListBox

Next, we create an observable collection, bind it to the image list, and pass that to a function which sets up the event handler:

ObservableCollection
let c = new ObservableCollection()
 imageList.ItemsSource <- c
 setupEvent c

Here’s how we setup the event handler:

Event Composition
let setupEvent (c : ObservableCollection) =
     twitterStream.NewTweet 
     |> every 20
     |> Event.choose parseTweet
     |> Event.add (fun s ->
                     System.Diagnostics.Debug.WriteLine(s.Status)
                     c.Insert(0, s) |> ignore)

Notice that the event handler will eventually insert the parsed tweet into the observable collection. (If you are not familiar with events in F#, I will post a blog entry on this in the near future).

The parseTweet function takes the XML and returns UseStatus type:

Code Snippet
type UserStatus = 
     { UserName : string; 
       ProfileImage : string; 
       Status : string; 
       StatusDate : DateTime }

Once we data bind the “root” object via F# code, the XAML code takes care of binding elements of the observable collection (which have type UserStatus). Here’s the interesting XAML code in the data template for the ListBox that binds the elements of the collection to the list box items:

XAML
<Image Grid.Column="0"
        Source="{Binding Path=ProfileImage}"
        Stretch="Fill"
        Height="50" />
 <Label Grid.Column="1"
        Height="50">
     <TextBlock Text="{Binding Path=Status}"
                TextWrapping="WrapWithOverflow"
    />
 Label>

Notice that the image is bound to the URL specified in the ProfileImage field of the UserStatus type, and the Label content is bound to the Status field of the UserStatus type.

Summary

I hope this sample highlights how to integrate F# and F# events with WPF.

QCON 2010 Presentation Sample

Timothy Ng — Tue, 27 Apr 2010 08:56:00 GMT

I’ve posted the QCON 2010 F# presentation sample on my code gallery page. The QCON experience was very positive for me, and I had a great time both at QCON and hanging out with the MS MVPs in Beijing. Looking forward to the next time I can visit!

QCon 2010 Beijing and Chinese F# Blogs

Timothy Ng — Thu, 22 Apr 2010 22:26:02 GMT

I’m currently in Beijing, China attending the QCON conference and giving a presentation on F#. It has been a blast so far! Jeff has been a great host and he is an avid F# enthusiast in China – he has a blog (in Chinese) - http://blog.zhaojie.me.

In addition, the F# Shanghai team has been busy translating popular blogs written by members of our team from English to Chinese – you can see them here http://blog.joycode.com/fscti.

I’ll be posting up the presentation and samples from my QCON 2010 Beijing talk soon!

F# Channel 9 at Visual Studio 2010 Launch Event

Timothy Ng — Mon, 12 Apr 2010 11:01:26 GMT

Channel9 will be doing interviews throughout the Visual Studio 2010 Launch Event at Las Vegas, and at 11:30 AM PDT the Visual Studio Managed Language Team will be on the air! If you want to ask us any questions, send a tweet to @ch9live and watch it here!

F# Released!

Timothy Ng — Mon, 12 Apr 2010 09:15:42 GMT

Just a few moments ago, Bob Muglia announced the general availability of Visual Studio 2010 at the launch event at Las Vegas. I am extremely proud to say that this event also means that the official release of F# is now released! Our team has worked extremely hard to bring the first release of F# to you, and we truly hope you enjoy your experience with F#.

Don has more details on F#, and be sure check out the F# dev center for more information.

I am currently at the launch event in Las Vegas, so if you are also taking part in the festivities and want to chat about F#, come seek me out at the VS booth or come to my session on F# on Tuesday, April 13th!

F# Quick Guides: Object Oriented Programming

Timothy Ng — Tue, 06 Apr 2010 10:21:00 GMT

Hello! As I mentioned in my earlier post, the F# team is tremendously proud of being a part of Visual Studio 2010. We have worked long and hard to get to this point, and we are very excited with the release of the first fully supported F# language.

To kick off the release of F#, I wanted to share with you a few quick guides to F#. The point of the quick guides is not to be a comprehensive language reference, but more of a “I know how to do this in C#, but how do I do it in F#” guide. As a result, the guides will be organized in table format, with F# code in the left, and corresponding C# code on the right.

The first guide will be about Object Oriented Programming in F#. You can download a copy of the F# Object Oriented Programming Quick Guide to make it easy for offline browsing. In addition, I’ve provided the F# source code for all the examples on the F# Quick Guides Code Gallery page.

Without further ado, here is the F# Quick Guide for Object Oriented Programming.

Language Feature

Classes with properties and default constructor

type Vector(x : float, y : float) =

member this.X = x

member this.Y = y

// Usage:

let v = Vector(10., 10.)

let x = v.X

let y = v.Y

public class Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double X

{

get { return this.x; }

}

public double Y

{

get { return this.y; }

}

// Usage:

Vector v = new Vector(10, 10);

double x = v.X;

double y = v.Y;

Structs with properties

[]

type Vector(x : float, y : float) =

member this.X = x

member this.Y = y

// Usage:

let v = Vector(10., 10.)

let x = v.X

let y = v.Y

public struct Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double X

{

get { return this.x; }

}

public double Y

{

get { return this.y; }

}

// Usage:

Vector v = new Vector(10, 10);

double x = v.X;

double y = v.Y;

Multiple constructors

type Vector(x : float, y : float) =

member this.X = x

member this.Y = y

new(v : Vector, s) = Vector(v.X * s, v.Y * s)

// Usage:

let v = Vector(10., 10.)

let w = new Vector(v, 0.5)

public class Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public Vector(Vector v, double s) :

this(v.x * s, v.y * s)

{

}

// Usage:

Vector v = new Vector(10, 10);

Vector w = new Vector(v, 0.5);

Member functions

type Vector(x : float, y : float) =

member this.Scale(s : float) =

Vector(x * s, y * s)

// Usage:

let v = Vector(10., 10.)

let v2 = v.Scale(0.5)

public class Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double Scale(double s)

{

return new Vector(this.x * s,

this.y * s);

}

// Usage:

Vector v = new Vector(10, 10);

Vector v2 = v.Scale(0.5);

Operators

type Vector(x, y) =

member this.X = x

member this.Y = y

static member (*) (a : Vector, b : Vector) =

a.X * b.X + a.Y + b.Y

// Usage:

let x = Vector(2., 2.)

let y = Vector(3., 3.)

let dp = x * y

public class Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double X

{

get { return this.x; }

}

public double Y

{

get { return this.y; }

}

public static double operator * (

Vector v1, Vector v2)

{

return v1.x * v2.x + v1.y * v2.y;

}

// Usage:

Vector x = new Vector(2, 2);

Vector y = new Vector(3, 3);

double dp = x * y;

Static members and properties

type Vector(x, y) =

member this.X = x

member this.Y = y

static member Dot(a : Vector, b : Vector) =

a.X * b.X + a.Y + b.Y

static member NormX = Vector(1., 0.)

// Usage:

let x = Vector(2., 2.)

let y = Vector.NormX

let dp = Vector.Dot(x, y)

public class Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double X

{

get { return this.x; }

}

public double Y

{

get { return this.y; }

}

public static double Dot(Vector v1,

Vector v2)

{

return v1.x * v2.x + v1.y * v2.y;

}

public static Vector NormX

{

get { return new Vector(1, 0); }

}

// Usage:

Vector x = new Vector(2, 2);

Vector y = Vector.NormX;

double dp = Vector.Dot(x, y);

Class properties that use let value computations in the constructor

type Vector(x, y) =

let mag = sqrt(x * x + y * y)

let rad = if x = 0. && y = 0. then

else if x >= 0. then

asin(y / mag)

else

(-1. * asin(y / mag)) +

Math.PI

member this.Mag = mag

member this.Rad = rad

// Usage:

let v = Vector(10., 10.)

let mag = v.Mag

let rad = v.Rad

public class Vector

{

double mag = 0.0;

double rad = 0.0;

public Vector(double x, double y)

{

this.mag = Math.Sqrt(x * x + y * y);

if (x == 0.0 && y == 0.0) rad = 0.0;

else if (x >= 0.0)

rad = Math.Asin(y / mag);

else

rad = (-1.0 * Math.Asin(y / mag)) +
Math.PI;

}

public double Mag

{

get { return this.mag; }

}

public double Rad

{

get { return this.rad; }

}

// Usage:

Vector v = new Vector(10, 10);

double mag = v.Mag;

double rad = v.Rad;

Class members that use private function values

type Vector(x, y) =

let rotate a =

let x' = x * cos a – y * sin a

let y' = y * sin a + y * cos a

new Vector(x', y')

member this.RotateByDegrees(d) =

rotate (d * Math.PI / 180.)

member this.RotateByRadians(r) =

rotate r

// Usage:

let v = Vector(10., 0.)

let x = v.RotateByDegrees(90.)

let y = v.RotateByRadians(Math.PI / 6.)

public class Vector

{

double x = 0.0;

double y = 0.0;

Vector rotate(double a)

{

double xx = this.x * Math.Cos(a) –

this.y * Math.Sin(a);

double yy = this.y * Math.Sin(a) +

this.y * Math.Cos(a);

return new Vector(xx, yy);

}

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public Vector RotateByDegrees(double d)

{

return rotate(d * Math.PI / 180);

}

public Vector RotateByRadians(double r)

{

return rotate(r);

}

// Usage:

Vector v = new Vector(10, 10);

Vector x = v.RotateByDegrees(90.0);

Vector y = v.RotateByRadians(Math.PI / 6.0);

Overloading members

type Car() =

member this.Drive() =

this.Drive(10)

()

member this.Drive(mph : int) =

// Do something

()

// Usage:

let c = Car()

c.Drive()

c.Drive(10)

public class Car

{

public void Drive()

{

Drive(10);

}

public void Drive(int mph)

{

// Do something

}

// Usage:

Car c = new Car();

c.Drive();

c.Drive(10);

Mutable fields in a class with get/set properties

type MutableVector(x : float, y : float) =

let mutable cx = x

let mutable cy = y

member this.X with get() = cx and

set(v) = cx <- v

member this.Y with get() = cy and

set(v) = cy <- v

member this.Length = sqrt(x * x + y * y)

// Usage:

let v = MutableVector(2., 2.)

let len1 = v.Length

v.X <- 3.

v.Y <- 3.

let len2 = v.Length

public class MutableVector

{

public MutableVector(double x, double y)

{

this.X = x;

this.Y = y;

}

public double X { get; set; }

public double Y { get; set; }

public double Length

{

get { return Math.Sqrt(

this.X * this.X +

this.Y * this.Y); }

}

// Usage:

MutableVector v = new MutableVector(2.0, 2.0);

double len1 = v.Length;

v.X = 3.0;

v.Y = 3.0;

double len2 = v.Length;

Generic classes and function arguments

type Factory<'T>(f : unit -> 'T) =

member this.Create() =

f()

// Usage:

let strings = Factory(

fun () -> "Hello!")

let res = strings.Create()

let ints = Factory(fun () -> 10)

let res = ints.Create()

public class Factory

{

Func creator;

public Factory(Func f)

{

this.creator = f;

}

public T Create()

{

return this.creator();

}

// Usage:

Factory<string> strings = new

Factory<string>(() => "Hello");

string res1 = strings.Create();

Factory<int> ints = new Factory<int>(() => 10);

int res2 = ints.Create();

Generic classes and methods

type Container<'T>(a : 'T) =

member this.Convert<'U>(f : 'T -> 'U) =

f a

// Usage:

let c = new Container(10)

let b = c.Convert(fun a -> a.ToString())

public class Container

{

private T value;

public Container(T t)

{

this.value = t;

}

public U Convert(Func f)

{

return f(this.value);

}

// Usage:

Container<int> c = new Container<int>(10);

string result = c.Convert(n => n.ToString());

Extension methods

type List<'T> with

member this.MyExtensionMethod() =

this |> Seq.map (fun a -> a.ToString())

// Usage:

let c = [1; 2; 3]

let d = c.MyExtensionMethod()

public static class ExtensionMethods

{

public static IEnumerable<string>

MyExtensionMethod(this List a)

{

return a.Select(s => s.ToString());

}

// Usage:

List<int> l = new List<int> { 1, 2, 3 };

IEnumerable<string> res =

l.MyExtensionMethod();

Extension properties

type List<'T> with

member this.MyExtensionProp =

this |> Seq.map (fun a -> a.ToString())

// Usage:

let c = [1; 2; 3]

let d = c.MyExtensionProp

N/A. C# does not support this feature.

Indexers

type Table() =

member this.Item

with get(key : string) = int key

// Usage:

let tab = Table()

let x = tab.["10"]

let y = tab.["12"]

public class Table

{

public int this[string key]

{

get { return Convert.ToInt32(key); }

}

// Usage:

Table tab = new Table();

int x = tab["10"];

int y = tab["12"];

Indexed Properties

type Table() =

member this.Values

with get(key : string) = int key

member this.MultipleValues

with get(key1, key2) = key1 + key2

// Usage:

let tab = Table()

let x = tab.Values("10")

let y = tab.Values("12")

let a = tab.MultipleValues(10, 5)

N/A. C# does not support this feature.

Abstract classes

[]

type Shape() =

abstract Name : string with get

abstract Scale : float -> Shape

public abstract class Shape

{

public abstract string Name { get; }

public abstract Shape Scale(double scale);

}

Derive from a base class and overriding base methods with generics

[]

type Shape<'T>() =

abstract Name : string with get

abstract Scale : float -> 'T

type Vector(angle, mag) =

inherit Shape()

member this.Angle = angle

member this.Mag = makg

override this.Name = "Vector"

override this.Scale(factor) =

Vector(angle, mag * factor)

// Usage:

let v = Vector(45., 10.)

let v2 = v.Scale(0.5)

public abstract class Shape

{

public abstract string Name { get; }

public abstract T Scale(double scale);

}

public class Vector : Shape<Vector>

{

double angle;

double mag;

public double Angle {get{return angle;}}

public double Mag {get{return mag;}}

public Vector(double angle, double mag)

{

this.angle = angle;

this.mag = mag;

}

public override string Name

{

get { return "Vector"; }

}

public override Vector Scale(double scale)

{

return new Vector(this.Angle,

this.Mag * scale);

}

// Usage:

Vector v = new Vector(45, 10);

Vector v2 = v.Scale(0.5);

Calling a base class method

type Animal() =

member this.Rest() =

// Rest for the animal

()

type Dog() =

inherit Animal()

member this.Run() =

// Run

base.Rest()

// Usage:

let brian = new Dog()

brian.Run()

public class Animal

{

public void Rest()

{

// Rest for the animal

}

public class Dog : Animal

{

public void Run()

{

// Run

base.Rest();

}

// Usage:

Dog brian = new Dog();

brian.Run();

Implementing an interface

type IVector =

abstract Mag : double with get

abstract Scale : float -> IVector

type Vector(x, y) =

interface IVector with

member this.Mag = sqrt(x * x + y * y)

member this.Scale(s) =

Vector(x * s, y * s) :> IVector

member this.X = x

member this.Y = y

// Usage:

let v = new Vector(1., 2.) :> IVector

let w = v.Scale(0.5)

let mag = w.Mag

interface IVector

{

double Mag { get; }

IVector Scale(double s);

}

class Vector : IVector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double X

{

get { return this.x; }

}

public double Y

{

get { return this.y; }

}

public double Mag

{

get { return Math.Sqrt(
this.x * this.x +

this.y * this.y); }

}

public IVector Scale(double s)

{

return new Vector(this.x * s,

this.y * s);

}

// Usage:

IVector v = new Vector(1, 2);

IVector w = v.Scale(0.5);

double mag = w.Mag;

Implementing an interface with object expressions

type ICustomer =

abstract Name : string with get

abstract Age : int with get

let CreateCustomer name age =

{ new ICustomer with

member this.Name = name

member this.Age = age

}

// Usage:

let c = CreateCustomer "Snoopy" 16

let d = CreateCustomer "Garfield" 5

N/A. C# does not support creating object expressions.

Events

type BarkArgs(msg:string) =

inherit EventArgs()

member this.Message = msg

type BarkDelegate =

delegate of obj * BarkArgs -> unit

type Dog() =

let ev = new Event()

member this.Bark(msg) =

ev.Trigger(this, new BarkArgs(msg))

[]

member this.OnBark = ev.Publish

// Usage:

let snoopy = new Dog()

snoopy.OnBark.Add(

fun ba -> printfn "%s" (ba.Message))

snoopy.Bark("Hello")

public class BarkArgs : EventArgs

{

private string msg;

public BarkArgs(string msg)

{

this.msg = msg;

}

public string Message

{

get { return this.msg; }

}

public delegate void BarkDelegate(

Object sender, BarkArgs args);

class Dog

{

public event BarkDelegate OnBark;

public void Bark(string msg)

{

OnBark(this, new BarkArgs(msg));

}

// Usage:

Dog snoopy = new Dog();

snoopy.OnBark += new BarkDelegate(

(sender, msg) =>

Console.WriteLine(msg.Message));

snoopy.Bark("Hello");

Explicit class constructor

type Vector =

val mutable x : float

val mutable y : float

new() = {x = 0.; y = 0.}

// Usage:

let v = Vector()

v.x <- 10.

v.y <- 10.

Explicit public fields

type Vector() =

[]

val mutable x : int

[]

val mutable y : int

// Usage:

let v = Vector()

v.x <- 10

v.y <- 10

public class Vector

{

public int x;

public int y;

}

// Usage:

Vector v = new Vector();

v.x = 10;

v.y = 10;

Explicit struct definition

[]

type Vector =

val mutable public x : int

val mutable public y : int

// Usage:

let mutable v = Vector()

v.x <- 10

v.y <- 10

public struct Vector

{

public int x;

public int y;

}

// Usage:

Vector v = new Vector();

v.x = 10;

v.y = 10;

F# Quick Guides: Object Oriented Programming

Timothy Ng — Mon, 05 Apr 2010 23:47:00 GMT

F# Quick Guides: Object Oriented Programming

This document is a quick guide of F #object oriented programming constructs and their equivalent in C#, where applicable. For more information on F#, please visit http://www.fsharp.net for documentation, videos, and samples.

Language Feature

Classes with properties and default constructor

type Vector(x : float, y : float) =

member this.X = x

member this.Y = y

// Usage:

let v = Vector(10., 10.)

let x = v.X

let y = v.Y

public class Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double X

{

get { return this.x; }

}

public double Y

{

get { return this.y; }

}

// Usage:

Vector v = new Vector(10, 10);

double x = v.X;

double y = v.Y;

Structs with properties

[]

type Vector(x : float, y : float) =

member this.X = x

member this.Y = y

// Usage:

let v = Vector(10., 10.)

let x = v.X

let y = v.Y

public struct Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double X

{

get { return this.x; }

}

public double Y

{

get { return this.y; }

}

// Usage:

Vector v = new Vector(10, 10);

double x = v.X;

double y = v.Y;

Multiple constructors

type Vector(x : float, y : float) =

member this.X = x

member this.Y = y

new(v : Vector, s) = Vector(v.X * s, v.Y * s)

// Usage:

let v = Vector(10., 10.)

let w = new Vector(v, 0.5)

public class Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public Vector(Vector v, double s) :

this(v.x * s, v.y * s)

{

}

// Usage:

Vector v = new Vector(10, 10);

Vector w = new Vector(v, 0.5);

Member functions

type Vector(x, y) =

member this.Scale(s) =

Vector(x * s, y * s)

// Usage:

let v = Vector(10., 10.)

let v2 = v.Scale(0.5)

public class Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double Scale(double s)

{

return new Vector(this.x * s,

this.y * s);

}

// Usage:

Vector v = new Vector(10, 10);

Vector v2 = v.Scale(0.5);

Operators

type Vector(x, y) =

member this.X = x

member this.Y = y

static member (*) (a : Vector, b : Vector) =

a.X * b.X + a.Y + b.Y

// Usage:

let x = Vector(2., 2.)

let y = Vector(3., 3.)

let dp = x * y

public class Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double X

{

get { return this.x; }

}

public double Y

{

get { return this.y; }

}

public static double operator * (

Vector v1, Vector v2)

{

return v1.x * v2.x + v1.y * v2.y;

}

// Usage:

Vector x = new Vector(2, 2);

Vector y = new Vector(3, 3);

double dp = x * y;

Static members and properties

type Vector(x, y) =

member this.X = x

member this.Y = y

static member Dot(a : Vector, b : Vector) =

a.X * b.X + a.Y + b.Y

static member NormX = Vector(1., 0.)

// Usage:

let x = Vector(2., 2.)

let y = Vector.NormX

let dp = Vector.Dot(x, y)

public class Vector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double X

{

get { return this.x; }

}

public double Y

{

get { return this.y; }

}

public static double Dot(Vector v1,

Vector v2)

{

return v1.x * v2.x + v1.y * v2.y;

}

public static Vector NormX

{

get { return new Vector(1, 0); }

}

// Usage:

Vector x = new Vector(2, 2);

Vector y = Vector.NormX;

double dp = Vector.Dot(x, y);

Class properties that use let value computations in the constructor

type Vector(x, y) =

let mag = sqrt(x * x + y * y)

let rad = if x = 0. && y = 0. then

else if x >= 0. then

asin(y / mag)

else

(-1. * asin(y / mag)) +

Math.PI

member this.Mag = mag

member this.Rad = rad

// Usage:

let v = Vector(10., 10.)

let mag = v.Mag

let rad = v.Rad

public class Vector

{

double mag = 0.0;

double rad = 0.0;

public Vector(double x, double y)

{

this.mag = Math.Sqrt(x * x + y * y);

if (x == 0.0 && y == 0.0) rad = 0.0;

else if (x >= 0.0)

rad = Math.Asin(y / mag);

else

rad = (-1.0 * Math.Asin(y / mag)) +
Math.PI;

}

public double Mag

{

get { return this.mag; }

}

public double Rad

{

get { return this.rad; }

}

// Usage:

Vector v = new Vector(10, 10);

double mag = v.Mag;

double rad = v.Rad;

Class members that use private function values

type Vector(x, y) =

let rotate a =

let x' = x * cos a – y * sin a

let y' = y * sin a + y * cos a

new Vector(x', y')

member this.RotateByDegrees(d) =

rotate (d * Math.PI / 180.)

member this.RotateByRadians(r) =

rotate r

// Usage:

let v = Vector(10., 0.)

let x = v.RotateByDegrees(90.)

let y = v.RotateByRadians(Math.PI / 6.)

public class Vector

{

double x = 0.0;

double y = 0.0;

Vector rotate(double a)

{

double xx = this.x * Math.Cos(a) –

this.y * Math.Sin(a);

double yy = this.y * Math.Sin(a) +

this.y * Math.Cos(a);

return new Vector(xx, yy);

}

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public Vector RotateByDegrees(double d)

{

return rotate(d * Math.PI / 180);

}

public Vector RotateByRadians(double r)

{

return rotate(r);

}

// Usage:

Vector v = new Vector(10, 10);

Vector x = v.RotateByDegrees(90.0);

Vector y = v.RotateByRadians(Math.PI / 6.0);

Overloading members

type Car() =

member this.Drive() =

this.Drive(10)

()

member this.Drive(mph : int) =

// Do something

()

// Usage:

let c = Car()

c.Drive()

c.Drive(10)

public class Car

{

public void Drive()

{

Drive(10);

}

public void Drive(int mph)

{

// Do something

}

// Usage:

Car c = new Car();

c.Drive();

c.Drive(10);

Mutable fields in a class with get/set properties

type MutableVector(x : float, y : float) =

let mutable cx = x

let mutable cy = y

member this.X with get() = cx and

set(v) = cx <- v

member this.Y with get() = cy and

set(v) = cy <- v

member this.Length = sqrt(x * x + y * y)

// Usage:

let v = MutableVector(2., 2.)

let len1 = v.Length

v.X <- 3.

v.Y <- 3.

let len2 = v.Length

public class MutableVector

{

public MutableVector(double x, double y)

{

this.X = x;

this.Y = y;

}

public double X { get; set; }

public double Y { get; set; }

public double Length

{

get { return Math.Sqrt(

this.X * this.X +

this.Y * this.Y); }

}

// Usage:

MutableVector v = new MutableVector(2.0, 2.0);

double len1 = v.Length;

v.X = 3.0;

v.Y = 3.0;

double len2 = v.Length;

Generic classes and function arguments

type Factory<'T>(f : unit -> 'T) =

member this.Create() =

f()

// Usage:

let strings = Factory(

fun () -> "Hello!")

let res = strings.Create()

let ints = Factory(fun () -> 10)

let res = ints.Create()

public class Factory

{

Func creator;

public Factory(Func f)

{

this.creator = f;

}

public T Create()

{

return this.creator();

}

// Usage:

Factory<string> strings = new

Factory<string>(() => "Hello");

string res1 = strings.Create();

Factory<int> ints = new Factory<int>(() => 10);

int res2 = ints.Create();

Generic classes and methods

type Container<'T>(a : 'T) =

member this.Convert<'U>(f : 'T -> 'U) =

f a

// Usage:

let c = new Container(10)

let b = c.Convert(fun a -> a.ToString())

public class Container

{

private T value;

public Container(T t)

{

this.value = t;

}

public U Convert(Func f)

{

return f(this.value);

}

// Usage:

Container<int> c = new Container<int>(10);

string result = c.Convert(n => n.ToString());

Extension methods

type List<'T> with

member this.MyExtensionMethod() =

this |> Seq.map (fun a -> a.ToString())

// Usage:

let c = [1; 2; 3]

let d = c.MyExtensionMethod()

public static class ExtensionMethods

{

public static IEnumerable<string>

MyExtensionMethod(this List a)

{

return a.Select(s => s.ToString());

}

// Usage:

List<int> l = new List<int> { 1, 2, 3 };

IEnumerable<string> res =

l.MyExtensionMethod();

Extension properties

type List<'T> with

member this.MyExtensionProp =

this |> Seq.map (fun a -> a.ToString())

// Usage:

let c = [1; 2; 3]

let d = c.MyExtensionProp

N/A. C# does not support this feature.

Indexers

type Table() =

member this.Item

with get(key : string) = int key

// Usage:

let tab = Table()

let x = tab.["10"]

let y = tab.["12"]

public class Table

{

public int this[string key]

{

get { return Convert.ToInt32(key); }

}

// Usage:

Table tab = new Table();

int x = tab["10"];

int y = tab["12"];

Indexed Properties

type Table() =

member this.Values

with get(key : string) = int key

member this.MultipleValues

with get(key1, key2) = key1 + key2

// Usage:

let tab = Table()

let x = tab.Values("10")

let y = tab.Values("12")

let a = tab.MultipleValues(10, 5)

N/A. C# does not support this feature.

Abstract classes

[]

type Shape() =

abstract Name : string with get

abstract Scale : float -> Shape

public abstract class Shape

{

public abstract string Name { get; }

public abstract Shape Scale(double scale);

}

Derive from a base class and overriding base methods with generics

[]

type Shape<'T>() =

abstract Name : string with get

abstract Scale : float -> 'T

type Vector(angle, mag) =

inherit Shape()

member this.Angle = angle

member this.Mag = makg

override this.Name = "Vector"

override this.Scale(factor) =

Vector(angle, mag * factor)

// Usage:

let v = Vector(45., 10.)

let v2 = v.Scale(0.5)

public abstract class Shape

{

public abstract string Name { get; }

public abstract T Scale(double scale);

}

public class Vector : Shape<Vector>

{

double angle;

double mag;

public double Angle {get{return angle;}}

public double Mag {get{return mag;}}

public Vector(double angle, double mag)

{

this.angle = angle;

this.mag = mag;

}

public override string Name

{

get { return "Vector"; }

}

public override Vector Scale(double scale)

{

return new Vector(this.Angle,

this.Mag * scale);

}

// Usage:

Vector v = new Vector(45, 10);

Vector v2 = v.Scale(0.5);

Calling a base class method

type Animal() =

member this.Rest() =

// Rest for the animal

()

type Dog() =

inherit Animal()

member this.Run() =

// Run

base.Rest()

// Usage:

let brian = new Dog()

brian.Run()

public class Animal

{

public void Rest()

{

// Rest for the animal

}

public class Dog : Animal

{

public void Run()

{

// Run

base.Rest();

}

// Usage:

Dog brian = new Dog();

brian.Run();

Implementing an interface

type IVector =

abstract Mag : double with get

abstract Scale : float -> IVector

type Vector(x, y) =

interface IVector with

member this.Mag = sqrt(x * x + y * y)

member this.Scale(s) =

Vector(x * s, y * s) :> IVector

member this.X = x

member this.Y = y

// Usage:

let v = new Vector(1., 2.) :> IVector

let w = v.Scale(0.5)

let mag = w.Mag

interface IVector

{

double Mag { get; }

IVector Scale(double s);

}

class Vector : IVector

{

double x;

double y;

public Vector(double x, double y)

{

this.x = x;

this.y = y;

}

public double X

{

get { return this.x; }

}

public double Y

{

get { return this.y; }

}

public double Mag

{

get { return Math.Sqrt(
this.x * this.x +

this.y * this.y); }

}

public IVector Scale(double s)

{

return new Vector(this.x * s,

this.y * s);

}

// Usage:

IVector v = new Vector(1, 2);

IVector w = v.Scale(0.5);

double mag = w.Mag;

Implementing an interface with object expressions

type ICustomer =

abstract Name : string with get

abstract Age : int with get

let CreateCustomer name age =

{ new ICustomer with

member this.Name = name

member this.Age = age

}

// Usage:

let c = CreateCustomer "Snoopy" 16

let d = CreateCustomer "Garfield" 5

N/A. C# does not support creating object expressions.

Events

type BarkArgs(msg:string) =

inherit EventArgs()

member this.Message = msg

type BarkDelegate =

delegate of obj * BarkArgs -> unit

type Dog() =

let ev = new Event()

member this.Bark(msg) =

ev.Trigger(this, new BarkArgs(msg))

[]

member this.OnBark = ev.Publish

// Usage:

let snoopy = new Dog()

snoopy.OnBark.Add(

fun ba -> printfn "%s" (ba.Message))

snoopy.Bark("Hello")

public class BarkArgs : EventArgs

{

private string msg;

public BarkArgs(string msg)

{

this.msg = msg;

}

public string Message

{

get { return this.msg; }

}

public delegate void BarkDelegate(

Object sender, BarkArgs args);

class Dog

{

public event BarkDelegate OnBark;

public void Bark(string msg)

{

OnBark(this, new BarkArgs(msg));

}

// Usage:

Dog snoopy = new Dog();

snoopy.OnBark += new BarkDelegate(

(sender, msg) =>

Console.WriteLine(msg.Message));

snoopy.Bark("Hello");

Explicit class constructor

type Vector =

val mutable x : float

val mutable y : float

new() = {x = 0.; y = 0.}

// Usage:

let v = Vector()

v.x <- 10.

v.y <- 10.

Explicit public fields

type Vector() =

[]

val mutable x : int

[]

val mutable y : int

// Usage:

let v = Vector()

v.x <- 10

v.y <- 10

public class Vector

{

public int x;

public int y;

}

// Usage:

Vector v = new Vector();

v.x = 10;

v.y = 10;

Explicit struct definition

[]

type Vector =

val mutable public x : int

val mutable public y : int

// Usage:

let mutable v = Vector()

v.x <- 10

v.y <- 10

public struct Vector

{

public int x;

public int y;

}

// Usage:

Vector v = new Vector();

v.x = 10;

v.y = 10;

SIGCSE 2010 and F#

Timothy Ng — Thu, 18 Mar 2010 09:21:00 GMT

This past week I had the chance to attend SIGCSE 2010 and present a session on F#. It was a ton of fun and it was great to talk to many people about F# and how we on the team believe that investing in F#, both professionally and academically, is a fantastic thing. If you would like to get in touch with me about any F# related discussions, just send me an email!

You can download the slides and sample code. For a more indepth tutorial on F#, check out Don’s blog here, and the channel 9 videos here. Download F# here and find more information at our F# center.