The F# compiler and libraries were also recently released as Open Source under the Apache 2.0 license which should make for some exciting developments in the future, not to mention better support for Mono.

I also found F# a good way to understand the slightly functional constructs that appeared in Delphi Prism 2011. I’ve only just started beginning to learn F# but I thought I would highlight some of the particularly interesting differences that I’ve found compared to Delphi.

Identifiers and let bindings

Identifiers are the way which you assign names to your values so that you can reference them later, using the let keyword. To a Delphi programmer this may sound like the concept of variables, however there is one important difference in F#: Variables are immutable and therefore normally can’t be changed and once a value has been assigned to it. Consider the following:

open System

let x = 1
printfn "%d" x

let x = 2
printfn "%d" x

This will produce a compiler error where we attempt to reassign a new value to the identifier x. F# shares the type inference approach of C# 3.0 onwards so you do not need to explicitly declare the types of your variables as you do in Delphi (while Delphi Prism shares the C# approach). It should also be noted that as in Delphi, you can also assign identifiers to methods. For example, in Delphi you might do something like the following:

var
  i: integer;
  myAdder: TFunc<integer, integer, integer>;
begin
  myAdder :=
    function(a, b: integer): integer
    begin
      result := a + b;
    end;
  i := myAdder(1, 2);
end;

The equivalent F# code might look like this where F# Functions are values in their own right anyway:

// Could also be written in longform as:
// let myAdder = fun a b -> a + b

let myAdder a b = a + b
let i = myAdder 1 2

If you’re coming from Delphi, it is also worth noting that identifier names are case-sensitive.

Scope

F# defines scope, by default, using whitespace and indentation creates new scope, and the end of that particular scope is signaled by the end of the indented block. The following example demonstrates this, by reusing the identifier ‘z’ as a midway calculation half way through a block.

let z = 1

let y =
    let z = 3 * 2
    z / 2

printfn "%d" y

This code also demonstrates that like the Ruby language, you do no need to explicitly state a return value for a method. This can be quite freeing in many ways.
It should also be noted that you can redefine identifiers with the let keyword whilst in the scope of a function.

Pattern Matching

Another favoured building block for functional programming is pattern matching. A very simple example of this might be compared to series of case or if statements in Delphi. For example, if we look at an implementation of the FizzBuzz problem in Delphi:

	// if ((i mod 15 = 0)) then
        if ((i mod 3 = 0) and (i mod 5 = 0)) then
        begin
          WriteLn('FizzBuzz');
        end
        else if (i mod 3 = 0) then
        begin
          WriteLn('Fizz');
        end
        else if (i mod 5 = 0) then
        begin
          WriteLn('Buzz');
        end
        else
        begin
          WriteLn(i);
        end;
      end;

And then using pattern matching in F#:

// FizzBuzz Solution - @jamiei
open System

let FizzBuzz() =
    let nums = [1..100]
    let printbuzz x =
        match x with
        // | x when x%15=0 -> printfn("FizzBuzz")
        | x when x%3=0 && x%5=0 -> printfn("FizzBuzz")
        | x when x%3=0 -> printfn("Fizz")
        | x when x%5=0 -> printfn("Buzz")
        | _ -> printfn "%d" x;
    nums |> List.iter(fun x -> printbuzz x)
FizzBuzz()
let _ = Console.ReadLine()

Pattern matching must either be complete (i.e. must match all possible values of an identifier) or incomplete and include a wildcard (“_” in the above example) or the compiler will raise an exception at runtime. The compiler will also emit a warning for rules which will never be matched.

let rand = new Random()
let randNum = rand.Next(0, 100);
let coinToss =
    match randNum % 2 = 0 with
    | true -> "heads"
    //| false -> "tails"
printfn "%A" coinToss

Pattern matching may appear to be a simple tool but it’s an extremely concise way of controlling the flow of an application, particularly to get rid of what would otherwise turn into a spaghetti ball of if statements. Pattern matching can also be active, which means that they allow you to execute a function to determine the match.

Units of measurement

If you were listening carefully to the Podcast of Delphi.org when marc hoffman was talking to Jim McKeeth about the future of Delphi Prism, you’ll remember that he mentioned that this might be coming to Delphi Prism. This represents a pretty nifty way of marking the units of a value which makes you less likely to accidentally make a mistake when combining them with less effort than in Delphi where you would have to declare and create a class for each. The following code in F#, will throw an exception:

[<Measure>]type centimetre
[<Measure>]type inch
let distanceToMyThumb = 1<inch>
let distanceToMyOtherThumb = 2.5<centimetre>
let newVol = distanceToMyThumb + distanceToMyOtherThumb

Summary

