Tuples and Anonymous Types

Option Strict On

Public Class Book
    Public Property Title As String = ""
    Public Property Year As Integer
End Class

Module Program
    Sub Main()
        ' 1. Positional tuple: the elements are called Item1, Item2.
        Dim pair = (1, "Dune")
        Console.WriteLine(pair.Item1 & " " & pair.Item2)

        ' 2. Names given in the literal.
        Dim named = (Id:=2, Title:="Emma")
        Console.WriteLine(named.Id & " " & named.Title)

        ' 3. Names given in the declared type; the literal can be positional.
        Dim typed As (Id As Integer, Title As String) = (3, "Ulysses")
        Console.WriteLine(typed.Id & " " & typed.Title)

        ' 4. Names inferred from variables and from member accesses (Visual Basic 15.3).
        Dim id = 4
        Dim title = "Ivanhoe"
        Dim book As New Book() With {.Title = "Persuasion", .Year = 1817}
        Dim fromVariables = (id, title)
        Dim fromMembers = (book.Title, book.Year)
        Console.WriteLine(fromVariables.id & " " & fromVariables.title)
        Console.WriteLine(fromMembers.Title & " " & fromMembers.Year)

        ' The positional names always work, whatever the declared names are.
        Console.WriteLine(typed.Item2 & " " & fromMembers.Item2)

        ' A tuple is a ValueTuple, whose ToString lists the values.
        Console.WriteLine(named.ToString())
        Console.WriteLine(typed.GetType().Name & " is a value type: " & typed.GetType().IsValueType)
        Console.WriteLine(fromMembers)

        ' Elements are read-write fields.
        typed.Title = "Ulysses (1922)"
        Console.WriteLine(typed.Title)

        ' A nested tuple, and an array of tuples.
        Dim nested = (Outer:=1, Inner:=(P:=2, Q:=3))
        Console.WriteLine(nested.Inner.Q & " " & nested.Item2.Item1)
        Dim rows = {(1, "a"), (2, "b")}
        Console.WriteLine(rows.GetType().Name & " " & rows(1).Item2)
    End Sub
End Module

1 Dune
2 Emma
3 Ulysses
4 Ivanhoe
Persuasion 1817
Ulysses 1817
(2, Emma)
ValueTuple`2 is a value type: True
(Persuasion, 1817)
Ulysses (1922)
3 2
ValueTuple`2[] b

Option Strict On

Imports System.Globalization

Public Class Book
    Public ReadOnly Property Title As String
    Public ReadOnly Property Year As Integer

    Public Sub New(title As String, year As Integer)
        Me.Title = title
        Me.Year = year
    End Sub
End Class

Module Program
    ' A named tuple as the return type.
    Function Summarize(books As IEnumerable(Of Book)) As (Count As Integer, Oldest As Integer, Newest As Integer)
        Dim years = books.Select(Function(b) b.Year).ToList()
        Return (years.Count, years.Min(), years.Max())
    End Function

    ' The Try pattern with a tuple instead of a ByRef parameter.
    Function ParseYear(text As String) As (Ok As Boolean, Year As Integer)
        Dim value As Integer
        Dim ok = Integer.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, value)
        Return (ok, value)
    End Function

    ' A tuple-returning iterator.
    Iterator Function Numbered(books As IEnumerable(Of Book)) As IEnumerable(Of (Position As Integer, Title As String))
        Dim position = 0
        For Each b In books
            position += 1
            Yield (position, b.Title)
        Next
    End Function

    Sub Main()
        Dim books = {New Book("Dune", 1965), New Book("Emma", 1815), New Book("Ulysses", 1922)}

        Dim s = Summarize(books)
        Console.WriteLine($"{s.Count} books from {s.Oldest} to {s.Newest}")

        For Each entry In {"1922", "nineteen"}
            Dim r = ParseYear(entry)
            Console.WriteLine($"{entry}: ok={r.Ok}, year={r.Year}")
        Next

        For Each n In Numbered(books)
            Console.WriteLine($"{n.Position}. {n.Title}")
        Next

        ' A lambda can return a tuple too; the element names come from the literal.
        Dim lengthOf = Function(b As Book) (b.Title, Length:=b.Title.Length)
        Console.WriteLine(lengthOf(books(2)))
        Console.WriteLine(lengthOf(books(2)).Length)
    End Sub
