I've started Tuples to LINQ and I'm not sure if it's an anti pattern I have 

public static class TupleExtensions {

    public static IEnumerable&lt;T&gt; SelectMany&lt;T&gt;(this IEnumerable&lt;Tuple&lt;T, T&gt;&gt; te)
    {
        foreach (var t in te)
        {
            yield return t.Item1;
            yield return t.Item2;
        }
    }

    public static IEnumerable&lt;T&gt; SelectMany&lt;T, U&gt;(this IEnumerable&lt;U&gt; source, Func&lt;U, Tuple&lt;T, T&gt;&gt; fn)
    {
        foreach (var s in source)
        {
            var t = fn(s);
            yield return t.Item1;
            yield return t.Item2;
        }

    } 

    public static IEnumerable&lt;T&gt; SelectMany&lt;T, U&gt;(this IEnumerable&lt;U&gt; source, Func&lt;U, Tuple&lt;T, T, T&gt;&gt; fn)
    {
        foreach (var s in source)
        {
            var t = fn(s);
            yield return t.Item1;
            yield return t.Item2;
            yield return t.Item3;
        }

    }

    public static IEnumerable&lt;T&gt; SelectMany&lt;T, U&gt;(this IEnumerable&lt;U&gt; source, Func&lt;U, Tuple&lt;T, T, T,T&gt;&gt; fn)
    {
        foreach (var s in source)
        {
            var t = fn(s);
            yield return t.Item1;
            yield return t.Item2;
            yield return t.Item3;
            yield return t.Item4;
        }

    }
}


I can then do as a trivial example

IEnumerable&lt;int&gt; source = ...
source.SelectMany(i=&gt;Tuple.Create(i, i+1, i+2))


Obviously the tuple must have the same types throughout. My use
case is where I have a mathematical solver which will always return
two solutions for a given input. Returning a list makes it unclear
how many solutions would be returned.

However in the end I would want all my solutions merged. For example

static Tuple&lt;Point,Point&gt; Intersect(this Shape shape, Line other);

Shape shape = ...
IEnumerable&lt;Line&gt; lines = ...

IEnumerable&lt;Point&gt; intersections = lines.SelectMany(line=&gt;shape.Intersect(line));


Is there some good reason not to treat Tuple&lt;T,T,T....&gt; as a container that we can flatten?
In general, I think this pattern makes sense, because it clearly expresses what the method returns and lets you easily do the computation you want to do with the result.

Some thoughts:


I don't see any reason why your extension methods should only work on a collection of Tuples and not on a single Tuple. Because of that, I would probably write extension methods that convert a single Tuple to IEnumerable:

public static IEnumerable&lt;T&gt; ToEnumerable&lt;T&gt;(this Tuple&lt;T, T&gt; tuple)
{
    yield return tuple.Item1;
    yield return tuple.Item2;
}


Since this would make the code you showed more complicated, it might make sense to also keep SelectMany(), but express it using ToEnumerable():

public static IEnumerable&lt;T&gt; SelectMany&lt;T&gt;(
    this IEnumerable&lt;Tuple&lt;T, T&gt;&gt; tuples)
{
    return tuples.SelectMany(t =&gt; t.ToEnumerable());
}

public static IEnumerable&lt;T&gt; SelectMany&lt;T, U&gt;(
    this IEnumerable&lt;U&gt; source, Func&lt;U, Tuple&lt;T, T&gt;&gt; selector)
{
    return source.SelectMany(x =&gt; selector(x).ToEnumerable());
}

It might make sense to create custom types that mean “pair (triple, …) of items of the same type”. As a side benefit, you wouldn't need custom ToEnumerable() or SelectMany() extensions, since those types could implement IEnumerable&lt;T&gt; directly.