jaredpar's WebLog : Tuple

Tuples Part 8: Finishing up

Jared Parsons — Mon, 28 Jan 2008 05:37:18 GMT

There are only a few missing features from our tuple implementation. Mainly FxCop compliance, debugging support and test case code. The actual functional work is complete.

The one issue with FxCop compliance is the chosen names. Namely using A,B etc. FxCop, rightly, believes names should have more value. Accordingly, calling the generic argument corresponding to A, TA also causes the same issue. This is a design decision made from the begining. I don't believe changing the name to ValueA adds any more value than simply A. Therefore the warning for this will simply be suppressed.

Additionally FxCop doesn't like types with more than 3 generic parameters. This is also a design decision intentionally done and there is no avoiding it. It will be suppressed as well.

For debugging support a simple DebuggerDisplay attribute will be used. It will display the current value of all of the tuple values.

Here is the latest version of the full script which includes all of the new information. With the exception of a few small tweaks this is just the combination of the individual parts specified throughout these postings.

param ( [int]$tupleCount = 5,
[string]$namespace = "Tuples" )

$script:scriptPath = split-path -parent $MyInvocation.MyCommand.Definition
$script:lowerList = 0..25 | %{ [char]([int][char]'a'+$_) }
$script:upperList = 0..25 | %{ [char]([int][char]'A'+$_) }
$script:valueList = "1","42",'"bar"', '"foo"', 'true'

function script:Gen-FxCop
{
param ( [int]$code )

    switch ( $code )
    {
        1704 { '[SuppressMessage("Microsoft.Naming", "CA1704")]'; break }
        1005 { '[SuppressMessage("Microsoft.Design", "CA1005")]'; break }
        default: {$(throw "Invalid")}
    }
}

function script:Gen-Display
{
    param ( [int]$count )
    $OFS = ", "
    $p = [string](0..($count-1) | %{ "{0}={{{0}}}" -f $upperList[$_] })
    '[DebuggerDisplay("{0}")]' -f $p
}

function script:Gen-Property
{
param ( [int] $index = $(throw "Need an index"), [bool]$mutable = $false)

    if (-not $mutable )
    {
@"
    private readonly T{0} m_{1};
    $(Gen-FxCop 1704)
    public T{0} {0} {{ get {{ return m_{1}; }} }}

"@ -f $upperList[$index],$lowerList[$index]
    }
    else
    {
@"
    private T{0} m_{1};
    $(Gen-FxCop 1704)
    public T{0} {0} {{ get {{ return m_{1}; }} set {{ m_{1} = value; }} }}

"@ -f $upperList[$index],$lowerList[$index]
}
}

function script:Gen-Constructor
{
    param ( [int] $count = $(throw "Need a count"), [string]$className )
    $OFS = ','
    $list = [string](0..$($count-1) | %{ "T{0} value{0}" -f $upperList[$_]})
    "public $className($list) {"
    0..($count-1) | %{ "m_{0} = value{1};" -f $lowerList[$_],$upperList[$_] }
    "}"
}

function script:Gen-InferenceConstructor
{
    param ( [int] $count = $(throw "Need a count"), [string]$name )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"
    $list = [string](0..$($count-1) | %{ "T{0} value{0}" -f $upperList[$_] })
    $argList = [string](0..$($count-1) | %{ "value{0}" -f $upperList[$_] })
    "public static partial class $name {"
    Gen-FxCop 1704
    "public static $name$gen Create$gen($list) { return new $name$gen($argList); } "
    "}"
}

function script:Gen-Equals
{
    param ( [int] $count = $(throw "Need a count"), [string]$name )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"
    "public override bool Equals(object obj) { "
    "return Equals(obj as $name$gen); }"
    "public bool Equals($name$gen other) {"
    "if ( Object.ReferenceEquals(other,null) ) { return false; }"
    "if ("
    $OFS = "&&"
    [string](0..($count-1) | %{"EqualityComparer<T{0}>.Default.Equals(m_{1},other.m_{1})" -f $upperList[$_],$lowerList[$_] })
    ") { return true; }"
    "return false;"
    "}"
}

function script:Gen-GetHashCode
{
    param ( [int] $count = $(throw "Need a count") )
    "public override int GetHashCode() {"
    "int code = 0;"
    0..($count-1) | %{ "code += EqualityComparer<T{0}>.Default.GetHashCode(m_{1});" -f $upperList[$_],$lowerList[$_] }
    "return code;"
    "}"
}