F# is a very expressive language and the more I read and use it, the more I find that the expressions and constructs that it allows give me new ways to think about certain problems. It is also great that it is built upon the .NET Framework and can interact fully with the standard .NET libraries. My F# test modules can also interact with and be interacted by any Delphi Prism applications that I need it to. If your curiosity is piqued by functional programming and you are already familiar with the .NET framework then F# is a great way to try your hands.

Further Information

You can find more information on F# here:

• F# MSDN Home
• F# Community Samples
• An Introduction to Functional Programming for .NET Developers

Ever since the release of Delphi.NET there has been much confusion surrounding why you would choose the Delphi language for .NET Development. When Delphi.NET was released there was concern that it was not a first class member of the .NET framework and always seemed to lag 12-18 months behind the lightning fast pace of development of the .NET Framework. With Prism Delphi offerings for .NET are based upon the RemObjects Oxygene compiler which isn’t required to maintain a loose language compatibility with the Win 32 Delphi compiler and therefore is able to progress at a much faster pace.  

Still, despite this: A recent Delphi Prism related thread at StackOverflow showed that there still seems to be a general feeling that Delphi is a second class citizen in the .NET Development World. Some even seemed to suggest that the language features in Prism make it unrecognisable as Delphi. To try to dispense with this idea: I thought that I would show off some of my own favourite new language features in Delphi Prism and ones which for me make it a natural fit for .NET.  

Please note: This is not intended to be a comprehensive guide to the new language features. For that you’ll need to refer to the Delphi Prism Wiki page on Compatibility with Win 32 Delphi.

My favourite new language features which Prism brings to the table for Delphi Developers is LINQ. Olaf Monien, who I also follow on Twitter (@omonien), posted a beautifully simple example of using LINQ with Delphi Prism on his own blog and then showed how Delphi Prism can also do LINQ to SQL. I have replicated his basic example below because it also demonstrates another great language feature.

// Type Declaration
  MusicAlbum = record
  public
    Name: string;
    Artist: string;
    AlbumYear: integer;
  end;

var
  MyAlbum: MusicAlbum;
  MyAlbums : List<MusicAlbum>;
begin
// Create our Album List
MyAlbums := new List<MusicAlbum>; 

// Setup a our records
MyAlbum := new MusicAlbum;
MyAlbum.Artist := 'Kanye West';
MyAlbum.Name := '808s and Heartbreak';
MyAlbum.AlbumYear := 2008;
MyAlbums.Add(MyAlbum);  

// Execute our LINQ Query
var AlbumsLastYear := from Album in MyAlbums where Album.AlbumYear.Equals(2008); 

// Add the result to our listbox
for Album in AlbumsLastYear do
begin
  lbFoundAlbums.Items.Add(Album.Artist + ' - ' + Album.Name + ' (' + Album.AlbumYear + ')');
end;

end;

 
This code clipping also demonstrates Type Inference which allows a variable type to be inferred from the context of it’s usage. For example, consider writing the following: var MyGreatList := new List<String>; or even something as simple as var s := ‘string’;. Type Inference is a useful addition which I can see myself making extensive use of. My only concern about Type Inference is how it affect’s the readability of the code as I am used to reviewing the var section of a method for a guide to what types are used within a method.

LINQ can also be used with XML. The below example takes our previous sample and reads the data from an XML file instead: 

<?xml version="1.0" encoding="UTF-8"?>
<albums>
		<album>
			<artist>Kanye West</artist>
			<title>808s and Heartbreak</title>
			<albumyear>2008</albumyear>
		</album>
		<album>
			<artist>Kanye West</artist>
			<title>Graduation</title>
			<albumyear>2007</albumyear>
		</album>
		<album>
			<artist>Nas</artist>
			<title>Unartistd</title>
			<albumyear>2008</albumyear>
		</album>
		<album>
			<artist>Notorious OST</artist>
			<title>The Notorious B.I.G.</title>
			<albumyear>2009</albumyear>
		</album>
</albums>

var
  AlbumData: XDocument;
begin
  // Load our XML Document with a System.Xml.Linq.XDocument
  AlbumData := XDocument.Load('../../albums.xml');

  // Query for albums in the year 2008
  var AlbumsLastYear := from Album in AlbumData.Descendants('album') where Album.Element('albumyear').Value = '2008' select Album;

  for Album in AlbumsLastYear do
  begin
    var s := String.Format('{0} - {1} ({2})', Album.Element('artist').Value, Album.Element('title').Value , Album.Element('albumyear').Value);
    lbFoundAlbums.Items.Add(s);
  end;

Another new language feature that I like in principle but will completely admit to not fully understanding yet is Anonymous Methods and Delegates which make executing code with different threads much easier. Sadly in my brief testing of Anonymous methods I discovered that they are only available in projects which link to the .NET Framework 3.0 and above (and, in my case, only WPF projects). In order to execute our ListBox adding code from the first code sample as an Anonymous Delegate you can do the following:

