Operno

Operno ist eine objektorientierte, dynamische und funktionale Programmiersprache, die von Josef Sniatecki (14. April 1993) gegründet wurde und weiterhin erntwickelt wird. Die Sprache dient zur Erstellung von Skripts, die von einer Anwendung ausgeführt und mittels Objekte angesprochen werden können. Die Objekte werden dabei zur Laufzeit erstellt und Typisiert. Ebenso kann man Objekte zur Laufzeit löschen und wieder neu definieren.

Zu den Sprachelementen gehört OOP, zur Laufzeit modifizierbare Klassen, dynamisch erweiterbare Listen (Containerklasse), vektorielle Operationen für nicht überladene Operatoren, Präprozessor für Makros und Symbole, Kontrollstrukturen (if, switch, while) und erweiterte Iterationsschleifen (for, repeat).

Zur Zeit besizt Operno eine deutsche Dokumentation, eine integrierte Entwicklungsumgebung und eine interaktive Konsole für die ausführung von eingebenen Anweisungen.

Objekte

Jedes Objekt kann eines von drei Typen annehmen:

• Variable
• Funktion
• Gruppe

Variable

Eine Variable kann jeden klassifizierten Wert speichern und diesen zur Laufzeit wiederverwenden und modifizieren. Dabei können direkt Klassenmethoden und Instanz-Objekte mittels einer Variable aufgerufen werden. Die Typisierung erfolgt zur Laufzeit, wodurch man von einer dynamischen Typisierung spricht.

Variants

Eine Variable kann von der Klasse variant sein. Dies ist eine unbestimmte Klasse, wodurch eine Variable vom Typ variant jeden Wert zugewiesen bekommen kann, ohne ein Type-Casting vorzunehmen.

Im folgenden Beispiel sind beide Parameter/Variablen a und b vom Typ variant, da keine Klassen angegeben werden:

sum(a, b){
  return a + b
}

out sum(10, 1)     'Gibt "11" aus
out sum("A", "BC") 'Gibt "ABC" aus

Funktion

Funktionen können in Operno mehrere Parameter erhalten und diese durch einen Block von Anweisungen verarbeiten. Der Rückgabewert kann in seiner Klasse bestimmt und auch unbestimmt sein.

Aufruf

Der Aufruf einer Funktion erfolgt durch das Erwähnen des Funktionsnamens. Werden Parameter verlangt, so gibt man eine Klammer mit Parametern nach dem Funktionsaufruf an:

put hello world(){
  out "Hello world!"
}

sum(a, b) = a + b

put hello world 'Gibt "Hello world!" aus
out sum(1, 10)  'Gibt 11 aus

Currying

Wird keine Parameterliste beim Aufruf angegeben, trotz dem Verlangen von Parametern, so werden überflüssige Parameter der aktuellen Funktion weitergegeben:

put two values(a, b){
  out a
  out b
}
put four values(){
  put two values 'Die ersten zwei Parameter weitergeben
  out "--"
  put two values 'Die letzten zwei Parameter weitergeben
}

put four values(1, 2, 3, 4)

Die Ausgabe:

1
2
--
3
4

Multi-Call

Ein sog. Multi-Call ist ein mehrfacher Aufruf durch das Aneinanderhängen von mehreren Parameterlisten. Die Ergebnisse dieser Aufrufe werden mittels einer Liste/Queue übergeben:

sum(a, b) = a + b

out sum(1, 2)(8, 2)("A", "BC") 'Gibt "[3, 10, ABC]" aus

Gruppe

Eine Gruppe besitzt mehrere Kindobjekte (engl. child objects), die ebenso eine Gruppe sein können, wodurch Verschachtelungen möglich sind. Zugelich können Gruppen auch Klassen sein, indem sie Klassenmethoden (Funktionen) besitzen und bei einer Deklaration einer Variable als Typ/Klasse angegeben werden.

Die Unterobjekte können durch einen zur Laufzeit ausgewerteten String angesprochen werden, ähnlich wie bei JavaScript.

Syntax

Die Syntax von Operno ist stark mit der Art der Ausführung verbunden, da Operno ein Token-Interpreter ist. Somit besteht kaum ein Unterschied zwischen dem ursprünglichen Code und der generierten Tokensequenz. Da die Syntax flexibel ist, was durch Synonyme von Schlüsselwörtern und Symbolen erreicht wird, können Anweisungen in verschiedenen Varianten implementiert werden.

Namensgebung

Namen von Objekten können Sonderzeichen und Leerzeichen beinhalten. Dabei werden Leerzeichen nach dem Parsen entfernt, indem die Namen in die lower-camel-case-Form umgewandelt wird:

'Zwei gleiche Variablen mit Sonderzeichen:
meine größe = 1.84
meineGröße += 0.1

Funktionales Programmieren

Die Kontrollstrukturen if und switch können ebenso wie die Iterationsschleifen for und repeat Werte zurückgeben. Somit können diese Skriptsteuerungen innerhalb einer auszuwertenden Anweisung einbauen, um somit die Auswertung variabler aufzustellen.

Beispiel (x bekommt einen Wert von if zugewiesen):

b = 1
x = if(b == 0)(
  "zero"
)else if(b == 1)(
  "one"
)else(b == 2)(
  "two"
)

Objektorieniertes Programmieren

Jeder Wert besitzt in Operno eine Klasse, die Instanz-Objekte und Klassenmethoden besitzt. Instanz-Objekte können durch ein Backslash ("\") angesprochen und Klassenmethoden durch einen Doppelpunkt aufgerufen werden. Zusätzlich besitzt jede Klasse Methoden, die automatisch zu bestimmten Ereignissen (z.B. der Konstruktor) aufgerufen werden.

Beispiel:

person{
  _new(){
    this def name.string, age.integer
  }
  _def(){
    this pop
  }
  _form(){
    return "name: #(name)
            age:  #(age)"
  }
}

myself.person("Josef", 16)
out myself 'Gibt "name: Josef
           '      age:  16" aus

out "Hello world":u case 'Ergibt "HELLO WORLD"

Präprozessor

Da Operno einen rekursiven Parser besitzt, kann vor der Ausführung der Präprozessor Anweisungen verarbeiten, um einen Code zu optimieren. Somit ist z.B. Ein Makro eine Funktion, die Zeichenketten erhält und einen Code als Zeichenkette zurückgibt. Neben Makros können auch Symbole definiert werden.

Der Präprozessor besitzt auch Kontrollstrukturen zur Kompilerzeit, wodurch zwischen Code-Abschnitten vor der Ausführung gewählt werden können.

Quellen

• Dieser Beitrag wurde vom Entwickler selbst ertsellt

Weblinks

• [1] Homepage des Entwicklers
• [2] Projekt-Seite auf SourceForge