End Module

3 books from 1815 to 1965
1922: ok=True, year=1922
nineteen: ok=False, year=0
1. Dune
2. Emma
3. Ulysses
(Ulysses, 7)
7

Option Strict On

Module Program
    Sub Main()
        Dim book = (Id:=1, Title:="Dune")
        Dim (id, title) = book
        Console.WriteLine(id & title)
    End Sub
End Module

Program.vb(6,13): error BC30203: Identifier expected.

Option Strict On

Module Program
    Sub Main()
        Dim book = (Id:=1, Title:="Dune")
        Dim id As Integer
        Dim title As String
        (id, title) = book
        Console.WriteLine(id & title)
    End Sub
End Module

Program.vb(8,9): error BC30035: Syntax error.

Option Strict On

Module Program
    Sub Main()
        Dim book = (Id:=1, Title:="Dune")

        ' No deconstruction syntax: read the elements one by one.
        Dim id = book.Id
        Dim title = book.Title
        Console.WriteLine(id & " " & title)

        ' A With block avoids repeating the variable name.
        With book
            Console.WriteLine(.Id & " " & .Title)
        End With

        ' Library Deconstruct methods are ordinary methods in Visual Basic: call them yourself.
        Dim pair As New KeyValuePair(Of String, Integer)("Dune", 1965)
        Dim key As String = ""
        Dim value As Integer
        pair.Deconstruct(key, value)
        Console.WriteLine(key & " " & value)

        ' Iterating a dictionary gives KeyValuePair objects, not tuples.
        Dim years As New Dictionary(Of String, Integer) From {{"Dune", 1965}, {"Emma", 1815}}
        For Each entry In years
            Console.WriteLine(entry.Key & " " & entry.Value)
        Next

        ' Converting to tuples is a projection.
        For Each t In years.Select(Function(e) (Title:=e.Key, Year:=e.Value))
            Console.WriteLine(t.Title & " " & t.Year)
        Next
    End Sub
End Module

1 Dune
1 Dune
Dune 1965
Dune 1965
Emma 1815
Dune 1965
Emma 1815

Option Strict On

Module Program
    Sub Main()
        Dim a = (1, "Dune")
        Dim b = (1, "Dune")
        Console.WriteLine(a = b)
        Console.WriteLine(a <> b)
    End Sub
End Module

Program.vb(7,27): error BC30452: Operator '=' is not defined for types '(Integer, String)' and '(Integer, String)'.
Program.vb(8,27): error BC30452: Operator '<>' is not defined for types '(Integer, String)' and '(Integer, String)'.

Option Strict On

Module Program
    Sub Main()
        Dim a = (Id:=1, Title:="Dune")
        Dim b = (Id:=1, Title:="Dune")
        Dim c = (Id:=1, Title:="Emma")

        ' Equals compares element by element with each element's own Equals.
        Console.WriteLine(a.Equals(b) & " " & a.Equals(c))
        Console.WriteLine(a.GetHashCode() = b.GetHashCode())

        ' The names play no part: only position and types count.
        Dim other = (Key:=1, Name:="Dune")
        Console.WriteLine(a.Equals(other))

        ' The spelled-out comparison that the = operator would have been.
        Console.WriteLine((a.Id = c.Id) AndAlso (a.Title = c.Title))

        ' Equals(Object) needs identical element types: Integer is not Long.
        Console.WriteLine(a.Equals((CLng(1), "Dune")))

        ' IComparable: elements are compared left to right.
        Dim ordered = {(2, "Emma"), (1, "Ulysses"), (1, "Dune")}.OrderBy(Function(t) t).ToList()
        Console.WriteLine(String.Join(", ", ordered))
        Console.WriteLine(a.CompareTo(c))

        ' Tuples work as dictionary and HashSet keys.
        Dim copies As New Dictionary(Of (Isbn As String, Branch As String), Integer)
        copies((Isbn:="9780441172719", Branch:="North")) = 3
        copies((Isbn:="9780441172719", Branch:="South")) = 1
        Console.WriteLine(copies((Isbn:="9780441172719", Branch:="North")))
        Console.WriteLine(copies.ContainsKey(("9780441172719", "East")))

        Dim seen As New HashSet(Of (Integer, Integer)) From {(1, 2)}
        Console.WriteLine(seen.Contains((1, 2)) & " " & seen.Contains((2, 1)))
    End Sub