// Add the result to our listbox
for Album in AlbumsLastYear do
begin
  Dispatcher.Invoke(DispatcherPriority.ApplicationIdle, method(MyAlbum : MusicAlbum);
      begin
      lbFoundAlbums.Items.Add(MyAlbum.Artist + ' - ' + MyAlbum.Name + ' (' + MyAlbum.AlbumYear + ')');
      end, Album);
end;

This means that the compiler declares a delegate with a signature matching our anonymous method and we have now easily executed this code within a seperate thread with a minimum of code.

There are several new language features which I personally have no use for but which facilitate the use of the Microsoft Parallels framework such as Futures and Parallel sequences. Delphi Prism also supports Generics and as well as most of the standard Delphi Win32 syntax.
 
There are also lots of small additions that aren’t .NET features per-se but demonstrate the usefulness of freeing the Prism compiler and allowing more rapid progression such as Double Boolean Expressions. I’m sure we’ve all written a statement like this before: if (cost > 400) and (cost < 600) then. In Delphi Prism this can also be written as: if 400 < cost < 600 then.

As I quickly discovered whilst going through the Delphi Prism Wiki: the language changes to Delphi Prism were easier to adapt to and to learn than I had originally imagined. The New language features gained mostly did not affect my coding style too much so any developers who were concerned that Delphi Prism is nothing like Delphi have nothing to worry about. Many of the new features are useful for compatibility with the .NET Framework and will be a natural fit for existing Delphi or .NET Developers

The Easiest way to get started is to look at the free Oxidizer tool provided on the RemObjects Wiki. The tool helps with the conversion of Delphi Win32 projects to Delphi Prism (but I’m uncertain about how it performs on Delphi.NET to Delphi Prism). The Wiki is also an excellent place to get started, particularly the pages on Delphi Win32 vs Delphi Prism which list the major incompatibilities between the two languages. 

Whilst converting my Delphi.NET Library for accessing Twitter, I encountered a few basic hints and tips which I felt I should share here:

• You need to specify the namespace keyword at the top of your unit file instead of the unit keyword. The first time I tried to compile after doing this Prism still complained about not having a namespace keyword present, this was fixed by closing the solution and re-opening.
• Delphi Prism automatically makes classes that are not explicitly marked otherwise as strict private. This meant that I had to go through my library and mark all classes that I wanted to make public. eg. TMyClass = public class(System.Object);
• The overload keyword isn’t neccesary as overloading is now implicit. This isn’t a problem at all and isn’t dificult to fix as it simply meant doing a Search and Replace for the overload keyword and removing it.
• TObject no long exists and instead needs to be replaced with System.Object which has much the same properties. 
• I encountered a few problems with the use of for .. in loops. It would seem that Delphi Prism loop variables are local to the loop and therefore should be declared at the beginning of the loop (see the for wiki page for more info). In reality this meant changing: for strItem in list do to for strItem: string in list do and then removing the strItem: string; declaration in the method var section.
• The TObject.Create([...]); constructor still exists however it is now recommended that you switch to the new Object([..]) keyword for new projects. This may come as a shock to traditional Delphi’ers who have been .Create()‘ing since the dawn of Borland but this is the construction method that sems to fit in with the .NET framework better. There is also a compatibility flag in the Project properties which allows the compiler to work some magic to allow .Create to continue to function.

These are not the only changes that you will probably need to make but I found them to be a good starting point. You should definitely consult the Prism Wiki for help in which I was able to find answers very quickly (no wading boots required!).

Lastly: My project could do with a lot of refactoring in order to take advatages of the unique language features of Prism. This will take considerably more time as it means learning the new language features first!

Delphi Prism was announced finally at the Microsoft PDC where we discovered (or some of us) that Delphi Prism is the new Delphi .NET Development solution which drops the slightly crippled compatibility approach that Delphi used to employ and instead fits within the Visual Studio IDE. Delphi Prism now supports all the latest and greatest .NET technologies including WPF, LINQ and Various Language methods. They’ve achieved this by making use of the extremely cool RemObjects Oxygene Compiler which I would highly recommend that you investigate right away if you’re interested at all in .NET Development! I will be doing a post soon to discuss some of my favourite new Delphi Prism language features!

This rejuvenation of Delphi is causing a product marketing effect and is slowly gathering momentum and I fully intend on doing whatever I can to generate enthusiasm for the Delphi Programming Community. This concept of User-led marketing has been widespread for many years as Apple fans will testify. As part of this I have a new project in mind for the Delphi community and will be explaining this in due course. I will certainly require Delphi enthusiasts to help with this venture, if you’re interested then please contact me.