S>Linq, при кажущейся простоте, потребовал:

S>

S>
Generics
S>
Extension Methods
S>
Lamda expressions
S>
Expression trees
S>
Anonumus types
S>
Object initializers
S>
Type inferring
S>

S>Это огромный пласт работы. Но и результат до сих пор впечатляет.

S>Есть ли что-либо подобное на других языках/платформах?

Еще нужно добавить про yield и ленивое выполнение.
То есть при выполнении цепочки

list.Where.Where.Select.Count
List пройдет всего один цикл ибо выполнение начнется с права на лево
Count вызовет MoveNext у Select, Select у Where и так далее.
По этому мы можем объединять Where без потери производительности на лишние циклы

I>Т.е. yield это частный случай для IEnumerable. То есть, частный случай частного случая

private static IEnumerable<TSource> WhereIterator<TSource>(IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
        {
            int index = -1;
            foreach (TSource element in source)
            {
                checked
                {
                    index++;
                }

                if (predicate(element, index))
                {
                    yield return element;
                }
            }
        }

I>Не подашь. У меня параметры это массивы в явном виде шоб люди навроде тебя не подпихивали хрень и не заявляли "Ваша обработка коллекций тормозит после того, как я сто фильтров объединил"

 var result= new List<TSource>();
            foreach (TSource element in source)
            {
     
                if (predicate(element, index))
                {
                   // yield return element;
                 result.Add(element);
                }
            }

return result;

private static IEnumerable<TResult> SelectIterator<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
        {
            int index = -1;
            foreach (TSource element in source)
            {
                checked
                {
                    index++;
                }

                yield return selector(element, index);
            }
        }

public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
            if (source == null) throw Error.ArgumentNull("source");
            if (predicate == null) throw Error.ArgumentNull("predicate");
            if (source is Iterator<TSource>) return ((Iterator<TSource>)source).Where(predicate);
            if (source is TSource[]) return new WhereArrayIterator<TSource>((TSource[])source, predicate);
            if (source is List<TSource>) return new WhereListIterator<TSource>((List<TSource>)source, predicate);
            return new WhereEnumerableIterator<TSource>(source, predicate);
        }

public override bool MoveNext() {
                switch (state) {
                    case 1:
                        enumerator = source.GetEnumerator();
                        state = 2;
                        goto case 2;
                    case 2:
                        while (enumerator.MoveNext()) {
                            TSource item = enumerator.Current;
                            if (predicate(item)) {
                                current = item;
                                return true;
                            }
                        }
                        Dispose();
                        break;
                }
                return false;
            }

 //public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
        //    if (source == null) throw Error.ArgumentNull("source");
        //    if (predicate == null) throw Error.ArgumentNull("predicate");
        //    return WhereIterator<TSource>(source, predicate);
        //}
 
        //static IEnumerable<TSource> WhereIterator<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate) {
        //    foreach (TSource element in source) {
        //        if (predicate(element)) yield return element;
        //    }
        //}

static void Main()
{
    var n =
        from c in 1.ToMaybe()
        from s in "2".ToMaybe()
        from x in 2.ToMaybe()
        select s + c + x;

    Console.WriteLine(n);
}

abstract class Maybe<T>
{
    public class Nothing : Maybe<T> {}
    public class Just : Maybe<T>
    {
        public T Value;
    }

    public override string ToString() => this switch
    {
        Just j => j.Value.ToString(),
        _ => "Nothing"
    };
}

static class Extensions
{
    public static Maybe<T> ToMaybe<T>(this T value)
    {
        return value == null ? (Maybe<T>)new Maybe<T>.Nothing() : new Maybe<T>.Just { Value = value };
    }

    public static Maybe<T2> SelectMany<T1,T2>(
        this Maybe<T1> source, Func<T1,Maybe<T2>> selector)
    {
        if (source is Maybe<T1>.Just j) return selector(j.Value);
        return new Maybe<T2>.Nothing();
    }

