Mxx_ru::setup_target(
    Mxx_ru::Cpp::Lib_target.new( "aag_3/sms_data_type/prj.rb" ) {

        required_prj "oess_1/defs/prj.rb"

        target_root "lib"
        target "aag_3.sms_data_type" + Aag_3::VERSION

        cpp_source "types.cpp"

        sources_root( "smpp2smsg" ) {
            cpp_source "pub.cpp"
            cpp_source "tag.cpp"
        }

        sources_root( "smsg2smpp" ) {
            cpp_source "pub.cpp"
            cpp_source "tag.cpp"
        }
    }
)

<project type="library" alias="aag_3/sms_data_type/prj">
    <required_prj alias="oess_1/defs/prj.rb" />
    
    <target_root name="lib" />
    <target name="aag_3.sms_data_type" version_suffix="Aag_3::VERSION" />
    
    <cpp_source name="types.cpp" />
    
    <sources_root name="smpp2smsg">
        <cpp_source name="pub.cpp"/>
        <cpp_source name="tag.cpp"/>
    </sources_root>

    <sources_root name="smsg2smpp">
        <cpp_source name="pub.cpp"/>
        <cpp_source name="tag.cpp"/>
    </sources_root>
</project>

c.field :name => :source_addr_ton,
        :type => "oess_1::uchar_t",
        :bit_mask => 0x1,
        :default => 0

c.field( { :name => :source_addr_ton,
        :type => "oess_1::uchar_t",
        :bit_mask => 0x1,
        :default => 0 } )

class MailTruck
    def self.company( name )
        meta_def :company do; name; end
    end
end

class HappyTruck < MailTruck
    company "Happy's -- We Bring the Mail, and That's It!" 
end

h = HappyTruck.new
h.company

class HappyTruck < MailTruck
    def company
        "Happy's -- We Bring the Mail, and That's It!"
    end
end

class My
    attr_accessor :my_attr
end

class My
    # Метод getter.
    def my_attr
        @my_attr
    end
    
    # Метод setter.
    def my_attr=( v )
        @my_attr = v
    end
end

class Date
    ...
    once :day_fraction
    ...
    def day_fraction
        <какие-то вычисления>
    end
    ...
end

class Date
    def calc_day_fraction
        <какие-то вычисления>
    end
    
    def day_fraction
        # Вычисляем атрибут @day_fraction только если он не был вычислен ранее.
        @day_fraction = calc_day_fraction unless @day_fraction
        @day_fraction
    end
end

class Project < ActiveRecord::Base
    belongs_to              :portfolio
    has_one                 :project_manager
    has_many                :milestones
    has_and_belongs_to_many :categories
end

• Project#portfolio, Project#portfolio=(portfolio), Project#portfolio.nil?
  
• Project#project_manager, Project#project_manager=(project_manager), Project#project_manager.nil?,
  
• Project#milestones.empty?, Project#milestones.size, Project#milestones, Project#milestones<<(milestone), Project#milestones.delete(milestone), Project#milestones.find(milestone_id), Project#milestones.find_all(conditions), Project#milestones.build, Project#milestones.create
  
• Project#categories.empty?, Project#categories.size, Project#categories, Project#categories<<(category1), Project#categories.delete(category1)

• В отличии от Lisp-а Ruby остается чисто императивным языком с превычным большинству программистов синтаксисом. Для меня это означает, во-первых, что не требуется адаптации к птичьему Lisp-синтаксису и, во-вторых, что на Ruby можно писать нормальный императивный код.
  
• В отличии от Lisp-а имеется одна основная ветвь разработки Ruby и одна единая реализация, портированная на массу платформ. Еще более важно, что есть единая стандартная библиотека (постоянно и оперативно развиваемая) и централизованная вокруг Ruby community. Достижением этого community является, например, система управления пакетами RubyGems.

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

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

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

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

В школе мне в уши и в рот клизму поставили
Так получил я полезные, нужные знания...

