Iterable

ist ein Interface, dass aus den Operatoren [first [tail]] und #. [first [tail]] gibt einen Iterator auf das erste Element, wie auf das nachfolgende Element aus (was als Liste verstanden werden darf). # liefert bei einem Container die Anzahl der Elemente Der Iterator muss den ++ Operator implementiert haben.

Iterator(T is type) contains
{
  Next is Iterator(T);
  Value is T ref;
    
  ++ is operator : Next;
};

Iterable( T is type ) contains
{
  operator # as unsigned int                const get mandatory;
  operator [first is Iterator(T) const [_]] const get mandatory;
};


Container is Iterable(int)
          contains
{
  Values is shared int[10]; // per default mit new int[10] aufgerufen
  Size   is unsigned int;
  First  is iteratable(int)
  
  operator #                            const for Iterable(int) get :  Size;           // for Iterable(int) ist eine optionale Angabe, wird ignoriert, wenn die genannte Klasse, dies als mandatory verlangt, entspricht override bei virtual
  operator [first is iterable(int) [_]] const for Iterable(int) set := first = First;  // for Iterable(int) ist eine optionale Angabe
  
  // weitere Überladungen möglich
  operator [first is iterable(int) [tail is iterable(int)] set  // [first [tail]] = list;  // wobei this hier [ []] ist.
  {
    tail =++ first = First;
  }

  operator [first is iterable(int) [tail is iterable(int)] get  // list = [first [tail]];  // wobei this hier [ []] ist.
  {
    first++ = tail;
    First   = first;
    
    Size = 0;
    while( first != null )
    {
      Size++;
      first++;
    }
  }

}

( Es sollte möglich sein von einem array oder list interface zu erben, so dass Klassen, die davon erben mit foreach oder anderen algorithmen (anyof, …) verwendet werden können (siehe auch: five-new-algorithms-to-cpp11-you-should-know-about