for (initialization_statement; boolean_invariant_condition; variant_statement) 
  loop_body

{
  initialization_statement;
  while (boolean_invariant_condition) 
  {
    {
      loop_body;
    }
    variant_statement;
  }
}

for iterator_type iterator_name in iterable_expression {
  loop_body
}

for int i in range(0, 100) { 
  write_int(i); write_char('\n'); 
}

for char c in "hello" {
  write_char(c);
}

for object o in (42, 3.14, 'q') {
  write_object(o);
}

I am happy with this so far, but I want to go further and generalize the notion so that programmers can define new constructs like for-loops. For instance I would like to be able to iterate over the collection in an non-deterministic order. This is important for optimization on concurrent machines.

The best way to generalize this I can think of is to use closures. This way for-loops and programmer defined constructs can map to anonymous functions. The problem right now is trying to figure out an elegant and efficient way to implement closures in HeronFront. In order to implement closures in C++, It seems I have to generate a context data type and pass it to the anonymous function.

for x in a:
  print x, len(x)

   let
      fun loop x =
         if isEndOfLoop x then
            ()
         else
            loop (doSomethingWith x)
   in
      loop initialX
   end

   begin
      x = initialX
      while not (isEndOfLoop x) do
         doSomethingWith x
      done
   end

   fun op to (a, b) f =
       let
          fun loop a =
             if a < b then
                (f a; loop (a+1))
             else
                ()
       in
          loop a
       end

   (lo to hi) (fn x => ...)