I can’t stop asking myself the same question: is it still possible for a new language to make a breakthrough like C and C+ did at the time?

VD>Тогда просьба к тем, то приводит примеры на Смолтоке: Будьте добры выбирать названия методов понятные тем, кто не знает и не хочет изучать 30-ти летнюю испторию Смолтока.

• do: — foreach;
  
• select: — выбрать элементы по условию;
  
• reject: — обратно к select: выбрать элементы не удовлетворяющие условию (отбросить по условию);
  
• collect: — к каждому элементу применить блок и вернуть коллекцию в которой результаты выполнения блока; в функц. языках обычно называется map;
  
• inject:into: — обсудили;
  
• detect: — вернуть первый элемент, удовлетворяющий условию, выбросить исключение если не найдено;
  
• detect:ifNone: — вернуть первый элемент, удовлетворяющий условию + можно обработать ситуацию отсутствия элемента;

Mixins

Модули имеют еще одно замечательное применение. Коротко говоря они замечательно устраняют необходимость во множественном наследовании, предоставляя возможность, называемую примесями (mixin).

В примере в предыдущем параграфе мы определили методы модуля, чьи имена имеют в качестве префикса имя модуля. Если это навело вас на мысль о статических методах класса (eao197: class method в Ruby является синонимом статического метода в C++), то вашей следующей мыслью может быть: "что же будет, если я определю не статические методы в модуле (eao197: instance method в Ruby является синонимом не статического метода в C++)?". Хороший вопрос. Не может быть экземпляров модуля, т.к. модуль не является классом. Тем не менее, вы можете включить модуль в определение класса. Когда это происходит все не статические методы модуля внезапно оказываются доступны как не статические методы класса. Они подмешаны (mixed in). Фактически, подмешанные модули становятся суперклассами.

module Debug     
  def whoAmI?     
    "#{self.type.name} (\##{self.id}): #{self.to_s}"     
  end     
end     
class Phonograph     
  include Debug     
  # ...     
end     
class EightTrack     
  include Debug     
  # ...     
end     
ph = Phonograph.new("West End Blues")     
et = EightTrack.new("Surrealistic Pillow")     
ph.whoAmI?     »    "Phonograph (#537766170): West End Blues"     
et.whoAmI?     »    "EightTrack (#537765860): Surrealistic Pillow"

Подключая модуль Debug и класс Phonograph, и класс EightTrack получают доступ к не статическому методу whoAmI?.

Несколько замечаний о предложении include перед тем как идти дальше. Во-первых, оно ничего не делает с файлами. C-программисты используют директиву препроцессора #include для включения содержимого одного файла в другой во время компиляции. В Ruby предложение include просто устанавливает ссылку на указанный модуль. Если этот модуль находится в другом файле, то вы должны сначала подключить этот файл посредством require прежде чем делать include. Во-вторых, include в Ruby не просто копирует методы модуля в описание класса. Вместо этого создается ссылка из класса на подключенный модуль. Если несколько классов подключают какой-то модуль, то все они ссылаются на одно и то же. Если вы изменяете определение метода внутри модуля, даже когда ваша программа работает, все подключившие модуль классы начнут проявлять новое поведение. [Конечно же, мы сейчас говорим только о методах. Например, атрибуты экземпляров всегда связаны со своим объектом.]

Примеси дают вам замечательный, управляемый способ добавления функциональность в класса. Но их настоящая мощь проявляется когда код в примеси начинает взаимодействовать с кодом в классе, который использует примеси. Для примера возьмем стандартную Ruby-примесь Comparable. Примесь Comparable может быть использована для добавления как операторов сравнения (<, <=, ==, >=, >), так и метода between? в класс. Для этого Comparable передполагает, что любой использующий его класс определяет оператор <=>. Поэтому, как разработчик класса вы определяете один метод <=>, делаете include Comparable и за просто так получаете шесть функций сравнения. Попробуем это с нашим классом Song сделав сравнение музыкальных композиций по времени звучания. Все, что нам нужно -- это подключить модуль Comparable и реализовать оператор сравнения <=>.