End Module

True False
True
True
False
False
(1, Dune), (1, Ulysses), (2, Emma)
-1
3
False
True False

Option Strict On

Module Program
    Sub Rename(ByRef pair As (Id As Integer, Title As String))
        pair.Title = pair.Title.ToUpperInvariant()
    End Sub

    Sub Main()
        Dim original = (Id:=1, Title:="Dune")
        Dim copy = original
        copy.Title = "Emma"
        Console.WriteLine(original.Title & " " & copy.Title)

        ' ByRef changes the caller's tuple, ByVal does not.
        Rename(original)
        Console.WriteLine(original.Title)

        ' A list element is a value: copy it, change it, store it back.
        Dim list As New List(Of (Id As Integer, Title As String)) From {(1, "A"), (2, "B")}
        Dim item = list(0)
        item.Title = "Z"
        list(0) = item
        Console.WriteLine(list(0))

        ' An array element is a variable, so it can be changed in place.
        Dim array = {(Id:=1, Title:="A")}
        array(0).Title = "Y"
        Console.WriteLine(array(0))

        ' More than seven elements: the tenth is still Item10, stored in nested Rest tuples.
        Dim wide = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        Console.WriteLine(wide.Item10 & " " & wide.GetType().Name & " " & wide.Rest.GetType().Name)
    End Sub
End Module

Dune Emma
DUNE
(1, Z)
(1, Y)
10 ValueTuple`8 ValueTuple`3

Option Strict On

Imports System.Reflection

Module Program
    Function Range() As (Min As Integer, Max As Integer)
        Return (1, 9)
    End Function

    Sub Main()
        Dim named = (Answer:=42, Message:="The meaning of life")
        Dim differentNamed = (SecretConstant:=1, Label:="x")

        ' Same arity and convertible types: values are copied by position, names stay with the variable.
        named = differentNamed
        Console.WriteLine(named.Answer & " " & named.Message)

        ' Widening element conversion: (Integer, String) to (Long, String).
        Dim wider As (Long, String) = named
        Console.WriteLine(wider.Item1.GetType().Name)

        ' Narrowing needs an explicit conversion, and checks the range at run time.
        Dim big As (Long, String) = (3000000000L, "big")
        Try
            Dim narrow = CType(big, (Integer, String))
            Console.WriteLine(narrow)
        Catch ex As OverflowException
            Console.WriteLine("OverflowException")
        End Try

        ' Through Object the names are gone; DirectCast needs the exact element types.
        Dim boxed As Object = named
        Dim back = DirectCast(boxed, (Integer, String))
        Console.WriteLine(back.Item2)
        Console.WriteLine(TypeOf boxed Is ValueTuple(Of Integer, String))

        ' The names live in an attribute on the member that declares them.
        Dim method = GetType(Program).GetMethod("Range", BindingFlags.Static Or BindingFlags.Public Or BindingFlags.NonPublic)
        Dim data = method.ReturnParameter.GetCustomAttributesData().Single()
        Dim names = CType(data.ConstructorArguments(0).Value, IEnumerable(Of CustomAttributeTypedArgument))
        Console.WriteLine(data.AttributeType.Name & ": " & String.Join(", ", names.Select(Function(n) n.Value)))

        ' Nullable tuple.
        Dim maybe As (Min As Integer, Max As Integer)? = Nothing
        Console.WriteLine(maybe.HasValue)
        maybe = Range()
        Console.WriteLine(maybe.Value.Max)
    End Sub
