LINQ identity function

Just a little niggle about LINQ syntax. I'm flattening an IEnumerable<IEnumerable<T>> with SelectMany(x => x).

My problem is with the lambda expression x => x. It looks a bit ugly. Is there some static 'identity function' object that I can use instead of x => x? Something like SelectMany(IdentityFunction)?

Unless I misunderstand the question, the following seems to work fine for me in C# 4:

public static class Defines
{
   public static T Identity<T>(T pValue)
   {
      return pValue;
   }

   ...

You can then do the following in your example:

var result =
   enumerableOfEnumerables
   .SelectMany(Defines.Identity);

As well as use Defines.Identity anywhere you would use a lambda that looks like x => x.

Note: this answer was correct for C# 3, but at some point (C# 4? C# 5?) type inference improved so that the IdentityFunction method shown below can be used easily.

---

No, there isn't. It would have to be generic, to start with:

public static Func<T, T> IdentityFunction<T>()
{
    return x => x;
}

But then type inference wouldn't work, so you'd have to do:

SelectMany(Helpers.IdentityFunction<Foo>())

which is a lot uglier than x => x.

Another possibility is that you wrap this in an extension method:

public static IEnumerable<T> Flatten<T>
    (this IEnumerable<IEnumerable<T>> source)
{
    return source.SelectMany(x => x);
}

Unfortunately with generic variance the way it is, that may well fall foul of various cases in C# 3... it wouldn't be applicable to List<List<string>> for example. You could make it more generic:

public static IEnumerable<TElement> Flatten<TElement, TWrapper>
    (this IEnumerable<TWrapper> source) where TWrapper : IEnumerable<TElement>
{
    return source.SelectMany(x => x);
}

But again, you've then got type inference problems, I suspect...

EDIT: To respond to the comments... yes, C# 4 makes this easier. Or rather, it makes the first Flatten method more useful than it is in C# 3. Here's an example which works in C# 4, but doesn't work in C# 3 because the compiler can't convert from List<List<string>> to IEnumerable<IEnumerable<string>>:

using System;
using System.Collections.Generic;
using System.Linq;

public static class Extensions
{
    public static IEnumerable<T> Flatten<T>
        (this IEnumerable<IEnumerable<T>> source)
    {
        return source.SelectMany(x => x);
    }
}

class Test
{
    static void Main()
    {
        List<List<string>> strings = new List<List<string>>
        {
            new List<string> { "x", "y", "z" },
            new List<string> { "0", "1", "2" }
        };
        
        foreach (string x in strings.Flatten())
        {
            Console.WriteLine(x);
        }
    }
}

With C# 6.0 and if you reference FSharp.Core you can do:

using static Microsoft.FSharp.Core.Operators

And then you're free to do:

SelectMany(Identity)

With C# 6.0 things are getting better. We can define the identity function in the way suggested by @Sahuagin:

static class Functions
{
    public static T It<T>(T item) => item;
}

And then use it in SelectMany the using static constructor:

using Functions;

...

var result = enumerableOfEnumerables.SelectMany(It);

I think it looks very laconic in the such way. I also find the identity function useful when building dictionaries:

class P
{
    P(int id, string name) // Sad. We are not getting primary constructors in C# 6.0
    {
        ID = id;
        Name = id;
    }

    int ID { get; }
    int Name { get; }

    static void Main(string[] args)
    {
        var items = new[] { new P(1, "Jack"), new P(2, "Jill"), new P(3, "Peter") };
        var dict = items.ToDictionary(x => x.ID, It);
    }
}

This may work in the way you want. I realize Jon posted a version of this solution, but he has a second type parameter which is only necessary if the resulting sequence type is different from the source sequence type.

public static IEnumerable<T> Flatten<T>(this IEnumerable<T> source)
    where T : IEnumerable<T>
{
    return source.SelectMany(item => item);
}

You can get close to what you need. Instead of a regular static function, consider an extension method for your IEnumerable<T>, as if the identity function is of the collection, not the type (a collection can generate the identity function of its items):

public static Func<T, T> IdentityFunction<T>(this IEnumerable<T> enumerable)
{
     return x => x;
}

with this, you don't have to specify the type again, and write:

IEnumerable<IEnumerable<T>> deepList = ... ;
var flat = deepList.SelectMany(deepList.IdentityFunction());

This does feel a bit abusive though, and I'd probably go with x=>x. Also, you cannot use it fluently (in chaining), so it will not always be useful.

I'd go with a simple class with a single static property and add as many as required down the line

    internal class IdentityFunction<TSource>
    {
        public static Func<TSource, TSource> Instance
        {
            get { return x => x; }
        }
    }

    SelectMany(IdentityFunction<Foo>.Instance)