class Song
  include Comparable
  def <=>(other)
    self.duration <=> other.duration
  end
end

Мы можем проверить, что результаты получаются осмысленными с помощью нескольких тестов:

song1 = Song.new("My Way",  "Sinatra", 225)     
song2 = Song.new("Bicylops", "Fleck",  260)     
song1 <=> song2     »    -1     
song1  <  song2     »    true     
song1 ==  song1     »    true     
song1  >  song2     »    false

Наконец, на странице 43 мы показали реализацию Смоллталковской функции inject реализовав ее внутри класса Array. Мы обещали, что мы следаем ее более обобщенной. Какой же лучший путь для этого, нежели определение ее как модуля-примеси?

module Inject
  def inject(n)
     each do |value|
       n = yield(n, value)
     end
     n
  end
  def sum(initial = 0)
    inject(initial) { |n, value| n + value }
  end
  def product(initial = 1)
    inject(initial) { |n, value| n * value }
  end
end

Мы можем протестировать ее подмешав в какой-нибудь встроенный класс.

class Array     
  include Inject     
end     
[ 1, 2, 3, 4, 5 ].sum     »    15     
[ 1, 2, 3, 4, 5 ].product     »    120     

class Range     
  include Inject     
end     
(1..5).sum     »    15     
(1..5).product     »    120     
('a'..'m').sum("Letters: ")     »    "Letters: abcdefghijklm"

Для более сложного примера примеси обратитесь к документации на модуль Enumerable, которая начинается на странице 403 (eao197: on-line версия).

Instance Variables in Mixins

Люди, которые пришли в Ruby из C++, часто спрашивают нас: "Что происходит с атрибутами объектов в примесях? В C++ я могу хоть как-то управлять тем, как атрибуты разделяются в иерархиях с множественным наследованием. Как с этим справляется Ruby?".

Чтож, начинающим мы говорим, что это не очень хороший вопрос. Вспомните, как атрибуты объектов работают в Ruby: первое упоминание начинающейся с "@" переменной создает атрибут в текущем объекте self.

Для примесей это означает, что модуль, который вы вы подмешиваете в ваш клиентский класс, может создавать атрибуты в клиентском объекте и может использовать attr и подобные методы для определения setter-ов/getter-ов для этих атрибутов. Например:

module Notes
  attr  :concertA
  def tuning(amt)
    @concertA = 440.0 + amt
  end
end

class Trumpet
  include Notes
  def initialize(tune)
    tuning(tune)
    puts "Instance method returns #{concertA}"
    puts "Instance variable is #{@concertA}"
  end
end

# The piano is a little flat, so we'll match it
Trumpet.new(-5.3)

приводит к:

Instance method returns 434.7
Instance variable is 434.7

Мы не только имеем доступ к определенным в примеси методам, мы так же получаем доступ к необходимым атрибутам. Конечно же, существует риск, что разные примеси могут использовать атрибуты с одинаковыми именами, что создаст коллизию:

module MajorScales
  def majorNum
    @numNotes = 7 if @numNotes.nil?
    @numNotes # Return 7
  end
end

module PentatonicScales
  def pentaNum
    @numNotes = 5 if @numNotes.nil?
    @numNotes # Return 5?
  end
end

class ScaleDemo
  include MajorScales
  include PentatonicScales
  def initialize
    puts majorNum # Should be 7
    puts pentaNum # Should be 5
  end
end

ScaleDemo.new

результат:

7
7

Обе части подмешанного кода используют атрибу @numNotes. К сожалению, результат, вероятно, не совпадает с тем, что ожидал автор.

По большей части модули-примеси не пытаются иметь собственных атрибутов -- они использут getter-/setter-ы для получения данных из клиентских объектов. Но, если вам нужно создать примесь, которая должна иметь собственное состояние, убедитесь, что атрибут имеет уникальное имя чтобы отличать его от остальных примесей в системе (например, делая имя модуля частью имени атрибута).

