====== enhance ======

Enhance erweitert die Funktionalität von Objekten, kann aber keine zusätzlichen Member einführen.

<code cpp>
Person contains
{
  Vorname, Nachname as String;
  
  construct( Vorname, Nachname );
};
// Klasse fertig.
</code cpp>

enhance kann nun Person erweitern:

<code cpp>
enhance Person
{
  operator $ -> string : Vorname + " " + Nachname;
  SayHello is code := print "Hello, ", Vorname;
};
</code>

Nun können Personen auch diese Funktionen aufrufen:

<code>
Person p( "Sascha", "Atrops" );
p.SayHello();

print p$;
</code>


====== enhance generisch ======

enhance kann auch generisch verwendet werden und so eine unbestimmte Menge an Klassen erweitern, die gewisse Mindestanforderungen erfüllen.

<code>
Debugger is enhance( T( contains $ as string ) )
{ 
  DebugOut is code :=
  {
    print "DebugOut for Type %s: %s\n" % (T$, this$ );
  }
};
</code>
Hiermit wird jeder Klasse (genannt T), die über den Operator $ verfügt eine Methode 'Debugger::DebugOut' untergejubelt, die direkt im Namensraum liegt, also über p.DebugOut() angesprochen werden kann. Sollten mehrere enhancements vorliegen, so kann auch p.Debugger::DebugOut() verwendet werden.


<code>
Debugger is enhance( T is type contains $ as string, U is type contains $ as string 
                                                               contains Vorname as string )
{ 
  DebugOut is code( person is U ) :=
  {
    print "%s sendet DebugOut for Type %s: %s\n" % (person.Vorname, T$, this$ );
  }
};
</code>

contains kann hier auch ein ganzes Interface benennen, z.B. um die generische Funktion "std::remove_if" zu implementieren, die so allen Iterierbaren Containern zur Verfügung steht.

<code>
Debugger is enhance( T( contains interface Iteratable ) )
{
  removeIf( filter is code( T const & ) -> bool )
  {
    for( x in this )  // for verlangt die Implementation der Operatoren Iterable
    {
      if( filter( x ) )
        this.remove( x );
    }
  }
};
</code>
siehe [[notes:op:iterable]]