function script:Gen-ITuple
{
    param ( [int] $count = $(throw "Need a count") )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"
    $base = ""
    if ( $count -ne 1 )
    {
        $baseGen = "<" + [string](0..($count-2) | %{ "T"+$upperList[$_] }) + ">"
        $base = ": ITuple$baseGen"
    }
    else
    {
        $base = ": ITuple"
    }
    Gen-FxCop 1704
    if ( $count -gt 2 ) { Gen-FxCop 1005 }
    "public interface ITuple$gen $base {"
    Gen-FxCop 1704
    "T{0} {0} {{ get; }}" -f $upperList[$count-1]
    "}"
}

function script:Gen-TupleAccess
{
    param ( [int] $count = $(throw "Need a count"), [bool]$mutable )
    "public int Count { get { return $count; } }"
    "public object this[int index] { get { switch (index){ "
    0..($count-1) | %{ "case $($_): return m_$($lowerList[$_]);" }
    "default: throw new InvalidOperationException(""Bad Index"");"
    "} }"

    if ( $mutable )
    {
        "set { switch (index) {"
        0..($count-1) | %{ "case $($_): m_$($lowerList[$_]) = (T$($upperList[$_]))value; break;" }
        "default: throw new InvalidOperationException(""Bad Index"");"
        "} } "
    }
    "}"
}

function script:Gen-OpEquals
{
    param ( [int] $count = $(throw "Need a count"), [string]$name )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"
    "public static bool operator==($name$gen left, $name$gen right) {"
    "return EqualityComparer<$name$gen>.Default.Equals(left,right); }"
    "public static bool operator!=($name$gen left, $name$gen right) {"
    "return !EqualityComparer<$name$gen>.Default.Equals(left,right); }"
}

function script:Gen-CompareTo
{
    param ( [int] $count = $(throw "Need a count"), [string]$name )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"
    "public int CompareTo(object obj) {"
    "return CompareTo(obj as $name$gen); }"
    "public int CompareTo($name$gen other) {"
    "if ( Object.ReferenceEquals(other,null) ) { return 1; }"
    "int code;"
    0..($count-1) |
        %{ "code = Comparer<T{0}>.Default.Compare(m_{1},other.m_{1}); if (code != 0) {{ return code; }}" -f $upperList[$_],$lowerList[$_] }
    "return 0; }"
    "public static bool operator>($name$gen left, $name$gen right) { "
    "return Comparer<$name$gen>.Default.Compare(left,right) > 0; }"
    "public static bool operator<($name$gen left, $name$gen right) { "
    "return Comparer<$name$gen>.Default.Compare(left,right) < 0; }"
}

function script:Get-Tuple
{
    param ( [int] $count, [bool]$mutable = $false )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"
    Gen-FxCop 1704
    Gen-Display $count
    if ( $count -gt 2 ) { Gen-FxCop 1005 }
    $name = "{0}Tuple" -f (Get-Ternary $mutable "Mutable" "")
    "public sealed class $name$gen : ITuple$gen,IEquatable<$name$gen>, IComparable<$name$gen>,IComparable {"
    (0..($count-1) | %{ Gen-Property $_ $mutable})
    Gen-Constructor $count $name
    Gen-TupleAccess $count $mutable
    Gen-Equals $count $name
    Gen-GetHashCode $count
    Gen-OpEquals $count $name
    Gen-CompareTo $count $name
    "}"
    Gen-InferenceConstructor $count $name
}