Iterators and the Enumerable Module

Вероятно вы заметили, что классы коллекций в Ruby поддерживают большое число операций, которые делают с коллекциями разные вещи: перебор (traverse it), сортировка и т.д. Вы можете подумать: "Ага, я уверен, что будет классно, если мой класс так же сможет поддерживать эти замечательные возможности!" (Если вы действительно думаете так, то, возможно, пора прекращать смотреть повторы телевизионных шоу 1960-х годов).

Хорошо, ваши классы могут поддерживать все эти замечательные возможности благодоря магии примесей и модулю Enumerable. Все, что вы должны для этого сделать -- это определить называемый each итератор, который будет один за один перебирать элементы вашей коллекции. Подмещайте Enumerable и внезапно ваш класс будет поддерживать такие вещи, как map, include? и find_all?. Если объекты в вашей коллекции поддерживают осмысленное упорядочение посредством метода <=>, то вы так же получаете методы min, max и sort.

E>Обобщенное программирование на Java Это забавно.

E>void
E>a_channel_t::on_deliver_sm(
E>    <...bla-bla-bla...>
E>}
E>

E>       pdu_parser_t
E>          /    \
E>         /      \
E>        /        \
E>deliver_sm_t    data_sm_t
E>

VD>>Да, есть. КОП > ООП.

E>Опять ты за свое.

using System;

class Program
{
    delegate int SumDelegate(int[] array, int start, int count);

