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

Rectangle intersection = Rectangle.PLANE; // Забудем о пересечении пустого набора, не о ней речь...
intersection = each(array).intersect(intersection);   // Для каждого элемента вызвать intersect с параметром, текущее значение intersection

int evenSum = 0;
evenSum += eventOrZero(each(array));

int evenOrZero(int x) {
    return x % 2 == 0 ? x : 0;
}

int addEven(int sum, int x) {
    return sum + (x % 2 == 0 ? x : 0);
}

int evenSum = for_each(array.begin, array.end, addEven);

int evenSum = ((sum, x) => sum + (x % 2 == 0 ? x : 0)) (0, each(array));

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

class Area {
    virtual bool containsPoint(Point p) = 0;
}

class Rectangle : public Area {
  virtual bool containsPoint(Point& p) {
      return (x >= p.x) && ...;
    }
}

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

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

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

int factorial<int>();

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

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

int f = factorial<10>();

class deliver_sm_t
    {
    public :
        const std::string & service_type() const;

        const oess_1::uchar_t & source_addr_ton() const;
        const oess_1::uchar_t & source_addr_npi() const;
        const std::string & source_addr() const;

        const oess_1::uchar_t    & dest_addr_ton() const;
        const oess_1::uchar_t    & dest_addr_npi() const;
        const std::string & dest_addr() const;

        const oess_1::uchar_t & esm_class() const;

        const oess_1::uchar_t & protocol_id() const;

        const oess_1::uchar_t & priority_flag() const;

        const std::string & schedule_delivery_time() const;

        const std::string & validity_period() const;

        const oess_1::uchar_t & registered_delivery() const;

        const oess_1::uchar_t & replace_if_present_flag() const;

        const oess_1::uchar_t & data_coding() const;

        const oess_1::uchar_t & sm_default_msg_id() const;

        const std::string &    short_message() const;
    };

class data_sm_t
    {
    public :
        const std::string & service_type() const;

        const oess_1::uchar_t & source_addr_ton() const;
        const oess_1::uchar_t & source_addr_npi() const;
        const std::string & source_addr() const;

        const oess_1::uchar_t    &    dest_addr_ton() const;
        const oess_1::uchar_t    & dest_addr_npi() const;
        const std::string & dest_addr() const;

        const oess_1::uchar_t & esm_class() const;

        const oess_1::uchar_t & registered_delivery() const;

        const oess_1::uchar_t & data_coding() const;
    };

1.1.4 stable rev. 510

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

D>Rectangle intersection = Rectangle.PLANE; // Забудем о пересечении пустого набора, не о ней речь...
D>intersection = each(array).intersect(intersection);   // Для каждого элемента вызвать intersect с параметром, текущее значение intersection
D>

D>int evenSum = 0;
D>evenSum += eventOrZero(each(array));

D>int evenOrZero(int x) {
D>    return x % 2 == 0 ? x : 0;
D>}
D>

D>int evenSum = ((sum, x) => sum + (x % 2 == 0 ? x : 0)) (0, each(array));
D>

int evenSum = 0;
evenSum += select(array, _1 % 2 == 0);

int complexSum = 0;
complexSum += select(array, _1 % 2 == 0);
complexSum *= select(array, _1 % 2 != 0);

> void f();
>

> void f(...);
>

void f(...);

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; }

class Big_Calculator
    {
    public :
        async some_calculation();
    };
    
Big_Calculator c;
c.some_calculation(); // fire and forget.

начальное состояние "wait_b_c";
в состоянии "wait_b_c":
    если поступает сообщение b:
        сохраняем сообщение b;
        переходим в состояние "wait_c";
    если поступает сообщение c:
        сохраняем сообщение c;
        переходим в состояние "wait_b";
в состоянии "wait_c":
    если поступает сообщение с:
        отсылаем объекту D сообщения b, c;
        завершаем работу;
в состоянии "wait_b":
    если поступает сообщение b:
        отсылаем объекту D сообщения b, c;
        завершаем работу;

создаем монитор Mi;
отсылаем сообщение ai объектам B, C;

ожидаем сообщения ai;
обрабатываем сообщение ai;
отсылаем сообщение bi (но так, чтобы его получил монитор Mi);

ожидаем сообщения ai;
обрабатываем сообщение ai;
отсылаем сообщение ci (но так, чтобы его получил монитор Mi);

class pdu_with_source_addr_t
    {
    public:
        virtual std::string source_addr() const = 0;
    };
class deliver_sm_source_addr_t
    : public pdu_with_source_addr_t
    {
    public:
        virtual std::string source_addr() const { return pdu_.source_addr(); }
        ...
    };
class data_sm_source_addr_t
    : public pdu_with_source_addr_t
    {
    public:
        virtual std::string source_addr() const { return pdu_.source_addr(); }
        ...
    };
    
void handle_source_addr_from_pdu( const pdu_with_source_addr_t & pdu )
    { ... pdu.source_addr(); ... }

template< class Pdu >
void handle_source_addr_from_pdu( const Pdu & pdu )
    { ... pdu.source_addr(); ... }

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

    aReceiver someMessage

  aReceiver meta someMessage