function Gen-TestTuple([int]$count, [string]$prefix)
{
    $OFS = ","
    $v = [string](0..($count-1) | %{ $valueList[$_]} )
    "[TestMethod]"
    "public void {0}Access{1}() {{" -f $prefix,$count
    "var t = $prefix.Create($v);"
    for ( $i = 0; $i -lt $count; ++$i )
    {
        "Assert.AreEqual({0},t.{1});" -f $valueList[$i],$upperList[$i];
    }
    "}"

    "[TestMethod]"
    "public void {0}GenericAccess{1}() {{" -f $prefix,$count
    "var t = $prefix.Create($v);"
    for ( $i = 0; $i -lt $count; ++$i )
    {
        ("Assert.AreEqual({0},t[{1}]);" -f $valueList[$i],$i);
    }
    "Assert.AreEqual({0},t.Count);" -f $i
    "}"

    "[TestMethod]"
    "public void {0}Equals{1}() {{" -f $prefix,$count
    "var t1 = $prefix.Create($v);"
    "var t2 = $prefix.Create($v);"
    "Assert.IsTrue(t1.Equals(t2));"
    "}"

    "[TestMethod]"
    "public void {0}NotEquals{1}() {{" -f $prefix,$count
    for ( $i = 0; $i -lt $count; ++$i )
    {
        $leftName = "t{0}_1" -f $i
        $rightName = "t{0}_2" -f $i
        $left = "var $leftName = $prefix.Create(" -f $i
        $right = "var $rightName = $prefix.Create(" -f $i
        for ( $v = 0; $v -lt $count; ++$v )
        {
            $left += "$v"
            if ( $v -eq $i )
            {
                $right += "-1"
            }
            else
            {
                $right += "$v"
            }

            if ( ($v + 1) -lt $count )
            {
                $left += ","
                $right += ","
            }
        }
        "$left);"
        "$right);"
        "Assert.AreEqual($leftName.GetType(), $rightName.GetType());"
        "Assert.IsFalse($leftName.Equals($rightName));"
    }
    "}"

    "[TestMethod]"
    "public void {0}CompareTest() {{ " -f $prefix
    "Assert.IsTrue($prefix.Create(1) < $prefix.Create(2));"
    "Assert.IsTrue($prefix.Create(2) > $prefix.Create(1));"
    "}"
}

$output =
@"
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;