    static void Main()
    {
        int[] array = new int[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        Console.WriteLine("Сумируем синхронно. Результат:   "
            + Sum(array, 0, 10));

        SumDelegate sum1 = Sum;
        SumDelegate sum2 = Sum;

        IAsyncResult ar1 = sum1.BeginInvoke(array, 0, 5, null, null);
        IAsyncResult ar2 = sum2.BeginInvoke(array, 5, 5, null, null);

        ar1.AsyncWaitHandle.WaitOne();
        ar2.AsyncWaitHandle.WaitOne();

        Console.WriteLine("Сумируем Асинхронно. Результат:  "
            + (sum1.EndInvoke(ar1) + sum2.EndInvoke(ar2)));
    }

    static int Sum(int[] array, int start, int count)
    {
        int end = start + count - 1;
        int sum = 0;

        for (int i = start; i <= end; i++)
            sum += array[i];

        return sum;
    }
}

E>class My_Process
E>    {
E>    public :
E>        async start();
E>        async shutdown();
E>    };
    
E>My_Process * process = new My_Process();
E>process->start(); // А где и когда он будет работать, уже не важно.
E>

E>class SomeClass
E>    ...
E>end # Думаешь, что определение класса SomeClass завершено?
E>

E>class SomeClass
E>  ...
E>end
E>

VD>>Дык и Смолтокщики тоже утверждают. Так вот ходят оба вместе с Лиспщиком и утверждают... рядом с толпами С++-ников, C#-щиков и других Дельфистов.

A>int a[] = {1, 2, 3, 2, 4, 5, 7, 6, 7, 2};
A>typedef map<int, int> map_t;
A>typedef map_t::value_type val_t;
A>map_t occur;

A>for_each(begin(a), end(a),
A>        if_(_1 < 7) [ bind(&map_t::operator[], &occur, _1)++ ]);

A>for_each(begin(occur), end(occur),
A>        cout << bind(&val_t::first, _1) << ":" << bind(&val_t::second, _1) << "\n");
A>

int a[] = {1, 2, 3, 2, 4, 5, 7, 6, 7, 2};
typedef map<int, int> map_t;
typedef map_t::value_type val_t;
map_t occur;

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

for_each(begin(occur), end(occur),
        void lambda( const val_t & x ) { std::cout << x.first << ": " << x.second << std::endl; } );

D>int sum = 0; // Какого фига я должен думать о том где храню результат?
D>for (int i = 0; i < array.length; i++) { // Переведи на русский и прочитай вслух :) "Для скобка цел и равно..."  :))) 
D>  sum += array[i]; // Ну вот это собственно я и думал :)
D>} // Это тоже надо подумать...
D>

Массив всавил двоеточие ноль в двоеточие квадратная...

int sum = Sum(array);
...
static int Sum(int[] array)
{
    int sum = 0;
    
    for (int elem: array)
        sum += elem;
    
    return sum;
}

static int Sum(Node list)
{
    if (list.getNext() == null)
        return 0;
    
    return list.getValue() + Sum(list.getNext());
}

D>Вариант от Smalltalk и ML это два разных способа мышления, а Java/C это сплошное спотыкание мысли и куча мусора.

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

var sum = array.Sum();

var sum = array.Fold((fold, second) => fold + second);

int sum = 0;

foreach (int elem in array)
    sum += elem;

a = "SomeMethodName"
...
b.a(x, y)

---------------------
На консилиуме ученых и военных...
Входит в кабинет секритарша и гворит:
— Тут к вам рвется какой-то товарищь... я его сдержать немогу, говоит что дело государственной важности...
— Ну, что же впустите.
— Здравствуйте! Я изобретатель! Дайте рассказать про свою идею.
— Ну, что же говорите, раз все равно ворвались.
— Значичь идея такова... Вражеские самалеты подетаютк к нашей границе и вдруг переворачиваются и падают. Здорово?!
— Здорово! И как же это все работеат?!
— Не, ну, вы же ученые? Вам и думать как реализовать. А мое дело идею предложить!!!

1. Отправить сообщение
2. Дождаться ответа

1. Отправить сообщение
2. Дождаться окончания обработки сообщения

list.Add("Hello!");

list.Contains("Hello!");

1.1.4 stable rev. 510

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

VD>var sum = array.Sum();
VD>

VD>Понятнее некуда.

VD>var sum = array.Fold((fold, second) => fold + second);
VD>

VD>int sum = 0;

VD>foreach (int elem in array)
VD>    sum += elem;
VD>

sum := 0.
array do: [:elem | sum := sum + elem].

>> E>a.inject { |s, v| s += v }
>> E>

>> int sum = 0;
>> foreach(int a in array)
>>   sum += a;
>>

ПК>int sum = std::accumulate(array.begin(), array.end(), 0);
ПК>

int sum = 0;
sum += each(array);    //ну или each(array.begin, array.end);

template<int N> int factorial() {
    return N*factorial<N-1>();
}

int factorial<0>() {
    return 1;
}

abstract class Int {
    abstact int factorial();
    
    Int create(int value) {
        return value != 0 ? new NotZeroInt(value) : new Zero();
    }
}

class Zero extends Int {
    int factorial() { return 1; }
}

class NotZeroInt extends Int {
    int value;
    int factorial() { return value*Int.create(value - 1); }
}

class ValueHolder<T> {
    T value;
    
    T get() { return value; }
    
    void T set(T newValue) { value = newValue; }

    ValueHolder<List> holder = new ValueHolder<List>();
    holder.setValue(new ArrayList()); // ok 
    holder.setValue(new HashSet());   // error
    List list = holder.get();           // ok
    Object obj = holder.get();        // ok
    Set set = holder.get();           // error
    Map map = (Map)holder.get();      // ok

<T> T create() {
    return (T)new String(); // compiler - warning
}

void f() {
    String s = create();    // compiler - ok, runtime - ok
    List l = create();      // compiler - ok!, runtime - ClassCastException
}

    invokeXXX create // XXX - потому как в данном случае не важно static, virtual, ...
                   // на вершине стека лежит объект класса String.
    checkcast String // Успешно проверили 
    astore_0         // собственно присваивание s
    invokeXXX create // Опять на вершине стека будет String, метод вызвали тоже самый!
    checkcast List   // Выполняется перед присваиванием вершины стека локальной переменной типа List
                     // Тут собственно и случится ClassCastException
    astore_1                 // Эта инструкция выполнена не будет

