So in part one of my posting I covered the real basics of object creation. Today I will hopefully dig a little deeper…

My expert F# book brings up an interesting point – properties in F# are just syntactic sugar for method calls. This makes sense… for instance assume I had the following object with the property exposed called Firstname.

type Person(Firstname : string, Lastname : string) =     
    member v.Firstname = Firstname

I could extend the Firstname property with the following code and everything would be hunky dory…

type Person(Firstname : string, Lastname : string) =     
    member v.Firstname = 
        Console.WriteLine("Side Effect")
        Firstname

All that this would do is each time I use the property Firstname, I would see the side effect printed to the screen saying “Side Effect”.

Member methods have a very similar look & feel to properties, in fact the only difference really is that you declare that parameters are being passed in.

type Person(Firstname : string, Lastname : string) =     
    member v.FullName(middleName) = Firstname + " " + middleName +  " " + Lastname

In the code above, FullName requires the parameter middleName, and if viewed from another project in C# would show as a method and not a property.

Precomputation Optimizations

Okay, so something that is obvious once you think of it but that poses an interesting side effect of mutable value holders is pre-computation of results.

All it is, is a slight difference in code but can result in quite a huge saving in performance. Basically pre-computation means you would not need to compute a value every time a method is called – but could perform the computation at the creation of the object (I hope I have got it right). In a way I battle to differentiate this from lazy evaluation but I will show an example to explain the principle.

Let me try and show an example to illustrate the principle… assume the following F# module

namespace myNamespace
open System

module myMod =
    let Add val1 val2 =
        Console.WriteLine("Compute")
        val1 + val2

    type MathPrecompute(val1 : int, val2 : int) =     
        let precomputedsum = Add val1 val2
        member v.Sum =         
            precomputedsum
    

    type MathNormalCompute(val1 : int, val2 : int) =         
        member v.Sum = Add val1 val2

Now assume you have a C# console app that makes use of the objects with code similar to the following…

using System;
using myNamespace;

namespace CSharpTest
{
    class Program
    {
        static void Main(string[] args)
        {

            Console.WriteLine("Constructing Objects");
            var myObj1 = new myMod.MathNormalCompute(10, 11);
            var myObj2 = new myMod.MathPrecompute(10, 11);
            Console.WriteLine("");

            Console.WriteLine("Normal Compute Sum...");
            Console.WriteLine(myObj1.Sum);
            Console.WriteLine(myObj1.Sum);
            Console.WriteLine(myObj1.Sum);
            Console.WriteLine("");
            
            Console.WriteLine("Pre Compute Sum...");
            Console.WriteLine(myObj2.Sum);
            Console.WriteLine(myObj2.Sum);
            Console.WriteLine(myObj2.Sum);
            
            Console.ReadKey();
            
        }
    }
}

The output when running the console application would be as follows….

You will notice with the normal compute object that the system would call the Add function every time the method was called. With the Precompute object it only called the compute method when the object was created. Subtle, but something that could lead to major performance benefits.

So… this post has gone off in a slight tangent but still related to F# objects.