namespace $namespace {
public interface ITuple {
int Count { get; }
object this[int index] { get; }
}
"@
$OFS = [Environment]::NewLine
$output += [string](0..($tupleCount-1) | %{ Gen-ITuple ($_+1) })
$output += [string](0..($tupleCount-1) | %{ Get-Tuple ($_+1) })
$output += [string](0..($tupleCount-1) | %{ Get-Tuple ($_+1) $true })
$output += "}"

$output > (join-path $scriptPath "Core\Tuple.cs")

$output =
@"
using System;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using $namespace;

namespace $($nameSpace)Test {

[TestClass]
public class TupleTest{
"@
$output += Gen-TestTuple $tupleCount "Tuple"
$output += Gen-TestTuple $tupleCount "MutableTuple"
$output += "}}"
$output > (join-path $scriptPath "TestCore\TupleTest.cs")

Tuples Part 7: Mutable Tuples

Jared Parsons — Wed, 23 Jan 2008 10:56:19 GMT

Part 6 left us with comparable tuples. At this point, the Tuple class is functionally complete. There will be a little more done with the debugability and overall fit into larger projects. But otherwise it is sound.

Now the focus shifts to generating mutable tuples. Immutability is nice for threading, memoization, etc ... However it's not always practical to use immutable objects. Often an algorithm does not benefit from immutability and lends itself to a more mutable type.

Mutable tuples behave like a Tuple in every other way except that they're ... mutable. This includes implementing interfaces as well as inheritance structure.

public sealed class MutableTuple<TA, TB> : 
    ITuple<TA, TB>, 
    IEquatable<MutableTuple<TA, TB>>, 
    IComparable<MutableTuple<TA, TB>>, 
    IComparable
{

As such the script already used will be sufficient to generate mutable classes in addition to the ones its already doing. The majority of the code difference is just in the naming of the classes. The only functional differences exist in the properties and indexer. Both of these add a setter method. Below is the modified code for generating the property and indexer.

function script:Gen-Property
{
param ( [int] $index = $(throw "Need an index"), [bool]$mutable = $false)

    if (-not $mutable )
    {
@"
    private readonly T{0} m_{1};
    public T{0} {0} {{ get {{ return m_{1}; }} }}

"@ -f $upperList[$index],$lowerList[$index]
    }
    else
    {
@"
    private T{0} m_{1};
    public T{0} {0} {{ get {{ return m_{1}; }} set {{ m_{1} = value; }} }}

"@ -f $upperList[$index],$lowerList[$index]
}
}

Now creating a mutable tuple is the same as the immutable tuple with just a name tweak.

            var t1 = MutableTuple.Create("foo", 42);
            t1.A = "again";

Tuples Part 6: Comparing

Jared Parsons — Tue, 22 Jan 2008 09:56:00 GMT

Part 5 produced equality tests for Tuples. This section will add comparison support through the IComparable<T> interface. Implementing comparable is very similar to adding equality support. Once again there is a generic class available to make all of the comparison decisions for us; Comparer<T>.

The implementation will compare objects in a left to right fashion. In this case the property corresponding to TA will be the left most, and TN the right most. If all properties are equal (Compare returns 0) then the two items will be determined to be equal and will return 0.

function script:Gen-CompareTo
{
    param ( [int] $count = $(throw "Need a count") )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"
    "public int CompareTo(object other) {"
    "return CompareTo(other as Tuple$gen); }"
    "public int CompareTo(Tuple$gen other) {"
    "if ( Object.ReferenceEquals(other,null) ) { return 1; }"
    "int code;"
    0..($count-1) |
        %{ "code = Comparer<T{0}>.Default.Compare(m_{1},other.m_{1}); if (code != 0) {{ return code; }}" -f $upperList[$_],$lowerList[$_] }
    "return 0; }"
}

Once again the same questions arise about implementing IComparable<Tuple> vs IComparable<ITuple> (or both). The arguments are fairly similar and as a result I decided to skip implementing the ITuple version for now.

Tuples Part 5: Equality

Jared Parsons — Tue, 22 Jan 2008 09:31:18 GMT

Part 4 left us with a reusable, abstract and inference friendly Tuple class. The next step is to be able to test for Tuple equality.

For the Tuple implementation, two tuples will be defined as equal if all of their members are equal. Seems fairly straight forward. The trick is in the implementation. In addition to doing the typical override of Equals/GetHashCode the Tuple implementation will be implementing IEquatable<T> and overloading the standard equality operators.

Tuple members are all unconstrained generic classes which leaves us with a non-great starting point.

For instance what if we are dealing with value types? Is Equals() the best method to call? What if the type in question implements IEquatable<T> or has a well known IEqualityComparer<T>? What if one or both of the arguments are reference types and null? What if they're value types and equal to null?

Luckily there is an easy and straight forward solution. The BCL defines a class, EqualityComparer<T>, which will properly perform equality comparisons for objects of a particular type. This makes the Equals override very straight forward.

There is one small trick to implementing Equals correctly. The implementation explicitly uses Object.ReferenceEquals to check for null rather than ==. The reason being is once operator== is defined for the type Tuple, comparison for even null will bind to this operator. Part of checking for operator== will end up calling Equals and hence you can end in a stack overflow fairly quick. Note that our implementation of == will work around this but it's still safer to be explicit.

function script:Gen-Equals
{
    param ( [int] $count = $(throw "Need a count") )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"
    "public override bool Equals(object obj) { "
    "return Equals(obj as Tuple$gen); }"
    "public bool Equals(Tuple$gen other) {"
    "if ( Object.ReferenceEquals(other,null) ) { return false; }"
    "if ("
    $OFS = "&&"
    [string](0..($count-1) | %{"EqualityComparer<T{0}>.Default.Equals(m_{1},other.m_{1})" -f $upperList[$_],$lowerList[$_] })
    ") { return true; }"
    "return false;"
    "}"
}

GetHashCode can also utilize EqualityComparer<T>.

Both of the operators are likewise straight forward. As before mentioned EqualityComparer<T> will properly check for null and then perform an Equals call so it can be used as the standard operator code.

function script:Gen-OpEquals
{
    param ( [int] $count = $(throw "Need a count") )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"
    "public static bool operator==(Tuple$gen left, Tuple$gen right) {"
    "return EqualityComparer<Tuple$gen>.Default.Equals(left,right); }"
    "public static bool operator!=(Tuple$gen left, Tuple$gen right) {"
    "return !EqualityComparer<Tuple$gen>.Default.Equals(left,right); }"
}

In addition to the methods, the Tuple class generation must be changed to implement IEquatable<Tuple<>>.

Some will notice that the implementation forces the equality comparison to be against a Tuple<T> vs an ITuple<T>. There are a couple of reasons for this.

I have come up against specific scenarios where I wanted to compare Tuple<T> but not ITuple<T>. This is not saying they don't exist (they do). But I prefer to leave an implementation until I find a justification for implementing it.
By constraining to IEquatable<Tuple<T>> we are always comparing apples to apples. If you try and perform an Equals against ITuple<TA> you're leaving yourself open to comparing apples and oranges. Since ITuple<TA,TB> implements ITuple<TA> it is a valid target for the overload. This type of equality seems scenario dependent and as such I left it out for the time. Note with our current implementation it would be very easy to come back and add this later.
To make #2 even stranger, once MutableTuples are implemented an implemantation of IEquatable<ITuple<TA>> might actually be comparing Tuple<TA,TB,TC> to MutableTuple<TA>.

Tuples Part 4: Interface

Jared Parsons — Thu, 10 Jan 2008 23:59:49 GMT

Now we have a decent tuple generation script which produces a very usable set of tuple classes. After awhile I ended up getting stuck because the tuples are not flexible enough. It's not possible to use a 2 pair tuple where a 1 pair is expected even though it meets the requirements.

            Process(Tuple.Create("foo"));
            Process(Tuple.Create("foo", 42));

        public static void Process<TA>(ITuple<TA> tuple)
        {
            
        }

I considered two approaches to this problem; inheritance and interface. I debated the inheritance one for awhile. I couldn't convince myself one way or another if a Tuple<int,int> was a Tuple<int> or merely behaved like one. Also once we introduce a MutableTuple class inheritance won't fix the problem (unless you introduce nasty shadowing variables). Instead I opted for an interface based approach.

In addition to defining the basic interface I added two methods to the base most interface. These methods allow methods to operate on tuples in generic ways regardless of the pair count.

    int Count { get; }
    object this[int index] { get; }

Generating the implementation is straight forward at this point considering the past solutions. You'll also have to alter the class definition to inherit from the appropriate ITuple interface.

Hopefully by now it's becoming clear why having a script to regenerate the large code base is a good idea. It's easy to make sweeping changes to your implementation.

function script:Gen-ITuple
{
    param ( [int] $count = $(throw "Need a count") )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"
    $base = ""
    if ( $count -ne 1 )
    {
        $baseGen = "<" + [string](0..($count-2) | %{ "T"+$upperList[$_] }) + ">"
        $base = ": ITuple$baseGen"
    }
    else
    {
        $base = ": ITuple"
    }
    "public interface ITuple$gen $base {"
    "T{0} {0} {{ get; }}" -f $upperList[$count-1]
    "}"
}

function script:Gen-TupleAccess
{
    param ( [int] $count = $(throw "Need a count") )
    "public int Count { get { return $count; } }"
    "public object this[int index] { get { switch (index){ "
    0..($count-1) | %{ "case $($_): return m_$($lowerList[$_]);" }
    "default: throw new InvalidOperationException(""Bad Index"");"
    "} } }"
}

Tuples Part 3: Type Inference Friendly Constructor

Jared Parsons — Mon, 07 Jan 2008 19:38:11 GMT

Last time we were left with a constructor that required us to explicitly specify generic parameters. This is not always easy or possible. We'll now alter the script to generate a constructor which utilizes type inference to create a Tuple. In addition, all tuples will use the same overloaded method making the creation uniform.

The best way to use type inference to create a generic argument is through static methods. In C# and VB it's legal to define a non-generic class with the same name as a generic class. I tend to create a non-generic class with a static Create method that takes advantage of type inference. For tuples the method will look like the following.

public partial class Tuple
{
    public static Tuple<TA> Create<TA>(TA a)
    { 
        return new Tuple<TA>(a); 
    }
}

This allows us to write the following code.

            var tuple = Tuple.Create("foo");

Partial classes are used because we will be generating one per Tuple class that we create. It's just easier to script it this way.

The method is very straight forward. We need one new additional string for the arguments to the constructor. It's created along the same line as the previous strings.

function script:Gen-InferenceConstructor
{
    param ( [int] $count = $(throw "Need a count") )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"
    $list = [string](0..$($count-1) | %{ "T{0} {1}" -f $upperList[$_],$lowerList[$_] })
    $argList = [string](0..$($count-1) | %{ $lowerList[$_] })
    "public partial class Tuple {"
    "public static Tuple$gen Create$gen($list) { return new Tuple$gen($argList); } "
    "}"
}

Now just add a call to this function in Get-Tuple and the code is now inference friendly.

Next up is defining an interface for tuples that will allow us to treat a Tuple<2> as a Tuple<1>. Both have an "A" property and should be able to be used in a generic way.

Tuples Part 2: Basic Structure

Jared Parsons — Fri, 04 Jan 2008 23:42:56 GMT

Part 1 of the series outlined the basic structure of the tuple. This entry will produce a PowerShell script that will generate N tuple classes containing 1-N name value pairs.

The first step is to get a few script variables defined. All of the names used in the tuples will be lower and upper case single characters tied to a specific index. To make the script a bit shorter we will define indexable arrays up front for the letters. We'll also grad the tuple count.

$script:tupleCount = [int]$args[0]
$script:lowerList = 0..25 | %{ [char]([int][char]'a'+$_) }
$script:upperList = 0..25 | %{ [char]([int][char]'A'+$_) }

All of the functions in this script will output an array of strings into the PowerShell pipeline. One of the neat/confusing features of PowerShell is that values that are not directly used in a function are passed onto the pipeline. This will conveniently allow us to type in literal code and hopefully increase readability.

Now for the function that generates a property. The tuples will be immutable by default as such we will generate private read only fields and simple getters.

It would also be just as plausible to skip the property here and instead produce a read only public field. Later on we will be altering the tuples to be used in a generic fashion through interfaces. Interfaces cannot define fields and instead we will need properties.

function script:Gen-Property
{
    param ( [int] $index = $(throw "Need an index") )
@"
    private readonly T{0} m_{1};
    public T{0} {0} {{ get {{ return m_{1}; }} }}

"@ -f $upperList[$index],$lowerList[$index]
}

Next up we need to define a constructor. All of the fields in the tuple are read only so we must define a constructor for the consumer (otherwise the tuples would be useless).

Generating the parameter list string would be tedious in most languages but PowerShell makes it a snap. When converting an array of strings into a single string the individual strings will be combined with the value of the *** $OFS variable (default is space). We can switch this to a comma and provide a quick pipeline for the parameter list.

function script:Gen-Constructor
{
    param ( [int] $count = $(throw "Need a count") )
    $OFS = ','
    $list = [string](0..$($count-1) | %{ "T{0} {1}" -f $upperList[$_],$lowerList[$_] })
    "public Tuple($list) {"
    0..($count-1) | %{ "m_{0} = {0};" -f $lowerList[$_] }
    "}"
}

Now that we have the basics we can generate the class. We'll use the same $OFS trick to generate the generic argument list here.

function script:Get-Tuple
{
    param ( [int] $count )
    $OFS = ','
    $gen = "<" + [string](0..($count-1) | %{ "T"+$upperList[$_] }) + ">"

    "public sealed class Tuple$gen {"
    0..($count-1) | %{ Gen-Property $_ }
    Gen-Constructor $count
    "}"
}

Now all that's left is processing the arguments

[string](0..($tupleCount-1) | %{ Get-Tuple ($_+1) })

Next step is to generate code that is more type inference friendly.

Tuples Part 1

Jared Parsons — Thu, 03 Jan 2008 19:25:51 GMT

A tuple in computer science can be described as a set of name/value pairs. In some cases it can be described as simply a set of values that are accessible via an index [1]. Previously I discussed how to create a Tuple inside of PowerShell. This series will focus on the use of Tuples in DotNet and how to use PowerShell to generate DotNet code.

This series will also distinguish between mutable and immutable tuples. As DotNet is shifting it's focus on parallel programming, immutable types are becoming more important. Therefore this serious will focus on Tuples as immutable types and later examine mutable tuples.

In Visual Studio 2005, both C# and VB acquired tuples as a part of the programming language in the form of Anonymous Types. These fit all of the properties of a tuple. The one difference is in VB, anonymous types are mutable by default. This can be changed though by using the Key keyword.

However anonymous types are lacking one quality which severely lessens their usefulness. Their type cannot be described. This prevents them from being used as parameters, fields, generic parameters [2] etc ... Unless you use late binding or terribly awkward casts this is limiting.

To get around this, we will be defining a set of generic tuple class supporting 1-N name value pairs. The great downside is because we will be predefining these types the names in the name value pair will be fixed. We will be using A-N for 1-N pairs.

This is very limiting in itself because it's reducing the expressiveness of a type. Anonymous types are much more expressive since they have names. Now types will have properties A,B, etc ...

For me this still works. In my code, I only end up using tuples when I need to pass data around between tightly coupled classes, or just within the same class. Since the creation and use are so close loosing the full expressiveness of the name is not that limiting.

In addition, our tuple implementation will leverage type inference as much as possible such that the following code can be written.

            var tuple = Tuple.Create("foo");
            Console.WriteLine(tuple.A);

Why write a script to generate these classes? Wouldn't it just be easier to just do this by hand??? Yes and no. If you are doing a fixed set of short used classes then yes, do it by hand. These scripts evolved out of my use of tuples. Once I would settle on a structure and I would think of a new feature I needed. Typically I have tuples defined up to 5 fields. Retyping out a new feature got tiresome and error prone. With a scripting solution I could add a new feature and tests in just a few minutes. The series is very representative of the way my solution changed over time. Simple at first but I added features as the situation dictated. Having a scripting solution saved me a lot of time.

Next up, generating the basic structure.

[1] In this case, the index just becomes the name and hence a name/value pair.