Design-time T4 text templates are a useful feature of Visual Studio that allow us to do a little meta-programming and generate code (or text) which is then compiled as part of a project. One problem I recently came up against which is nicely solved by T4 is a slight difficulty in using F#’s discriminated unions from C#.

In an F# class library project called Foo, I have the following types defined:

namespace Foo

type Vehicle =
    | LandVehicle of LandVehicle
    | WaterVehicle of WaterVehicle
    | AirVehicle of AirVehicle
    | SpaceVehicle of SpaceVehicle

and LandVehicle =
    | PersonalLandVehicle  of PersonalLandVehicle
    | PublicLandVehicle of PublicLandVehicle

and PersonalLandVehicle =
    | Car
    | Bike

... *snip* ...

module Something =
    let GetVehicle() = 
        Vehicle.LandVehicle(LandVehicle.PersonalLandVehicle(PersonalLandVehicle.Bike))

I also have a C# project called Bar which makes use of the GetVehicle function defined in Foo.

Vehicle vehicle = Foo.Something.GetVehicle();

In order to take an appropriate action depending on whether or not vehicle is any of LandVehicle, WaterVehicle, AirVehicle, SpaceVehicle, it’s necessary to do something like:

if (vehicle.IsAirVehicle)
{
	AirVehicle airVehicle = ((Vehicle.AirVehicle)vehicle).Item;
}
else if (vehicle.IsLandVehicle)
{
	LandVehicle landVehicle = ((Vehicle.LandVehicle)vehicle).Item;
}
else if (vehicle.IsSpaceVehicle)
{
	SpaceVehicle spaceVehicle = ((Vehicle.SpaceVehicle)vehicle).Item;
}
else if (vehicle.IsWaterVehicle)
{
	WaterVehicle waterVehicle = ((Vehicle.WaterVehicle)vehicle).Item;
}

Note the ugly and awkward typecast which quickly becomes cumbersome when you have many of these unions in a structure such as an AST. However, it can be remedied with the use of an extension methods like this:

public static class Extensions
{
	public static AirVehicle AsAirVehicle(this Vehicle vehicle)
	{
		return ((Vehicle.AirVehicle)vehicle).Item;
	}

	public static LandVehicle AsLandVehicle(this Vehicle vehicle)
	{
		return ((Vehicle.LandVehicle)vehicle).Item;
	}
}

It’s then possible to replace the ugly typecasting with a more eloquent expression

AirVehicle airVehicle = vehicle.AsAirVehicle();

Of course, we have to write an extension method for each discriminated union and for each of its cases, so for Vehicle and LandVehicle alone we will need 6 extension methods that are fairly identical.

This is where T4 comes into play. First, let’s add a “Text Template” named “Extensions.tt” to the C# solution. The next thing to do is open it up, and change the line

<#@ output extension=".txt" #>

to read

<#@ output extension=".cs" #>

, which tells T4 to output C# source code. We also need to add the following lines to load the required assemblies:

<#@ assembly name="System.Core" #>
<#@ assembly name="FSharp.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="Microsoft.FSharp.Core" #>

Now add

using Foo;

namespace Bar
{
	public static class Extensions
	{
		<#
		#>
	}
}

Note that any C# code between the <# and #> symbols will be executed when the template is parsed. It's possible to output text from within the code block by calling "WriteLine" (Not Console.WriteLine!). Now for the interesting bit, we need to somehow loop over all of the types defined in Foo and output the C# source for their relevant extension methods. The final T4 template looks like this:

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Core" #>
<#@ assembly name="FSharp.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="Microsoft.FSharp.Core" #>

using Foo;

namespace Bar
{
	public static class Extensions
	{
		<#
			PushIndent("\t");
			PushIndent("\t");

			var asm = System.Reflection.Assembly.LoadFrom(@"Z:\Path\To\Foo.dll");
			foreach (var type in asm.GetTypes().Where(t => t.Namespace == "Foo" && t.IsNested == false))
			{
				foreach(var attr in type.GetCustomAttributes(typeof(CompilationMappingAttribute), true))
				{
					if (((CompilationMappingAttribute)attr).SourceConstructFlags == SourceConstructFlags.SumType)
					{
						foreach (var nested in type.GetNestedTypes().Where(t => t.Name != "Tags" && t.Name != type.Name))
						{
							WriteLine("public static {0} As{1}(this {2} node)", nested.Name, nested.Name, type.Name);
							WriteLine("{");
							PushIndent("\t");

							WriteLine("return (({0}.{1})node).Item;", type.Name, nested.Name);

							PopIndent();
							WriteLine("}");
							WriteLine("");
						}
					}
				}				
			}

			PopIndent();
			PopIndent();
		#>
	}
}

Important: Note the line var asm = System.Reflection.Assembly.LoadFrom(@"Z:\Path\To\Foo.dll");. We need to give an explicit path to the Foo.dll as the T4 engine runs outside of the scope of the project and we therefore could not access the Foo assembly through AppDomain for example.

The final step is to save "Extensions.tt", right click it in the solution explorer and select "Run Custom Tool". A new file, "Extensions.cs" should now be generated with all the required extension methods and looks something like

using Foo;

namespace Bar
{
	public static class Extensions
	{
		public static LandVehicle AsLandVehicle(this Vehicle node)
		{
			return ((Vehicle.LandVehicle)node).Item;
		}

		public static WaterVehicle AsWaterVehicle(this Vehicle node)
		{
			return ((Vehicle.WaterVehicle)node).Item;
		}
		
		... *snip* ...
	}
}

Tweet