Immutable Stack Erweiterungen

Lambda Kalkül für Javascript

Search…

Lambda Kalkül für praktisches JavaScript

Forschungsarbeit IP5 - Lambda Kalkül

Forschungsarbeit IP6 - Fortschrittliche Abstraktionen im Lambda Kalkül

Immutable Stack Erweiterungen

Box

Benchmark und unsere Erkenntnisse

Code Convention

Immutable Stack Erweiterungen

Neue Funktionen für den Stack: concat, flatten, zipWith, zip, stackEquals, getElementByIndex, removeByIndex, getIndexOfElement, maybeIndexOfElement, containsElement, convertElementsToStack

Basis
Die Funktionen in diesem Kapitel sind neu zum Immutable Stack hinzugekommen.
Immutable Stack
Der Index bei einem Stack beginnt bei 1. Der Index 0 ist reserviert für den emptyStack. Am Index 0 steht immer das Element id.
In den folgenden Beispielen wird zur besseren Übersicht, die Stack Datenstruktur wie folgt dargestellt:[ element1, element2, element3, ... ]
Erweiterungen
Die Titel der Funktionen sind mit einem Link zur Implementation verknüpft
​concat​
Die Funktion concat nimmt zwei Stacks entgegen und konkateniert diese.
const stack1  = convertArrayToStack( ["Hello", "Haskell"] );
const stack2  = convertArrayToStack( ["World", "Random"] );
​
concat(stack1)(stack2); // [ "Hello", "Haskell", "World", "Random" ]
​
​
const stack3 = convertArrayToStack( [1, 2, 3] );
const stack4 = convertArrayToStack( [4] );
concat(stack3)(stack4)  // [ 1, 2, 3, 4 ]
​flatten​
Die Funktion flatten nimmt einen Stack entgegen, dessen Einträge Stacks sind. Die Funktion verknüpft diese alle zusammen zu einem Stack. Das Tiefenlevel, bis zu welcher die Struktur abgeflacht wird ist 1.
const s1 = convertArrayToStack( [1, 2] );
const s2 = convertArrayToStack( [3, 4] );
const s3 = convertArrayToStack( [5, 6] );
​
const stackWithStacks = convertArrayToStack( [s1, s2, s3] ); // [ [1, 2], [3, 4], [5, 6] ]
​
flatten(stackWithStacks) // [ 1, 2, 3, 4, 5, 6]
​zipWith​
Die zipWithFunktion nimmt eine Verknüpfungsfunktion und zwei Stacks entgegen. Anhand der Verknüpfungsfunktion werden die Elemente der beiden übergebenen Stacks paarweise miteinander verknüpft zu einem neuen Stack.
Wenn einer der beiden übergebenen Stacks kürzer ist wird nur bis zum letzten Element des kürzeren Stacks verknüpft.
const add = x => y => x + y;
​
const s1 = convertArrayToStack( [1, 2] );
const s2 = convertArrayToStack( [4, 5] );
​
zipWith(add)(s1)(s2) // [ 5, 7 ]
​zip (with pair)​
Die zip Funktion nimmt zwei Stacks entgegen und verknüpft die beiden Stacks mit der Funktion pair.
Wenn einer der beiden übergebenen Stacks kürzer ist wird nur bis zum letzten Element des kürzeren Stacks verknüpft.
const s1 = convertArrayToStack( [1, 2] );
const s2 = convertArrayToStack( [3, 4] );
​
zip(s1)(s2)  // [ (1, 3), (2, 4) ]
​stackEquals​
Die Funktion stackEquals nimmt zwei Stacks entgegen und vergleicht alle Elemente mit dem JavaScript === Operator auf Gleichheit. Wenn alle Vergleiche true ergeben, gibt die Funktion ein Church-Boolean True ansonsten ein Church-Boolean False zurück.
const s1 = convertArrayToStack( [1, 2] );
const s2 = convertArrayToStack( [1, 2] );
​
stackEquals(s1)(s2)  // True (Church Boolean)
​getElementByIndex​
Die Funktion getElementByIndex nimmt einen Stack und eine Church- oder JS-Zahl, die den Index des Elements repräsentiert, entgegen. Falls an diesem Index ein Element existiert, wird dieses zurückgegeben ansonsten wird auf der Console einer Error geloggt und der Rückgabewert ist undefined.
Anwendungs Beispiel:
const stackWithStrings = convertArrayToStack(["Hello", "World"]);
​
getElementByIndex(stackWithStrings)(n1) // "Hello"
getElementByIndex(stackWithStrings)(n2) // "World"
​
getElementByIndex(stackWithStrings)( 1)  // "Hello"
getElementByIndex(stackWithStrings)( 2)  // "World"
​
getElementByIndex(stackWithStrings)(999) // Error "invalid index" 
Der Anwender muss nicht mehr entscheiden, welche Funktionen er braucht: getElementByChurchNumberIndex oder getElementByJsNumIndex.
Die Funktion getElementByIndexwurde erweitert, dass der Index auf den "Typ" kontrolliert wird mittels eitherFunction und eitherNaturalNumber. So kann der Anwender eine Church- oder JavaScript-Zahl angeben, die Funktion findet selber heraus, welche Methode er braucht. Bei ungültigen Parametern werden die passende Fehler-Meldungen geloggt.
-> siehe Implementation ****
Die spezifischeren Funktionen um ein Element zu erhalten sind weiterhin vorhanden:
``getElementByChurchNumberIndex``
``getElementByJsnumIndex``
``
Als Either-Variante:
[**`eitherElementByIndex`**](https://github.com/mattwolf-corporation/ip6_lambda-calculus-in-js/blob/1854cf6515e5f1ba74c48c4a9a97f12e5e363aa2/src/stack/stack.js#L270) **``**
``eitherElementByJsNumIndex``
``eitherElementByChurchIndex``
​removeByIndex​
Die Funktion removeByIndex nimmt einen Stack und eine Church- oder JS-Zahl als Index entgegen. Die Funktion löscht das Element am übergebenen Index und gibt den neuen Stack zurück.
Bei einem nicht existierenden Index erhält man denselben Stack unverändert zurück.
const stackWithStrings = convertArrayToStack( ["Hello", "Haskell", "World"] );
​
removeByIndex(stackWithStrings)( 2) // [ "Hello", "World" ]
removeByIndex(stackWithStrings)(n2) // [ "Hello", "World" ]
​
removeByIndex(stackWithStrings)(999) // [ "Hello", "Haskell", "World" ]
​getIndexOfElement​
Die Funktion getIndexOfElement nimmt einen Stack und ein Element entgegen und gibt den Index als JavaScript-Zahl von diesem Element zurück. Wenn das Element nicht existiert wird undefined zurückgegeben.
const stackWithNumbers = convertArrayToStack( [7, 34, 10] );
​
getIndexOfElement(stackWithNumbers)(7)    // 1
getIndexOfElement(stackWithNumbers)(34)   // 2
getIndexOfElement(stackWithNumbers)(10)   // 3
getIndexOfElement(stackWithNumbers)(100)  // undefined
​maybeIndexOfElement​
Die Funktion maybeIndexOfElement ist analog zur Funktion getIndexOfElement. Nur der Rückgabetyp ist ein Maybe.
const stackWithNumbers = convertArrayToStack( [7, 34, 10] );
​
maybeIndexOfElement(stackWithNumbers)(7)    // Just(1)
maybeIndexOfElement(stackWithNumbers)(34)   // Just(2)
maybeIndexOfElement(stackWithNumbers)(10)   // Just(3)
maybeIndexOfElement(stackWithNumbers)(100)  // Nothing
​containsElement​
Die Funktion containsElement nimmt einen Stack und ein Element entgegen. Gibt True (ChurchBoolean) zurück, wenn das Element im Stack vorhanden ist. Gibt False (ChurchBoolean) zurück, wenn das Element nicht im Stack vorhanden ist.
const stackWithNumbers = convertArrayToStack( [0, 11, 22, 33] );
​
containsElement(stackWithNumbers)(-1) === False
containsElement(stackWithNumbers)( 0) === True
containsElement(stackWithNumbers)(11) === True
containsElement(stackWithNumbers)(22) === True
containsElement(stackWithNumbers)(33) === True
containsElement(stackWithNumbers)(44) === False
​convertElementsToStack​
Die Funktion convertElementsToStack nimmt einen Rest Parameter (JavaScript Rest Parameter) entgegen. Die übergebenen Elemente werden in ein Stack umgewandelt.
const stackWithValues = convertElementsToStack(1,2,3);
​
convertStackToArray( stackWithValues ) === [1,2,3]
​
​
const stackWithValues2 = convertElementsToStack(1,2,3,...['a','b','c']);
​
convertStackToArray( stackWithValues2 ) === [1,2,3,'a','b','c']