Functional Programming

Since around Christmas, I’ve been slowly falling in love with F#. The more I look at it, read about it and try it, the more I appreciate functional programming in general, and particularly F#.

One of the joys is that the list is so core to the entire experience. As I’ve learnt more as a programmer, I’ve realised that so much of what we do is working with lists, and although C# is getting better with things like LINQ, it’s still so far behind.

F# also has the advantage that it’s a .NET language and is not only fully functional, but also fully object oriented. It’s a superset of C#, so you get the joys of C#, along with being able to program functionally.

A few quick examples to demonstrate some F#:

let square x = x * x

let sumOfSquares n =
    [1..n] |> List.map square |> List.sum
let sumOfOddSquares n = 
    [1..2..n] |> List.map square |> List.sum

printfn "Sum of Squares 1..100: %i" (sumOfSquares 100)
printfn "Sum of odd Squares 1..100: %i" (sumOfOddSquares 100)

The equivalent C# code:

public class Program
{
    public static int Square(int x)
    {
        return x*x;
    }

    public static int SumOfSquares(int n)
    {
        int sum = 0;
        for (int i = 0; i < n; ++i)
        {
            sum += Square(i);
        }

        return sum;
    }

    public static int SumOfOddSquares(int n)
    {
        int sum = 0;
        for (int i = 1; i < n; i+=2)
        {
            sum += Square(i);
        }

        return sum;
    }

    static void Main(string[] args)
    {
        Console.WriteLine("Sum of Squares 1..100: {0}", SumOfSquares(100));
        Console.WriteLine("Sum of odd Squares 1..100: {0}", SumOfOddSquares(100));
    }
}

And the C# code using modern techniques like LINQ:

public class Program
{
    public static int Square(int x)
    {
        return x*x;
    }

    public static int SumOfSquares(int n)
    {
        return Enumerable.Range(1, n)
                         .Select(i => Square(i))
                         .Sum();
    }

    public static int SumOfOddSquares(int n)
    {
        return Enumerable.Range(1, n)
                         .Where(i => i % 2 != 0)
                         .Select(i => Square(i))
                         .Sum();
    }

    static void Main(string[] args)
    {
        Console.WriteLine("Sum of Squares 1..100: {0}", SumOfSquares(100));
        Console.WriteLine("Sum of odd Squares 1..100: {0}", SumOfOddSquares(100));
    }
}

The LINQ code is clearly nicer than the old style C# code, but F# is just so much more concise and easier to understand. The benefits of easier comprehension along with the benefits of first-class lists are just fantastic.

Learning about F# is the most I’ve been interested in programming since discovering mobile development so many years ago. It should be very exciting to carry on with F# and see what the future brings.