ЗХ>>Вот спасибо. Вот уж спасибочки...

E>Так вот получается, что Java произошла от Oak, который вобрал в себя: Ada 83, Objective C, C++, Cedar, Smalltalk-80, Scheme. Не хилая солянка, однако (но синтаксис-то C++ный ).

E>А у C# было всего три прародителя: Deplhi 5, C++, Java. (Но ведь и Java имеет в родителях C++, так что у C# с C++ довольно тесные родственные связи ).

- А-а! Вы историк? — с большим облегчением и уважением спросил Берлиоз.
— Я — историк, — подтвердил ученый и добавил ни к селу ни к городу: — Сегодня вечером на Патриарших прудах будет интересная история!

VD>int[] array = {1,2,3,2,4,5,7,6,7,2};

VD>var y = from x in array
VD>    where x < 7
VD>    group x by x into z
VD>    orderby z.Key
VD>    select new { Value = z.Key, Встерчается = z.Group.Count() };

VD>foreach (var varue in y)
VD>    Console.WriteLine(varue);
VD>

var y = array.Where(x => x < 7).GroupBy(x => x).OrderBy(z => z.Key)
    .Select(z => new { Value = z.Key, Встерчается = z.Group.Count() });

//тут предполагается, что select вернет объект, у которого будут нужные методы
/*тип?*/ y = select(array, _1 < 7).groupBy(_1).orderBy(_1.key).generate( std::make_pair(_1.key, _1.group.count) );

member(_1, /*тип?*/::key);
//или
_1.method("key");
//или, наконец, учитывая, что мы знаем, что это методы типа, который вернул groupBy:
...groupBy(_1).orderBy(_group.key).generate( std::make_pair(_group.key, _group.group.count) );

C>управлением памятью

for_each( begin(a), end(a),
        void lambda( const int & x, map_t & m = occur )
            { if( x < 7 ) m[ x ]++; }
    );

class lambda_impl
    {
    private :
        map_t & m_m;
        
        void body( const int & x, map_t & m )
            { if( x < 7 ) m[ x ]++; }
            
    public :
        lambda_impl( map_t & m ) : m_m( m ) {}
        void operator()( const int & x ) { body( x, m_m ); }
    };
    
for_each( begin(a), end(a), lambda_impl() );

class my_functor_t : public std::unary_function< param_type, result_type >
{
public :
    result_type operator()( argument_type a ) { /* Мой код */ }
};

class my_another_functor_t : public std::unary_function< param_type, result_type >
{
    binded_object_type m_binded_object;
    other_object_type m_other_object;
public :
    my_another_functor_t(
        binded_object_type binded_object,
        other_object_type other_object )
        :    m_binded_object( binded_object )
        ,    m_other_object_type( other_object )
        {}
    result_type operator()( argument_type a ) { /* Мой код */ }
};

result_type lambda(
        param_type a,
        binded_object_type binded_object = ...,
        other_object_type other_object = ... )
    {
        /* Мой код */
    }

class my_class_t
    {
        some_list_t m_list;
        some_map_t m_map;
        some_complex_data_t m_data;
    ...
        void some_method()
            {
                some_list_t updated_list;
                std::for_each( m_list.begin(), m_list.end(),
                    void lambda( some_list_t::value_type a,
                            some_list_t & receiver = updated_list,
                            some_map_t & map = m_map,
                            const some_complex_data_t & data = m_data )
                        {
                            /* Мой код, который использует m_map, m_data (через ссылки map и data). */
                        }
                );
                m_list.swap( updated_list );
            }
    };

C> Точнее, там где они останутся — новый С++ не нужен будет.

ЗХ>Понял, что меня в этом варианте смущает Слишком много "новых ключевых слов". По сути, это отдельный DSL внутри C#. Т.е.

ЗХ>var y = array.Where(x => x < 7).GroupBy(x => x).OrderBy(z => z.Key)
ЗХ>    .Select(z => new { Value = z.Key, Встерчается = z.Group.Count() });
ЗХ>

ЗХ>//тут предполагается, что select вернет объект, у которого будут нужные методы
ЗХ>/*тип?*/ y = select(array, _1 < 7).groupBy(_1).orderBy(_1.key).generate( std::make_pair(_1.key, _1.group.count) );
ЗХ>

ЗХ>member(_1, /*тип?*/::key);
ЗХ>//или
ЗХ>_1.method("key");
ЗХ>//или, наконец, учитывая, что мы знаем, что это методы типа, который вернул groupBy:
ЗХ>...groupBy(_1).orderBy(_group.key).generate( std::make_pair(_group.key, _group.group.count) );
ЗХ>

public static IEnumerable<T> Where<T>(
    this IEnumerable<T> source,
    Func<T, bool> predicate)
{
    foreach (T element in source)
        if (predicate(element))
            yield return element;
}

public static OrderedSequence<T> OrderBy<T, K>(
this IEnumerable<T> source,
Func<T, K> keySelector)
{
return new OrderedSequence<T, K>(source, null, keySelector, null, false);
}

public static IEnumerable<Grouping<K, E>> GroupBy<T, K, E>(
    this IEnumerable<T> source,
    Func<T, K> keySelector,
    Func<T, E> elemSelector,
    IEqualityComparer<K> comparer)
{
    Dictionary<K, List<E>> dict = new Dictionary<K, List<E>>(comparer);

    foreach (T element in source)
    {
        K key = keySelector(element);
        E elem = elemSelector(element);
        List<E> list;

        if (!dict.TryGetValue(key, out list))
        {
            list = new List<E>();
            dict.Add(key, list);
        }

        list.Add(elem);
    }

    foreach (KeyValuePair<K, List<E>> pair in dict)
        yield return new Grouping<K, E>(pair.Key, pair.Value);
}

public static IEnumerable<S> Select<T, S>(
    this IEnumerable<T> source,
    Func<T, S> selector)
{
    foreach (T element in source)
        yield return selector(element);
}