

Longest and Shortest Type Name in .NET 4.0 using LINQ - bunglebooz
http://www.dotnetcurry.com/ShowArticle.aspx?ID=535

======
euroclydon
It would be pretty cool to try to instantiate each one, and then do a
sizeof(instance) on it to see how large the memory footprint is.

~~~
daeken
If you only want the size of the object itself -- not the things it references
-- then you don't actually need to instantiate them to know this. You can
reflect on the fields of the type and calculate its memory footprint that way.

------
DanielBMarkham
I love F#.

Same code in F# (one line, of course!)

    
    
      let currentNetTypes = System.AppDomain.CurrentDomain.GetAssemblies() |>
          Seq.filter(fun x->x.FullName.Contains("Version=4.0.0.0")) |>
          Seq.map(fun x->x.GetExportedTypes()) |> Seq.concat |>
          Seq.sortBy(fun x->x.Name.Length);;
    

To me this reads easier, but I admit to a biased opinion :)

~~~
MichaelGG
The only thing I'm not overly fond of is the repeated "fun x -> x". It'd be
nice if there was a way to refer to members without an instance reference. So
you could write:

    
    
      Seq.map ($GetExportedTypes()) |> Seq.sortBy $x.Name.Length
    

Where $ is some special syntax to indicate "generate a function that uses its
parameter as the this parameter for the instance call". I think this has been
brought up but perhaps a nice syntax hasn't been found?

~~~
daeken
In Nemerle (another ML dialect for .NET), you can use _ to that end. Syntax
for local functions/lambdas, all equivalent (but suited for different
situations, syntactically speaking):

    
    
      def foo(x) { x + 5 }
      fun(x) { x + 5}
      (x) => x + 5
      lambda x -> x + 5
      _ + 5
    

I find I miss the _ syntax more than most syntactical sugar. I don't know how
often I have to write things like _lambda x: x.foo_ in Python, where __.foo_
would serve the same purpose.