End Module

1 x
Int64
OverflowException
x
True
TupleElementNamesAttribute: Min, Max
False
9

Option Strict On

Module Program
    Sub Main()
        Dim pair = (1, "Dune")
        Dim narrower As (Integer, Integer) = pair

        Dim list As New List(Of (Id As Integer, Title As String)) From {(1, "A")}
        list(0).Title = "Z"

        Dim triple = (1, 2, 3)
        pair = triple
    End Sub
End Module

Program.vb(12,16): error BC30311: Value of type '(Integer, Integer, Integer)' cannot be converted to '(Integer, String)'.
Program.vb(6,46): error BC30512: Option Strict On disallows implicit conversions from '(Integer, String)' to '(Integer, Integer)'.
Program.vb(9,9): error BC30068: Expression is a value and therefore cannot be the target of an assignment.

Option Strict On

Public Class Book
    Public Property Title As String = ""
    Public Property Year As Integer
End Class

Module Program
    Sub Main()
        Dim book As New Book() With {.Title = "Dune", .Year = 1965}

        ' Explicit names, with and without Key.
        Dim plain = New With {.Id = 1, .Title = "Dune"}
        Dim keyed = New With {Key .Id = 1, Key .Title = "Dune"}
        Console.WriteLine(plain)
        Console.WriteLine(keyed)

        ' Names and types inferred from the expressions (Visual Basic 9.0).
        Dim inferred = New With {book.Title, book.Year, Key .Decade = (book.Year \ 10) * 10}
        Console.WriteLine(inferred)
        Console.WriteLine(inferred.Title & " " & inferred.Decade)

        ' Non-Key properties can be assigned; Key properties are read-only.
        plain.Title = "Dune Messiah"
        Console.WriteLine(plain.Title)

        ' Anonymous types can nest and can hold arrays and lambdas.
        Dim richer = New With {.Author = New With {.Name = "Frank Herbert"}, .Years = {1965, 1969}, .Greet = Function(s As String) "Hello " & s}
        Console.WriteLine(richer.Author.Name & " " & richer.Years.Length & " " & richer.Greet("reader"))

        ' The type is generated: internal, sealed, generic and without a usable name.
        Dim t = keyed.GetType()
        Console.WriteLine(t.Name.StartsWith("VB$AnonymousType_") & " " & t.IsGenericType & " " & t.IsSealed & " " & t.IsPublic)
        Console.WriteLine(t.BaseType.Name)
    End Sub
End Module

{ Id = 1, Title = Dune }
{ Id = 1, Title = Dune }
{ Title = Dune, Year = 1965, Decade = 1960 }
Dune 1960
Dune Messiah
Frank Herbert 2 Hello reader
True True True False
Object

Option Strict On

Module Program
    Sub Main()
        Dim keyed = New With {Key .Id = 1, Key .Title = "Dune"}
        keyed.Id = 2
    End Sub
End Module

Program.vb(6,9): error BC30526: Property 'Id' is 'ReadOnly'.

Option Strict On