  T t = new T(); // Компилятор сделает один байт код на все случаи жизни, а их может быть много...
    T[] t = new T[...]; // Массив в Java тоже знает класс своих елементов
    List<T> l = new ArrayList<T>(); // А вот это пожалуйста, после компиляции вместо List<T> останется просто List

template<T>
T* copy(T& value) {
    return (T*)(void*)new XXX(); // "обманываем" компилятор
}

MyClass c = copy(new MyClass()); // Все в порядке, но где-то потом случится GPF

    aReceiver someMessage

  aReceiver meta someMessage

AVK>Т.е. изменение кода на лету будет прорывом, только если будет реализовано в С++?

A a = new A();
a.one_method();
// Oops! Тут код класса уже изменился.
a.one_method(); // Отработал уже другой код.

D>Это уже лучше, с последними веяниями C# не знаком Мусора конечно еще много, но новшество мне нравится.

string[] strs = Array.ConvertAll(array, obj => obj.ToString());

string result = string.Join(", ", strs);

var result = string.Join(", ", Array.ConvertAll(array, obj => obj.ToString()));

var result = string.Join(", ", array.ConvertAll(obj => obj.ToString()));

var result = array.Join(", ", obj => obj.ToString()));

public static class ArrayExt
{
    public static string Join<T>(this T[] array, string separator)
    {
        return string.Join(", ", Array.ConvertAll(array, str => str.ToString()));
    }
}

> E>a.inject { |s, v| s += v }
> E>

> int sum = 0;
> foreach(int a in array)
>   sum += a;
>

int sum = std::accumulate(array.begin(), array.end(), 0);

П>уже нельзя.

b = lambda(x): (x>0)and(x*x)or(-x)

print b(-1)
print b(-2)
print b(0)
print b(4)

void foo(void (*fn)())
{
  fn();
}

void (*)() bar(string word)
{
  struct A {
    static void baz() {
      cout << "Me a de " << word << " nuttah" << endl;
    }
  };
  return &A::baz;
}

int main()
{
  foo(bar("original")); // выводит Me a de original nuttah
  foo(bar("mad")); // выводит Me a de mad nuttah
}

def foo(f):
    f()

def bar(w):
    def l():
        print "Me a de", w, "nuttah"
    return l

foo(bar("original"))
foo(bar("mad"))

VD>Мне, например, Шарп заменяет и Руби, так как на нем программировать так же эффективно, и С++ так как я могу создавать код стольк же быстрый как и на С++. При этом я не жертвую ни статической типизацией, ни удобством работы. Плюс я имею отличные средства разработки (комплит ворд, рефакторин, отладчик, профайлеры и т.п.). Ты же все время рассказывашь о крутизне Руби, но пишеш реальный код на С++.

Для текущего проекта смена языка реализации нереальна, это и так всем понятно. Для новых проектов это вполне может иметь смысл, почему нет? Это первое, и второе — кто-то заставляет сразу писать на незнакомой платформе критичный проект? Боже упаси. Стратегия перехода на новую платформу предполагает существенно более сложный сценарий, и это, как я думал, не является предметом дискуссии.

Но если говорить о смене платформы — то и это вполне возможно. Только начинать надо с микропрототипов для proof of the concept. А потом (если все в порядке) с маленьких некритичных проектов. Потом (если итоги их внедрения и экстплуатации положительны), внедрять новую платформу шире, с учетом накопленного опыта. Только осторожно, никакой спешки, риски надо контроллировать.

VD>Хм... Это тебя колбасит.

ЗХ>Понял, что меня в этом варианте смущает Слишком много "новых ключевых слов". По сути, это отдельный 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);
}

