void for( void i_init(); void i_cond(); void i_iterate() ) arg( void i_body() )
{


}

void if( bool i_cond() ) arg( void i_then() ) else arg( void i_else() )
{
}

void if( bool i_cond() ) arg( void i_then() )
{
}

gear( X ) IntRange(int a,int b,name i=i)
 {
  for(int i=a; i<=b ;i++) X;
 }
 
gear( Odd else Even ) IntStrangeRange(int a,int b,name i=i)
 {
  IntRange(a,b,i) if( i&1 ) Odd; else Even;
 }

/* main() */ 

int main()
 {
  int s=0;
  
  IntRange(1,100) s+=i;
  
  int odd=0;
  int even=0;
  
  IntStrangeRange(1,100) odd+=i; else even+=i;
  
  return 0;
 }

foreach (SomeType value in SomeCollection)
    SomeCollection.Remove(value);

enum __for{ __for_continue, __for_break };
void continue() { throw __for_continue; }
void break() { throw __for_break; }

V>Скажу так, что мне приходится регулярно модифицировать содержимое контейнеров в своих задачах на дотнете, и я удивлен — неужели ты используешь контейнеры в основном только для того, чтобы однажды заполнить и затем ничего с ним не делать?

ArrayList newList = new ArrayList(oldList);

G>void for( void i_init(); void i_cond(); void i_iterate() ) arg( void i_body() )
G>{

G>}
G>

void for( open void i_init(); void i_cond(); void i_iterate() ) arg( void i_body() )
{

}

void for( open void i_init(); bool i_cond(); void i_iterate() ) arg( void i_body() )
{
}

...
void myFun()
{
   std::set< int > mySet;
   void someFunc() { int x = 1; }
   void body() { mySet.insert( x ) }
   for( someFunc; x != n; { x++; doSomethingStupid( x, mySet ) } ) body;
}
...

