Lambda Kalkül für praktisches JavaScript
Benjamin Brodwolf & Pascal Andermatt
Lambda Kalkül ist ein formales System, in der mathematische Logik zur Berechnung und Untersuchung von Funktionen gilt. Es ist ein universelles Berechnungsmodel , mit dem jede Turing-Maschine simuliert werden kann. Es wurde von dem Mathematiker Alonzo Church in den 1930er Jahren als Teil seiner Forschung zu den Grundlagen der Mathematik eingeführt.
Lambda-Kalkül hat im Grunde nichts in sich. Es hat nur drei Dinge: Variablenbindung, einen Weg, Funktionen zu bauen und einen Weg, Funktionen anzuwenden. Es hat keine anderen Kontrollstrukturen, keine anderen Datentypen, gar nichts.
JavaScript ist die Programmiersprache die hauptsächlich im Web verwendet wird und durch den Browser ausgeführt wird. JavaScript integriert dabei viele funktionale Aspekte, stellt aber auch einiges an Funktionalität aus der objektorientierten Programmierung zur Verfügung. Es besteht also die Möglichkeit, in vielen verschiedenen Paradigmen zu programmieren.
Lambda Kalkül & JavaScript
JavaScript hat den Ruf, eine unsichere Programmiersprache zu sein. Man kann aber auch in JavaScript sichere und belastbare Konstruktionen mit Industriehärte bauen. Ein Weg dazu ist die Anwendung von Erkenntnissen aus den Grundlagen der Informatik, dem untypisierten Lambda-Kalkül. Das Konzept ist, Lambda Kalkül mit der Programmiersprache JavaScript zu verbinden. Das heisst, in nur rein funktionalen Paradigma Program-Codes zu schreiben (purely functional). JavaScript bietet dazu Sprachelemente wie Closures und Funktionen. Sie machen es möglich, dass in JavaScript funktional programmiert werden kann. Es gewährleistet die Konzepte der Seiteneffektfreiheit, Zustandslosigkeit, Variablenbindung statt Zuweisung, Funktionskomposition und Funktionen höherer Ordnung (high order functions) zu schreiben.
Forschungsarbeit
Ziel dieser Forschungsarbeit ist es, neue Konstruktionen aus dem untypisierten Lambda Kalkül, mit der Programmiersprache JavaScript zu entwerfen. Diese Konstruktionen haben das Ziel JavaScript Applikationen robuster, sicherer und wartbarer zu machen. Bei diesen Konstruktionen wird komplett auf die Werte der reinen funktionalen Programmierung gesetzt:
Reinheit (pure functions): Funktionen ohne Seiteneffekte (wie mathematische Funktionen)
Unveränderlichkeit (immutable Datastructure): __ Unveränderliche Datenstrukturen
Iteration: Eine Iteration ohne Ausdrücke wie
for
,while
oderdo
SchleifenFunktionen höherer Ordnung (high order functions).
Zustandslosigkeit
Abgrenzung von objektorientierter Programmierung: Es werden keine objektorientierte Konzepte wie Klassen oder Vererbung verwendet.
Was du hier findest
Eine Sammlung von Konstruktionen heraus:
kleine Bibliothek von Lambda-Kalkül-Konstruktionen zusammengestellt (Einfache Kombinatoren)
kleine Bibliothek von Lambda-Kalkül-Konstruktionen (Einfache Kombinatoren)
Rechnen mit JavaScript- und mit Church-Zahlen inklusivem lambdafizierter Taschenrechner
Eigene unveränderliche Datenstruktur (die immutable Stack Datenstruktur)
Immutable ListMap Datenstruktur (Stack mit Schlüssel-Wert Paaren)
Umsetzung des Observer Pattern (funktionales Oberservable Konstrukt)
Box-Konstrukt um Werte in einer Pipeline zu verarbeiten
Eignes Test-Frameworks mit einer Zeitmessung für die Methodenausführung (Benchmark-Test)
JsDoc (Dokumentation und Typ-Unterstützung für Anwender)
Code Convention (Konzepte, Formatierung und Anwendungsbeispiele)
Classic JS vs Lambda JS
Property Value aus Objekt extrahieren (null-safe)
Gegeben: Ein verschachteltes User-Objekt mit Street-Property. Ziel: Strassenname extrahieren
Eine mögliche Implementierung im klassischen JavaScript (ohne Optional Chaining) wäre:
Eine gleichwertige Implementierung mit Verwendung des Werkzeugkastens (Lambda JS):
Vergleich
Pure Lambda JS vs Lambda JS
Bereits eine kleine Funktion wie push
, die ein Stack mit einem neuen Wert erstellt , besteht im Kern aus mehreren Funktionen.
Die Implementation der Funktion push
sieht wie folgt aus:
push
sieht wie folgt aus:Sie besteht aus folgenden Funktionen: stack
, succ
, stackIndex
.Diese Funktionen können in der Funktion push durch ihre Implementation ersetzt werden:
const stack = triple
const triple = x => y => z => f => f(x)(y)(z);
const succ = n => f => x => (f)(n(f)(x));
const stackIndex = firstOfTriple;
const firstOfTriple = x => y => z => x
;
Die Funktion push
würde im reinen Lambda Kalkül (pure Lambda JS) wie folgt aussehen:
push
würde im reinen Lambda Kalkül (pure Lambda JS) wie folgt aussehen:Nach der Eta-Reduktion:
Funktionen in JS im reinen Lambda Kalkül zu schreiben kann schnell unübersichtlich werden weil die Definitionen fehlen. Diese verschachtelten anonymen Funktion werden schnell zu komplex. Darum ist es besser dieses Funktionskonstrukt in mehreren Funktionen aufzuteilen und diesen einen sinnvollen Namen zu geben.
Beispiel an der grösseren Funktion reduce
reduce
Implementation von reduce
in Lambda JS:
reduce
in Lambda JS:Implementation in pure Lambda JS (Funktionsdefinitionen ersetzt und ETA reduziert)
Die Performance leidet wenn eine grössere, komplexere Funktion in einer reinen Lambda Kalkül Schreibweise definiert ist. Da es keine Definitionen gibt die wiederverwendet werden können muss viel mehr evaluiert werden in JavaScript. Darum ist es für die Performance und für die Leserlichkeit besser die Funktionen nicht in der reinen Lambda Kalkül Schreibweise zu definieren.
Fazit / Erkenntnisse
Konzepte aus der funktionalen Programmierung
Die Konstruktionen beinhalten Ideen und Konzepte aus der funktionalen Programmierung. Mit dem Einsatz dieser Konstruktionen, können JavaScript Applikationen funktionaler implementiert werden. Die Konstruktionen sind so implementiert, dass sie leicht integrierbar und anwendbar sind. Ein JavaScript Programm muss dabei nicht komplett nur aus diesen Konstruktionen bestehen, sondern der Anwender kann hier und dort bestimme Konstrukte in sein Programm einfliessen lassen.
Nutzen & Vorteile
In mehreren kleinen Beispielen hat sich gezeigt, dass die Konstruktionen den Code leserlicher, wartbarer und sicherer machen. Ausserdem entstehen weniger typische Fehler, die bei der Programmierung mit JavaScript auftreten.
Da die Konstruktionen aus puren Funktionen bestehen, ist der Programmablauf klarer und Fehler können besser eingegrenzt werden. Bei veränderlichen Daten und Funktionen mit Seiteneffekten, leidet die Übersicht, man verliert die Kontrolle über den Programmablauf und den Abhängigkeiten innerhalb des Programmes. Schon durch einen kleinen Einsatz von diesen Konstruktionen wird diesem Problem entgegenwirkt und die Übersicht wird verbessert.
JS Doc Unterstützung - Fehlendes Typ System bei JavaScript
Ein wesentliches Ziel von Typisierung in Programmiersprachen ist die Vermeidung von Laufzeitfehlern. JavaScript ist eine schwach typisierte oder dynamische Programmiersprache. Datentypen werden bei einer Variable nicht explizit deklariert und jede Variable kann mit Werten jedes Typen initialisiert werden. Es gibt auch kein Compiler der die Typen überprüfen würde. Die JS Doc unterstützt den Anwender für die korrekte Verwendung der Funktionen. Mit der JS Doc bekommt der Anwender Hinweise auf die korrekten Typ-Parameter.
Potenzielle Erweiterungen/Vorschläge für nächste Schritte
Für die unveränderlichen Datenstrukturen Stack und ListMap könnten zusätzliche Funktionen entwickelt werden, sodass ein noch grösseres Anwendungsgebiet entsteht.
Mögliche Funktionen: findFirst, stream-artige Funktionen
Weitere Konzepte der funktionalen Programmierung umsetzen
Was kann verbessert werden?
Bei gewissen Funktionen könnte noch mehr Sicherheit eingebaut werden, sodass ungültige Parameter besser abgefangen werden
Noch mehr Funktionen die auch ein Maybe/Either Type zurückgeben
Mehr Funktionen mit aussagekräftigen Fehlermeldungen für den Verwender
Diese Arbeit erstanden aus einem Projekt (IP5) und der Bacherlorarbeit (IP6) an der FHNW:
Herzlichen Dank an unseren Projektbetreuer und Inspirator Prof. Dierk König
Last updated