====== Constrain/Necessity =======

Ein Constrain definiert eine Fähigkeit oder eine Unfähigkeit einer Funktion, einer Klasse oder eines Namensraums. Ein Constrain wird in den unterliegenden Scope vererbt. Ein Constrain selbst kann Teil eines Namensraums sein.
Funktionen mit contrains können überladen werden und werden durch das constrain unterschieden. Ähnlich const.
Eine Funktion mit einem Contrain kann nur Funktionen und Methoden aufrufen, die den gleichen Constrain beinhalten.
<code>
noheap is constrain;
Genesys::interpretable is contrain;  // Contrain innerhalb eines gesetzten Namensraums

add is code( int a, int b ) noheap
{
  return a+b; 
}
</code>

Die Funktion add kann also von Funktionen gerufen werden, die verlangen, dass die gerufene Funktion sich an das Constrain "NoHeap" hält, also keinen Hauptspeicher verlangt.

====== Necessity ======

Ein Necessity ist gewissermaßen die Umkehrung eines constrains und wird an rufende Funktionen vererbt.

<code>
usesheap is necessity;
noheap is constrain = !usesheap;

new is operator( s is size ) usesheap as neutral ptr :=
  return malloc( s );

createObject() as Object :=
  return new Object;

main noheap :=
{
  createObject();
}

</code>

Die Funktion createObject bekommt von operator new das Necessity "usesheap" verpasst, weil //new// operator new ruft. Die Funktion main ruft createObject, die das Necessity "usesheap" trägt. Das Constrain noheap bei main verlangt aber, dass main keinen Heap-Speicher verwenden darf. Also ist das Programm so nicht kompilierbar.

Der Entwickler kann nun die Funktion createObject mit dem Constrain noheap überladen, die von "main noheap" bevorzugt gerufen wird.
<code>
createObject() as Object noheap :=
  return construct(nonheapMemory) Object;
<code>



Das ganze gibt's auch schonmal mit einer Erweiterung für const, die ich attribute genannt habe: [[notes:attr:attribute]]