D>if (area.containsPoint(mouseLocation) {
D> ... // Что-нить сделаем
D>}
D>

D>class Area {
D>    virtual bool containsPoint(Point p) = 0;
D>class Rectangle : public Area {
D>  virtual bool containsPoint(Point& p) {
D>

Area      * Point -> bool
Rectangle * Point -> bool

T * Point -> bool

D>template<class T>
D>T sum(iterator<T> begin, iterator<T> end) {
D>    T result = T();
D>  while (begin != end) {
D>        result = result + *begin;
D>        begin++;
D>    }
D>    return result;
D>}
D>

iterator<T> * iterator<T> -> T

D>class Vector2D {
D>    Vector2D operator+(Vector2D& v) { return Vector2D(x+v.x, y+v.y); }
D>}
D>

D>>>template<int N> int factorial() {
D>>>    return N*factorial<N-1>();
D>>>}
D>>>int factorial<0>() {
D>>>    return 1;
D>>>}
D>>>

D>int factorial<int>();
D>

D>int factorial<0>() { return 1; }
D>int factorial<1>() { return 1; }
D>int factorial<2>() { return 2; }
D>....
D>int factorial<12>() { return 479001600; } // Вроде это последний какой в 32 бита влезет

D>template<int N>
D>int factorial() {
D>    error "int overflow or negative";
D>}
D>

void -> int

template<class T> T fsnc();

template <> int    fsnc<int>()    { return 1; }
template <> double fsnc<double>() { return 1.0; }
template <> char*  fsnc<char*>()  { return "1"; }
...

void -> int
void -> double
void -> char*

D>int f = factorial<10>();
D>

int f1 = factorial<1>();
int f2 = factorial<2>();
int f3 = factorial<3>();
int f4 = factorial<4>();

int f1 = factorial1();
int f2 = factorial2();
int f3 = factorial3();
int f4 = factorial4();

template<int i> int func();

template<> int func<1>() { return 1; }
template<> int func<2>() { return 2; }
template<> int func<3>() { return 3; }
template<> int func<4>() { return 4; }
template<> int func<5>() { return 5; }

int func1() { return 1; }
int func2() { return 2; }
int func3() { return 3; }
int func4() { return 4; }
int func5() { return 5; }

var(occur)[_1]++ //occur[_1]++

E>Ну что, Влад, помучать тебя длинными исходниками?

E>typedef std::map< int, int > tmp_map_t;
E>typedef std::map< int, std::string > result_map_t;

E>struct selector_t
E>    {
E>        tmp_map_t & m_tmp;
E>        selector_t( tmp_map_t & tmp ) : m_tmp( tmp ) {}

E>        void operator()( int x ) { if( x < 7 ) m_tmp[ x ]++; }
E>    };

E>result_map_t::value_type
E>transformer( const tmp_map_t::value_type & v )
E>    {
E>        char sz[ 16 ];
E>        std::sprintf( sz, "%d", v.second );

E>        return result_map_t::value_type( v.first, std::string( "occurencies: " ) + sz );
E>    }

E>int
E>main()
E>    {
E>        int array[] = { 1,2,3,2,4,5,7,6,7,2 };

E>        tmp_map_t tmp;
E>        std::for_each( array, array + sizeof( array ) / sizeof( array[ 0 ] ), selector_t( tmp ) );

E>        result_map_t r;
E>        std::transform( tmp.begin(), tmp.end(), std::inserter( r, r.begin() ), transformer );

E>        for( result_map_t::iterator it = r.begin(), it_end = r.end(); it != it_end; ++it )
E>            std::cout << it->first << " " << it->second << std::endl;
E>    }
E>

int a[] = {1, 2, 3, 2, 4, 5, 7, 6, 7, 2};
typedef map<int, int> map_t;
typedef map_t::value_type val_t;
map_t occur;

for_each(begin(a), end(a),
        if_(_1 < 7) [ bind(&map_t::operator[], &occur, _1)++ ]);

for_each(begin(occur), end(occur),
        cout << bind(&val_t::first, _1) << ":" << bind(&val_t::second, _1) << "\n");

E>Ну, а если у тебя хватило терпения дочитать до сюда, то бонус: решение на Ruby

E>array = [ 1,2,3,2,4,5,7,6,7,2 ]

E>y = array.
E>    select { |x| x < 7 }.
E>    inject( {} ) { |m, x| m[ x ] = m.fetch( x, 0 ) + 1; m }.
E>    sort.
E>    collect { |z| { z[ 0 ], "Occurencies: #{z[1]}" } }

E>y.each { |v| p v }
E>

E>Мои решения работают и под Windows и под Linux. А твои?

class Test < AsyncBase

    # Для объявления асинхронного метода используем async вместо def.
    async :hello do
        puts "hello"
    end
end

t = Test.new
t.hello

hello intercepted
hello

class AsyncBase
    def self.async( method, &blk )
        define_method method, &blk
        class_eval <<-EOS
            alias :pre_async_#{method} :#{method}
            def #{method}
                puts "#{method} intercepted"
                pre_async_#{method}
            end
        EOS
    end
end

#include "stdafx.h"
#include <tut/tut.h>

using tut::ensure;

struct string_data {};

typedef tut::test_group<string_data> TestString;
typedef TestString::object object;
TestString test_storage_group("string_tests");

template<> template<> void object::test<1>()
{
    //Test code
}

template<> template<> void object::test<2>()
{
    //Test code 2
}

...

#include "stdafx.h"
#include <tut/tut.h>
#include <tut/tut_reporter.h>
#include <iostream>
#include <time.h>
#include <crtdbg.h>

tut::test_runner_singleton runner;

int main(int argc,const char* argv[])
{
#ifdef _DEBUG
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_CHECK_ALWAYS_DF|
        _CRTDBG_LEAK_CHECK_DF);
#endif
    tut::reporter visi;
    tut::runner.get().set_callback(&visi);
    tut::runner.get().run_tests();
}

VD>Но мы то про него в основном речь ведем! Ты же утверждашь, что именно он от С++ произошел.

Так вот, имхо, Java/C# стали всего лишь дальнейшей эволюцией C++ времен 1990-1992 годов, а то и еще более раннего периода.

VD>Издевашся?

VD>И вообще, откровенно говоря использование всех этих предрассудков в качестве аргументации и постоянное переключение с руби на С++ уже надоело. Ты себя уже убдил. Явно аргументы и информация тебе не нужна. Если что еще раз переключишся с С++ на Руби.

А использование байт-кода и виртуальной машины в Java позволило применять такие механизмы, как динамическая загрузка кода и интанцирование объектов по имени класса.

E>>Нет, я надеюсь, что у Ruby круг пользователей будет раза в три пошире, чем у Smalltalk-а.

VD>Круче Smalltalk только D и Оберон :

E>a.inject { |s, v| s += v }
E>

int sum = 0;
foreach(int a in array)
  sum += a;

for (int i = 0; i < array.length && i < maxlen; i++) 
  sum += array[i];

fun sum(head::tail) = sum(head) + tail | sum([]) = 0.

int sum = 0; 
for (int i = array.length-1; i >=0; i--)
  sum += array[i];

foreach(/*int*/ a in /*(IEnumerable<int>)*/array)
  sum+=a;

S>foreach(/*int*/ a in /*(IEnumerable<int>)*/array)
S>  sum+=a;
S>

var sum = 0;

foreach(var a in array)
    sum += a;

var sum = 0L;

var sum = 0.0;

_>sum := 0.
_>array do: [:elem | sum := sum + elem].
_>

        public delegate R Collector<R, T>(R current, T item);
        
        public static R Collect<R, T>(IEnumerable<T> collection, Collector<R, T> collector, R initialValue)
        {
            R current = initialValue;
            foreach (T item in collection)
                current = collector(current, item);
            return current;
        }

> void f();
>

> void f(...);
>

void f(...);