Module Program
    Sub Main()
        Dim a1 = New With {Key .Id = 1, Key .Title = "Dune"}
        Dim a2 = New With {Key .Id = 1, Key .Title = "Dune"}
        Dim a3 = New With {Key .Id = 1, Key .Title = "Emma"}
        Console.WriteLine("Key: " & a1.Equals(a2) & " " & a1.Equals(a3) & " hash equal: " & (a1.GetHashCode() = a2.GetHashCode()))

        Dim p1 = New With {.Id = 1, .Title = "Dune"}
        Dim p2 = New With {.Id = 1, .Title = "Dune"}
        Console.WriteLine("no Key: " & p1.Equals(p2) & " " & p1.Equals(p1))

        ' Only the Key properties take part in equality.
        Dim m1 = New With {Key .Id = 1, .Note = "first"}
        Dim m2 = New With {Key .Id = 1, .Note = "second"}
        Console.WriteLine("mixed: " & m1.Equals(m2))

        ' What the compiler generated.
        Console.WriteLine("Key interfaces: " & String.Join(",", a1.GetType().GetInterfaces().Select(Function(i) i.Name)))
        Console.WriteLine("no-Key interfaces: " & p1.GetType().GetInterfaces().Length)
        Console.WriteLine(a1.GetType().GetMethod("Equals", {GetType(Object)}).DeclaringType Is a1.GetType())
        Console.WriteLine(p1.GetType().GetMethod("Equals", {GetType(Object)}).DeclaringType Is p1.GetType())

        ' Type identity: names (case-insensitive), order, types and Key must all match.
        Dim same = New With {Key .title = "x", Key .ID = 2}
        Dim sameShape = New With {Key .Title = "y", Key .Id = 3}
        Dim reordered = New With {Key .Id = 3, Key .Title = "y"}
        Dim differentKey = New With {Key .Title = "y", .Id = 3}
        Dim differentType = New With {Key .Title = "y", Key .Id = 3L}
        Console.WriteLine(same.GetType() Is sameShape.GetType())
        Console.WriteLine(sameShape.GetType() Is reordered.GetType())
        Console.WriteLine(sameShape.GetType() Is differentKey.GetType())
        Console.WriteLine(sameShape.GetType() Is differentType.GetType())

        ' Equals(Object) between different anonymous types is False, never an error.
        Console.WriteLine(sameShape.Equals(reordered))

        ' Use as keys of hashed collections.
        Dim set1 As New HashSet(Of Object) From {a1, a2, a3}
        Console.WriteLine(set1.Count)
    End Sub
End Module

