Hello. We know that C# 3.0 introduces a new feature called anonymous type which can be used within a query expression to create a type on the fly, just like the following:

1
2
3
4
5
6
7
8

var q =
    from book in GetBooks()
    where book.Price < 50.0
    select new
    {
        book.Title,
        book.Authors
    };

where the type of book is defined as follows:

1
2
3
4
5
6
7

class Book
{
    public string Title { get; set; }
    public string Authors { get; set; }
    public double Price { get; set; }
    public string Tags { get; set; }
}

Here I create an anonymous type and perform a transformation from the type Book to the anonymous type. Is it possible to create anonymous type like the one above in F#?

Let me see, object expression can be used to create anonymous type, but it only supports overriding existing dispatch slot(s) and not allows inserting additional members. Therefore, it doesn't meet the need.

Another try, tuple is a wonderful type that simplifies data transfer in F#, so why not have a try with tuple?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

type Book =
    { Title: string;
      Authors: string;
      Price: double;
      Tags: string }
      
let getBooks() =
    [ { Title = "Expert F#"
        Authors = "Don Syme;Adam Granicz;Antonio Cisternino"
        Price = 55.99
        Tags = "F#" }
      { Title = "Foundations of F#"
        Authors = "Robert Pickering"
        Price = 47.99
        Tags = "F#" } ]
      
let where = Seq.filter
let select = Seq.map

open System

let q =
    getBooks()
    |> where (fun b -> b.Price <= 50.0)
    |> select (fun b -> (b.Title, b.Authors))

So far so good, and tuple seems to be the right type that meets the need. Now back to the first code snippet, what do you usually do with the query in a Windows application or web application? Let me guess, you may want to bind it directly to a grid-like control, such as DataGridView of Windows Forms, right? For C# anonymous type, it's OK because the property names can act as the column names of grid-like control; while F# tuple lacks this kind of information. Of course you may argue that I can configure the column names of the grid-like control, but this will leave me a problem of synchronizing these two thing manually. Yes, you may also argue that I should create a named type in this situation because I want to share data across different scopes. That's a good point, but what if I allow the users to choose what column(s) to display and query only what needs to be displayed? In this case, I may need that "name(s)".

Yup, tuple may also help in this situation with the following lambda expression for select:

1

fun b -> (("Title", b.Title), ("Authors", b.Authors))

But this could lead to another problem, i.e. it makes me hard to tell grid-like controls how to get the display correctly though possible. Therefore I wonder whether there's an easy way to meet the need. What do you think guys?

By the way, when I bound q to DataGridView in F# as follows:

1

grid.DataSource <- q

nothing was shown (grid has been added to a Form object correctly); while the following worked:

1

grid.DataSource <- (q |> Seq.to_array)

For C#, q of type IEnumerable<T> can be bound to DataGridView directly, so how come with F# seq<'a>?

Thanks in advance!