forth
: wsparse 32 parse ;
: lnparse 10 parse ;
macro
: f: wsparse find compile ;
: m: wsparse mfind compile ;
: ['] wsparse find m: literal ;
: >r $ad50 2, ;
: r> $8904ee83 , $5806 2, ;
: dup $8904ee83 , $06 1, ;
: drop $ad 1, ;
: swap $0687 2, ;
: nip $04c683 3, ;
: and $0623 2, m: nip ;
: or $060b 2, m: nip ;
: xor $0633 2, m: nip ;
: >> $d3adc189 , $e8 1, ;
: << $d3adc189 , $e0 1, ;
: not -1 m: literal m: xor ;
: @ $008b 2, ;
: ! $89adc289 , $ad02 2, ;
: c@ m: @ $ff m: literal m: and ;
: c! $c289 2, m: drop $0288 2, m: drop ;
: + $ad0601 3, ;
: - $ad0629 3, ;
: * $26f7 2, m: nip ;
: negate -1 m: literal m: * ;
: / $99adc389 , $fbf7 2, ;
: mod m: / $d089 2, ;
: here h0 m: literal m: @ ;
: : create here -5 + h0 ! ;
forth
: dup dup ;
: drop drop ;
: execute >r ;
: swap swap ;
: rot >r swap r> swap ;
: -rot rot rot ;
: tuck swap : over swap dup -rot ;
: 2dup over over ;
: 2drop drop drop ;
: nip nip ;
: and and ;
: or or ;
: xor xor ;
: >> >> ;
: << << ;
: not not ;
: @ @ ;
: ! ! ;
: c@ c@ ;
: c! c! ;
: + + ;
: * * ;
: negate negate ;
: - - ;
: / / ;
: mod mod ;
: here here ;
: ( ') parse drop drop ;
: | lnparse drop drop ;
: create: wsparse entry ;
: exit, $c3 1, ;
macro
: ( ') parse 2drop ;
: | lnparse 2drop ;
: 1+ $40 1, ;
: 1- $48 1, ;
: repeat here ;
: again compile ;
: next m: r> : until $48 1, $c009 2, $850f 2, here - 4 - , m: drop ;
: for here m: >r ; 
: r m: r> ['] dup compile m: >r ;
: if $c009 2, m: drop $840f 2, here 0 , ;
: (if) $063b 2, m: drop m: drop $0f 1, 1, here 0 , ;
: <>if $84 m: (if) ;
: =if $85 m: (if) ;
: <if $8e m: (if) ;
: >if $8d m: (if) ;
: ?if $063b 2, $820f 2, here 0 , ;
: then dup here swap - 4 - swap ! ;
: else $e9 1, here 0 , swap dup here swap - 4 - swap ! ;
: cell+ 4 m: literal m: + ;
: cell- 4 m: literal m: - ;
: cells 4 m: literal m: * ;
forth
: last> last @ ;
: >last last ! ;
: variable 0 : variable, create , ;
: literal, m: literal ;
: const create: literal, exit, ;
: hex 16 base ! ;
: decimal 10 base ! ;
: binary 2 base ! ;
: octal 8 base ! ;
: /mod over over / -rot mod ;
: pad here 1024 + ;
: allot here + h0 ! ;
: align 0 here 4 mod allot ;
: cell+ cell+ ;
: cell- cell- ;
: cells cells ;
: 2over >r >r 2dup r> -rot r> -rot ;
: 2swap rot >r rot r> ;
: ' wsparse find ;
: alias create: last @ cell+ ! ;
: fill swap repeat >r swap 2dup c! 1+ swap r> until 2drop ;
: 0; dup 0 =if r> 2drop ;; then ;
: >pad dup >r pad swap cmove pad r> ;
: zt-make dup >r here swap cmove here r> dup allot 0 1, 1+ ;
: zt-free negate allot ;
: cr 10 emit ;
: space 32 emit ;
: . (.) space ;
: u. (u.) space ;
: tab 9 emit ;
: del 8 emit ;
: clear 25 repeat cr until ;
: type dup 0 <>if repeat swap dup c@ emit 1+ swap until drop ;; then 2drop ;
: word.name dup 8 + dup 1+ swap c@ ;
: words last repeat @ 0; word.name type space again ;
: last.name last> word.name type ;

variable st0
: " '" parse >pad ;
: ." " type ;
: $, st0 @ 2dup m: literal m: literal 2dup + st0 ! swap cmove ;

macro
: s" " $, ;
forth
here st0 ! 4096 allot
: version# 0 0 8 ;
: .version s" ref " type
  version# rot . del '. emit swap . del '. emit . ;

.version
" (c)2005 Alexey Abramov :: djkaries at list.ru" type cr cr

forth
: @var wsparse find 5 + ;
macro
: mc: m: ['] ['] compile compile ;
: call $d0ff 2, ;
: to @var $a3 1, , m: drop ;
: addr @var $fc4689 3, $fc768d 3, $b8 1, , ;
: prior last @ >r last @ @ last ! wsparse find compile r> last ! ;

forth
| : cmove 3 - repeat >r 2dup swap @ swap ! 1+ >r 1+ r> r> until 2drop ;
: var 0 : var, create: literal, exit, ;
: vars: repeat var until ;
: to @var ! ;
: ns: create: last> literal, last> swap dup @ >last exit, ;
: ns; last> swap ! >last ;
: stack cells allot here var, ;

32 stack {@}
: { {@} cell- to {@} last> {@} ! ;
: } {@} @ >last {@} cell+ to {@} ;

{
  var nnn
  : {:}
    {@} @
    last>
    dup @ >last
    dup {@} @ swap !
    {@} !
    last
    repeat
      dup to nnn
      @
      2dup =if
        2drop {@} @ nnn !
        ;;
      then
    again
  ; {:}
}

: z" " zt-make drop ;

: as last> dup cell+ @ swap @ >last create last> cell+ ! ;
: late: here wsparse ] entry last @ cell+ ! ;

macro
: z" " zt-make drop ;

forth

: import
  create:
  GetProcAddress literal, m: call exit,
;

: stdcall
  create:
  dup if
    dup repeat
      m: >r
    until
  then
  drop
  GetProcAddress literal, m: call exit,
;

: stdcall*
  create:
  dup if
    dup repeat
      m: >r
    until
  then
  drop
  GetProcAddress literal, m: call m: drop exit,
;

: true -1 ;
: false 0 ;

" kernel32.dll" LoadLibraryAs KERNEL32

{
  KERNEL32 " GlobalAlloc" 2 stdcall GlobalAlloc
  KERNEL32 " GlobalFree" 1 stdcall GlobalFree
  : GMEM_FIXED 0 ;
  
  : getmem GMEM_FIXED swap GlobalAlloc ; {:}
  : freemem GlobalFree drop ; {:}
}

{
  KERNEL32 " CreateFileA" 7 stdcall CreateFile
  KERNEL32 " ReadFile" 5 stdcall ReadFile
  KERNEL32 " WriteFile" 5 stdcall WriteFile
  KERNEL32 " SetFilePointer" 4 stdcall SeekFile
  KERNEL32 " CloseHandle" 1 stdcall CloseHandle
  KERNEL32 " GetFileSize" 2 stdcall GetFileSize

  : CodeSize getmem h0 ! ; {:}

  : GENERIC_READ $80000000 ;
  : GENERIC_WRITE $40000000 ;

  : CREATE_NEW 1 ;
  : CREATE_ALWAYS 2 ;
  : OPEN_EXISTING 3 ;
  : OPEN_ALWAYS 4 ;
  : TRUNCATE_EXISTING 5 ;

  4 vars: SrcFile SrcFileSize SrcFileSizeReaded SrcFileData

  var uses_stored_voc
  var uses_voc
  var uses_level
  
  : used
    s" Used files: " type
    last> to uses_stored_voc
    uses_voc >last
    words cr
    uses_stored_voc >last
  ; {:}

  : terminate
    s" Program terminated." type cr
    bye
  ;

  : uses
    wsparse 2dup
    last> to uses_stored_voc
    uses_voc >last
    find ?if
      uses_stored_voc >last
      drop
      s" Warning: file '" type type s" ' is already used." type cr
      ;;
    then
    2dup entry
    uses_level 0 >if
      uses_level repeat
        32 emit
      until
    then
    s" uses " type type
    last> to uses_voc
    uses_stored_voc >last
    zt-make drop GENERIC_READ 0 0 OPEN_EXISTING 0 0 CreateFile to SrcFile

    SrcFile -1 =if
      cr s" File not found." type cr
      terminate
    then
    SrcFile 0 GetFileSize to SrcFileSize
    SrcFileSize 0 >if
      SrcFileSize getmem to SrcFileData
      SrcFile SrcFileData SrcFileSize addr SrcFileSizeReaded 0 ReadFile drop
    then
    SrcFile CloseHandle drop
    SrcFileSize 0 >if
      s"  -> " type SrcFileSize (u.) s"  bytes" type cr
      SrcFileData >r
      uses_level 1+ to uses_level
      SrcFileData SrcFileSize eval
      uses_level 1- to uses_level
      r> to SrcFileData
      SrcFileData freemem
    then
  ; {:}
}

uses main.f

> Хе-хе . Если "язык" — это С++, то все довольно просто. Поехали: <...>

enum A { a };
enum B { b };

void foo(A);
void foo(B);

template< class T, class F >
void bar( T t, F f )
{
   f( t );
}

void g()
{
   bar( a, foo );
}

>> Хе-хе . Если "язык" — это С++, то все довольно просто. Поехали: <...>

vector<int> v;
for_each(v.begin, v.end())
{
   // lambda function
}

int b;
vector<int> v;
for_each(v.begin(), v.end(); void(int a))
{
    cout << a + b << endl;
}

struct __closure {
    int & b_;
    __closure(int & b) : b_(b) {}
    void operator()(int a) {
        cout << a << b_ << endl;
    }
};

int b;
vector<int> v;
for_each(v.begin(), v.end(), __closure(b));

>> Хе-хе . Если "язык" — это С++, то все довольно просто. Поехали: <...>

ПК>enum A { a };
ПК>enum B { b };

ПК>void foo(A);
ПК>void foo(B);

ПК>template< class T, class F >
ПК>void bar( T t, F f )
ПК>{
ПК>   f( t );
ПК>}

ПК>void g()
ПК>{
ПК>   bar( a, foo );
ПК>}
ПК>

bar:: a (a -> b) -> b
bar t f = f t

void IntRange(int a, int b, name ValueName = i) 
gear void X(int ValueName);
{
    for(int i=a; i<=b ;i++) 
        X(i);
}

void IntStrangeRange(int a, int b, name ValueName = i) 
gear(odd)  void Odd(int ValueName);
gear(even) void Even(int ValueName);
{
    IntRange(a, b, i) 
        if ( i & 1 ) 
            Odd(i);
        else 
            Even(i);
}

template<class Iter>
Iter find_if(Iter begin, Iter end, name ValueName = i)
gear bool Condition(Iter ValueName);
{
    for (; begin != end; ++begin)
        if (Condition(begin))
            return begin;
    return end;
}

int main()
{
    int s = 0;

    IntRange(1, 100)
        s += i;

    int odd_sum = 0;
    int even_sum = 0;

    IntStrangeRange(1, 100)
    odd
        odd_sum += i;
    even
        even_sum += i;

    std::vector<int> v;
    IntRange(1, 100)
        v.push_back(i);

    std::vector<int> iter = find_if(v.begin(), v.end())
    {
        return *i % 37 == 0;
    }

    return 0;
}