Key: True False hash equal: True
no Key: False True
mixed: True
Key interfaces: IEquatable`1
no-Key interfaces: 0
True
False
True
False
False
False
False
2

Option Strict On

Public Class Book
    Public ReadOnly Property Title As String
    Public ReadOnly Property Year As Integer
    Public ReadOnly Property Kind As String

    Public Sub New(title As String, year As Integer, kind As String)
        Me.Title = title
        Me.Year = year
        Me.Kind = kind
    End Sub
End Class

Public Class Loan
    Public ReadOnly Property Title As String
    Public ReadOnly Property Borrower As String

    Public Sub New(title As String, borrower As String)
        Me.Title = title
        Me.Borrower = borrower
    End Sub
End Class

Module Program
    Sub Main()
        Dim items = {
            New Book("Dune", 1965, "Novel"),
            New Book("Emma", 1815, "Novel"),
            New Book("Nature", 1965, "Magazine"),
            New Book("Ulysses", 1922, "Novel"),
            New Book("Wired", 1965, "Magazine")}
        Dim loans = {New Loan("Dune", "Ana"), New Loan("Wired", "Luis"), New Loan("Dune", "Marta")}

        ' 1. Projection: with several expressions, Select builds an anonymous type with Key properties.
        Dim projection = From b In items
                         Where b.Year > 1900
                         Order By b.Title
                         Select b.Title, b.Year
        For Each p In projection
            Console.WriteLine($"{p.Title} ({p.Year})")
        Next

        ' 2. Renaming and computing members.
        Dim labels = From b In items
                     Select Label = b.Kind & ": " & b.Title, Age = 2026 - b.Year
        Console.WriteLine(labels.First())

        ' 3. Composite grouping key: it must be a Key anonymous type (or a tuple).
        Dim groups = From b In items
                     Group By k = New With {Key b.Year, Key b.Kind} Into Count()
                     Order By k.Year, k.Kind
        For Each g In groups
            Console.WriteLine($"{g.k.Year} {g.k.Kind}: {g.Count}")
        Next
        Dim brokenGroups = From b In items
                           Group By k = New With {b.Year, b.Kind} Into Count()
        Console.WriteLine("without Key: " & brokenGroups.Count() & " groups instead of " & groups.Count())

        ' 4. Join on a composite key.
        Dim borrowed = From b In items
                       Join l In loans On New With {Key b.Title} Equals New With {Key l.Title}
                       Select b.Title, l.Borrower
        Console.WriteLine(String.Join("; ", borrowed.Select(Function(r) r.Title & "->" & r.Borrower)))
        Dim unmatched = From b In items
                        Join l In loans On New With {b.Title} Equals New With {l.Title}
                        Select b.Title, l.Borrower
        Console.WriteLine("without Key: " & unmatched.Count() & " matches")

        ' 5. Distinct only collapses anonymous values when they have Key properties.
        Console.WriteLine(items.Select(Function(b) New With {Key b.Kind}).Distinct().Count())
        Console.WriteLine(items.Select(Function(b) New With {b.Kind}).Distinct().Count())

        ' 6. Method syntax, and a List of the generated type.
        Dim list = items.Select(Function(b) New With {Key b.Title, .Initial = b.Title(0)}).ToList()
        list.Add(New With {Key .Title = "Extra", .Initial = "E"c})
        Console.WriteLine(list.Count & " " & list(5).ToString())
    End Sub
End Module

Dune (1965)
Nature (1965)
Ulysses (1922)
Wired (1965)
{ Label = Novel: Dune, Age = 61 }
1815 Novel: 1
1922 Novel: 1
1965 Magazine: 2
1965 Novel: 1
without Key: 5 groups instead of 4
Dune->Ana; Dune->Marta; Wired->Luis
without Key: 0 matches
2
5
6 { Title = Extra, Initial = E }

Option Strict On

Module Program
    Private ReadOnly Origin = New With {.X = 0, .Y = 0}

    Sub Main()
        Console.WriteLine(Origin)
    End Sub
End Module

Program.vb(4,22): error BC30209: Option Strict On requires all variable declarations to have an 'As' clause.

Option Strict On

Module Program
    Function MakeItem() As Object
        Return New With {.Title = "Dune", .Year = 1965}
    End Function

    Sub Main()
        Dim item = MakeItem()
        Console.WriteLine(item.Title)
    End Sub
End Module

Program.vb(10,27): error BC30574: Option Strict On disallows late binding.

Option Strict On

Module Program
    ' Generic inference lets a helper accept an anonymous type without naming it.
    Function Describe(Of T)(value As T) As String
        Return "anonymous=" & GetType(T).Name.StartsWith("VB$AnonymousType_") & " -> " & value.ToString()
    End Function

    ' A lambda keeps the anonymous type in its return type, inside one method.
    Function Project(Of T, TResult)(source As IEnumerable(Of T), selector As Func(Of T, TResult)) As List(Of TResult)
        Return source.Select(selector).ToList()
    End Function

    ' The "cast by example" trick: recover the type from a sample of the same shape.
    Function CastByExample(Of T)(value As Object, example As T) As T
        Return DirectCast(value, T)
    End Function

    Function Boxed() As Object
        Return New With {Key .Id = 7, Key .Title = "Dune"}
    End Function

    Sub Main()
        Console.WriteLine(Describe(New With {Key .Id = 1}))

        Dim rows = Project({"Dune", "Emma"}, Function(s) New With {Key .Title = s, .Length = s.Length})
        Console.WriteLine(rows(1).Title & " " & rows(1).Length)

        Dim sample = New With {Key .Id = 0, Key .Title = ""}
        Dim back = CastByExample(Boxed(), sample)
        Console.WriteLine(back.Id & " " & back.Title)
    End Sub
End Module

anonymous=True -> { Id = 1 }
Emma 4
7 Dune