Variablen sind in Aleph vorhanden. Im Gegensatz zu anderen Sprachen dienen sie aber nicht nur zur Aufnahme von Zwischenergebnissen oder als Referenzen für Objekte. Sie bieten sehr viel mehr.
Auch bei Aleph können Variablen die Programmierung erleichtern. Die Möglichkeit eigene Bezeichnungen für Objekte zu verwenden steht dabei häufig im Vordergrund. Damit wird zwar der Code umfangreicher, die Pflege aber erleichtert.
Das Java-Programm "xyz.java" dient als Grundlage. Es sollte als ".class"-Datei vorhanden sein (sonst einfach mit "javac xyz.java" erstellen).
public class xyz {
static public int Cvalue = -11; // class- FIELD
public int Ivalue = -99; // instance-FIELD
public void test() { // instance-METHOD
System.out.println( "Funktioniert!");
}
public int add( int a, int b) { // instance-METHOD
return a+b;
}
}
|
Wird ein Objekt häufig benutzt, so wird es über eine Variable referenziert. In den "gängigen" Sprachen muss die Deklaration dieser Variablen die Klasse des Objekts enthalten.
In Aleph nicht. Es genügt die Variable als solche zu deklarieren. Variablen in Aleph sind nicht an Typen gebunden. So werden mit
"Class" variable "Instance" variable |
die beiden Variablen Class und Instance bereitgestellt. In sie werden nun mit der Klasse des Programms xyz und einer Instanz dieser Klasse "gespeichert" (dieser Begriff ist eigentlich falsch, eine Korrektur benötigt aber noch ein paar Informationen).
"xyz" classify "Class" is Class instantiate "Instance" is |
Die "Speicherung" in die Variablen erfolgt über die Nennung des Namens und die Anweisung "is". Letztere ist durchaus wörtlich zu nehmen, denn in Aleph sind Variablen etwas, sie enthalten nichts. Die Variable Class ist die Klasse xyz und die Variable Instance ist eine Instanz davon.
Jedenfalls ist jetzt der Zugriff auf die Inhalte von xyz (Klasse oder Instanz) dem Vorgehen in "normalen" Sprachen ähnlich.
Die Inhalte xyz können über field und/oder method als Aleph-Objekte bereit gestellt werden. Referenzen über Variablen sind eigentlich überflüssig. Aber es geht hier um die Verwendung von Variablen als Referenz.
Class "Cvalue" field cField
Instance "Ivalue" field iField
Instance "add {int int}" method plus
|
Das Command field greift hier über die Variable Class wird auf die Java- Klassenvariable Cvalue zu und erzeugt das field namens cField. Die Eingabe
cfield .
ergibt jetzt -11 im Protokoll-Fenster (Konsole). Auf die gleiche Weise wird das field namens Ivalue bereitgestellt, wobei es sich jetzt aber um eine Java-Instanzvariable handelt. Als Letztes wird noch die Java-Methode add als method namens plus erzeugt. so ergibt denn auch die Eingabe von
iField cField plus .
das Ergebnis -110.
So erfolgt auch in den normalen Sprachen der Zugriff auf Komponenten in Objekten und Klassen. Es werden natürlich Operatoren zur Verkettung benötigt, so dass sich Konstruktionen wie
Class.Cvalue
Instance->Ivalue
ergeben können. Wichtig ist die Verwendung einer Variablen als Referenz auf das Objekt (Speicherbereich) oder die Klasse (Struktur).
Variablen sind zu Allem fähig. Eine Erkenntnis die C-Programmierer in Form von "side effects" leidvoll erfahren. In Aleph meint "fähig" jedoch etwas Anderes. Variablen können durchaus Funktionalität haben.
"X" variable "cField" find drop "X" is "Y" variable "iField" find drop "Y" is "Z" variable "plus" find drop "Z" is X Y Z . |
Die Variablen X, Y und Z werden über "... find drop is" zu fields oder methods. Damit ist klar, dass Variablen tatsächlich etwas sind und keinesfalls nur etwas enthalten. Es besteht jetzt kein Unterschied mehr zwischen
X Y plus .
cField iField Z .
In der Datei "variables.vvm" sind noch weitere Informationen zu Variablen enthalten. Auch mögliche Kombinationen von "call by value" und "call by reference" werden dargelegt. Weil Aleph keine lokalen Variablen im herkömmlichen Sinn hat, könnten sich Probleme beim löschen der "Inhalte" ergeben.
Variablen erhalten ihre Bedeutung (Inhalt) durch die Anweisung "is". Damit wird ausgesagt, dass Variablen eben nicht etwas enthalten – dann wäre "set" oder "store" die richtige Anweisung – sondern eben etwas sind.
Im letzten Beispiel ist die Variable "X" das field "cField". Bei "normalen" Variablen würde also die Zuweisung von 123 an "X" den Speicherbereich von "cField" in 123 ändern. Damit wäre "X" eine Referenzvariable. Weil "X" ja ein field ist, sollte eine Zuweisung auch den Inhalt des fields ändern. Aber "is" ist keine Zuweisung sondern eine Änderung der Bedeutung. Um dem Inhalt des fields "X" etwas zuzuweisen muss daher auch die Anweisung "set" benutzt werden. "X" ist ein field! Mit "is" wird "X" etwas anderes, womit "X" natürlich auch 123 werden kann und damit natürlich kein field mehr ist.
Wenn Variablen etwas sind, wie können sie geleert werden? Und was sind dann leere Variablen?
Generell wird bei Aleph-Variablen unterschieden wischen gebundenen und solchen ohne Bindung – ungebundenen. Diese Fähigkeit drängt Parallelen zum Lambda Kalkül, LISP und Prolog auf. Tatsächlich hat Aleph derartige Fähigkeiten, wie das Beispiel "lists.vvm" und die Dokumentation zu diesem Thema zeigen.
Variablen sind den Commands ähnlich. Commands haben einen Namen und eine Liste mit den compilierten Anweisungen (Symbole haben hier wenigstens irgendwelche Objekte). Diese Liste kann leer sein, trotzdem ist ein derartiges Objekt vorhanden.
Bei Variablen kann dieses Objekt fehlen; sie ist dann ungebunden. In jedem anderen Fall ist eine Variable gebunden. Unmittelbar nach ihrer Erzeugung sind Variablen ungebunden. Sie enthalten also weniger als eine leere Anweisung.
Wird eine ungebundene Variable benutzt, passiert einfach nichts. Ein leeres Command wird zumindest betreten, um gleich wieder verlassen zu werden, eine ungebundene Variable bewirkt noch nicht einmal das.
Es gibt vier Anweisungen für Variablen:
variable
erzeugt eine neue, ungebundene Variable.
is
bindet eine Variable an das Objekt auf dem Stack,
free
befreit eine Variable von ihrer Bindung.
forget
entfernt den Namen der Variablen aus dem Wörterbuch.