    public static Maybe<T3> SelectMany<T1,T2,T3>(
        this Maybe<T1> source, Func<T1,Maybe<T2>> collectionSelector, Func<T1,T2,T3> resultSelector)
    {
        return source.SelectMany(x => collectionSelector(x).SelectMany(y => resultSelector(x, y).ToMaybe()));
    }
}

IT>static void Main()
IT>{
IT>    var n =
IT>        from c in 1.ToMaybe()
IT>        from s in "2".ToMaybe()
IT>        from x in 2.ToMaybe()
IT>        select s + c + x;

IT>    Console.WriteLine(n);
IT>}

IT>abstract class Maybe<T>
IT>{
IT>    public class Nothing : Maybe<T> {}
IT>    public class Just : Maybe<T>
IT>    {
IT>        public T Value;
IT>    }

IT>    public override string ToString() => this switch
IT>    {
IT>        Just j => j.Value.ToString(),
IT>        _ => "Nothing"
IT>    };
IT>}

IT>static class Extensions
IT>{
IT>    public static Maybe<T> ToMaybe<T>(this T value)
IT>    {
IT>        return value == null ? (Maybe<T>)new Maybe<T>.Nothing() : new Maybe<T>.Just { Value = value };
IT>    }

IT>    public static Maybe<T2> SelectMany<T1,T2>(
IT>        this Maybe<T1> source, Func<T1,Maybe<T2>> selector)
IT>    {
IT>        if (source is Maybe<T1>.Just j) return selector(j.Value);
IT>        return new Maybe<T2>.Nothing();
IT>    }

IT>    public static Maybe<T3> SelectMany<T1,T2,T3>(
IT>        this Maybe<T1> source, Func<T1,Maybe<T2>> collectionSelector, Func<T1,T2,T3> resultSelector)
IT>    {
IT>        return source.SelectMany(x => collectionSelector(x).SelectMany(y => resultSelector(x, y).ToMaybe()));
IT>    }
IT>}
IT>

var selectedUsers = from user in users
                    from lang in user.Languages
                    where user.Age < 28
                    where lang == "английский"
                    select user;

var selectedUsers = users.SelectMany(u => u.Languages,
                            (u, l) => new { User = u, Lang = l })
                          .Where(u => u.Lang == "английский" && u.User.Age < 28)
                          .Select(u=>u.User);

var n = 1.ToMaybe().SelectMany(u => "2".ToMaybe(),
                            (c, s) => new { c, s })
                .SelectMany(u => 2.ToMaybe(),
                            (t, x) =>  t.s + t.c + x);
         
            Console.WriteLine(n);

public static Maybe<T2> SelectMany<T1, T2>(
            this Maybe<T1> source, Func<T1, Maybe<T2>> selector)
        {
            if (source is Maybe<T1>.Just j)
                return selector(j.Value);

            return new Maybe<T2>.Nothing();
        }

        public static T1 Ret<T1>(T1 value)
        {
            return value;
        }

        public static T1 Ret2<T1>(T1 value)
        {
            return value;
        }
        public static Maybe<T3> SelectMany<T1, T2, T3>(
            this Maybe<T1> source, Func<T1, Maybe<T2>> collectionSelector, Func<T1, T2, T3> resultSelector)
        {
              return source.SelectMany(x => 
            collectionSelector(Ret(x))
            .SelectMany(y => 
            resultSelector(x, Ret2(y)).
            ToMaybe()));
        }

I>> Ты в любой момент можешь отказаться от вызова MoveNext, а следовательно, IEnumerable сам по себе ленивый, безо всякого yield.

Да но именно yield и создает IEnumerable ленивым.

I>>> Теперь ясно, почему тебе мои аргументы непонятны.

 var n =
        from c in 1.ToMaybe()
        from s in "2".ToMaybe()
        from x in 2.ToMaybe()
        select s + c + x;

var n = 1.ToMaybe().SelectMany(u => "2".ToMaybe(),
                            (c, s) => new { c, s })
                .SelectMany(u => 2.ToMaybe(),
                            (t, x) =>  t.s + t.c + x);