Name Tuples/Anonymous Types in F#?

I find it easier to do

let route = routes.MapRoute(
    "Default", // Route name
    "{controller}/{action}/{id}" // URL with parameters
    )
route.Defaults.Add("controller", "Home")
route.Defaults.Add("action", "Index")

or

[ "controller", "Home"
  "action", "Index" ]
|> List.iter route.Defaults.Add

In F#, I would avoid calling overloads that accept anonymous types much as I would avoid calling an F# method accepting FSharpList from C#. Those are language-specific features. Usually there is a language-agnostic overload/workaround available.

EDIT

Just looked at the docs--here's yet another way to do it

let inline (=>) a b = a, box b

let defaults = dict [
  "controller" => "Home"
  "action"     => "Index" 
]
route.Defaults <- RouteValueDictionary(defaults)

• +1 This is definitely nicer. I didn't know that there is a more sensible overload for Add - I should use that in my ASP.NET MVC samples too! - Tomas Petricek
• Re: using RouteValueDictionary. This compiles, but doesn't work, because the expected dictionary type is IDictionary<string,obj>. At runtime it unboxes the "obj", so it must first be box'ed when it is created. Instead, use: "dict [ ("controller", box "Home");("action", box "Index")]". This also enables defaults of mixed types, eg. ("User", box null),("id", box UrlParameter.Optional). - Stephen Hosking
• @Javaman59: Oops, forgot to box the values. Fixed. Thanks. - Daniel
• @Daniel. Nice work. I like the (=>) operator. Makes it much more readable. - Stephen Hosking

You can't create "anonymous records" in F# - when using types, you can either use tuples which are anonymous, but don't carry labels or you can use records which have to be declared in advance and have labels:

// Creating an anonymous tuple
let route = ("Home", "Index", UrlParameter.Optional)

// Declaration and creating of a record with named fields
type Route = { controller : string; action : string; id : UrlParameter } 
let route = { controller = "Home"; action = "Index"; id = UrlParameter.Optional } 

Technically, the problem with anonymous records is that they would have to be defined as actual classes somewhere (the .NET runtime needs a type), but if the compiler put them in every assembly, then two anonymous records with same members might be different types if they were defined in different assemblies.

Honestly, I think that the example you posted is just a poor design decision in ASP.NET - it is misusing a particular C# feature to do something for which it wasn't designed. It may not be as bad as this, but it's still odd. The library takes a C# anonymous type, but it uses it as a dictionary (i.e. it uses it just as a nice way to create key-value pairs, because the properties that you need to specify are dynamic).

So, if you're using ASP.NET from F#, it is probably easier to use an alternative approach where you don't have to create records - if the ASP.NET API provides some alternative (As Daniel shows, there is a nicer way to write that).

• @Kirk: An IDictionary seems like a better choice. In F# that would be dict ["controller", "Home"; "action", "Index"] -- very natural. - Daniel
• I think that would actually be neither as concise nor as clear: new Dictionary<string, object> { { "controller", "Home" }, { "action", "Index" } } vs. new { controller = "Home", action = "Index" } (And was specifically asking about a solution that wouldn't be worse in C#) - Kirk Woll
• I wouldn't say IDictionary is clearer or shorter in C#, but it's a better approach (happy medium) given that several languages target the CLR. Anonymous types are specific to C#. - Daniel
• The point is, if ASP.NET is a .NET library (as opposed to being a C# library), it simply shouldn't make any assumptions about the language that people are going to use. Using classes with properties to represent dictionaries sounds pretty silly from the pure .NET perspective! - Tomas Petricek
• @Kirk - even in C#, there are still problems with this approach, such as discoverability. The defaults parameter has type object with description "An object that contains default route values.". As a caller, this is completely inscrutable unless I've seen examples of the heavily idiomatic style used by the library. To me, this is symptomatic of a workaround for C#'s inability to support concise collection literals, rather than a positive use of a C# feature that F# lacks. - kvb

The OP does not describe the best use of anonymous type. They are best used when using LINQ to map to an arbitrary class. For example:

var results = context.Students
              .Where(x => x.CourseID = 12)
              .Select(x => new { 
                 StudentID = x.ID, 
                 Name = x.Forename + " " + x.Surname
              });

I know this can be done by defining a new record type, but then you have two places to maintain code, (1) the record type definition (2) where you've used it.

It could instead be done with a tuple, but to access individual fields you have to use the deconstruction syntax (studentId, name) all the time. This becomes unwieldy if you have 5 items in the tuple. I would rather type in x and hit dot and have intellisense tell me what fields are available.

Here's my take on the default web project route config:

module RouteConfig =

    open System.Web.Mvc
    open System.Web.Routing

    let registerRoutes (routes: RouteCollection) =

        routes.IgnoreRoute("{resource}.axd/{*pathInfo}")

        /// create a pair, boxing the second item
        let inline (=>) a b = a, box b

        /// set the Defaults property from a given dictionary
        let setDefaults defaultDict (route : Route) =  
            route.Defaults <- RouteValueDictionary(defaultDict)

        routes.MapRoute(name="Default", url="{controller}/{action}/{id}")
        |> setDefaults (dict ["controller" => "Home" 
                              "action" => "Index" 
                              "id" => UrlParameter.Optional])