Ein wiederhole-Befehl
Einen neuen Befehl einführen
Interessant wäre eine Erweiterung des Befahlssatzes um einen wiederhole-Befehl.
[VW 2, WH 4 [VW 2, RE], VW 2]
Der wiederhole-Befehl soll dabei so ausgeführt werden.
WH 4 [VW 2, RE] wiederhole 4-mal die Befehlsfolge [VW 2, RE]
Aufgabe 1
Erkläre, was das Programm [VW 2, WH 4 [VW 2, RE], VW 2]
ausgehend von der Lage (0,0,N)
des Akteurs leistet.
Die Typdefinition erweitern
Um den wiederhole-Befehl verwenden zu können muss die Typdefinition erweitert werden:
module Interpreter exposing (..)
type Befehl
= LI -- links
| RE -- rechts
| VW Int -- vorwärts ...
| WH Int (List Befehl) -- wiederhole ...
> import Interpreter exposing (..)
> WH 4 [VW 2,RE]
WH 4 [VW 2,RE] : Befehl
> WH 2 [VW 3,WH 4 [VW 2,RE]]
WH 2 [VW 3,WH 4 [VW 2,RE]]
: Befehl
Beachte, dass die Typdefinition jetzt rekursiv ist. Der neue Typname Befehl
kommt selbst bei der Definition des Datentyps Befehl
vor.
Das ist erlaubt und ermöglicht geschachtelte Daten.
Aufgabe 2
(a) Erkläre, warum die Befehle WH 4 [VW 2,RE]]
und WH 2 [VW 3,WH 4 [VW 2,RE]]
von der Typdefinition erfasst werden.
(b) Teste selbst weitere komplexe Befehle, die von der Typdefinition erfasst werden.
Die Befehlsausführung festlegen
Die Ausführung des WH
-Befehls ist etwas komplizierter. Hier ein Vorschlag für eine Umsetzung.
Ausführung des LI-Befehls:
((3,0,N), [LI, ...]) -> ((3,0,W), [...])
((2,1,O), [LI, ...]) -> ...
...
Ausführung des RE-Befehls:
((0,1,N), [RE, ...]) -> ((0,1,O), [...])
((-1,1,O), [RE, ...]) -> ...
...
Ausführung des VW-Befehls:
((2,1,N), [VW 2, ...]) -> ((2,3,N), [...])
((0,-1,O), [VW 2, ...]) -> ...
((-2,4,S), [VW 2, ...]) -> ...
((1,3,W), [VW 2, ...]) -> ...
...
Ausführung des WH-Befehls:
((0,2,N), [WH 4 [VW 2, RE], ...]) -> ((0,2,N), [VW 2, RE, WH 3 [VW 2, RE], ...])
((0,4,O), [WH 3 [VW 2, RE], ...]) -> ((0,4,O), [VW 2, RE, WH 2 [VW 2, RE], ...])
((2,4,S), [WH 2 [VW 2, RE], ...]) -> ...
((0,4,W), [WH 1 [VW 2, RE], ...]) -> ...
((0,4,N), [WH 0 [VW 2, RE], ...]) -> ((0,4,N), [...])
Aufgabe 3
Erkläre die bereits vorgegebenen Zustandsänderungen und ergänze die noch fehlenden.
Eine Implementierung ergänzen
Die Quelltext liefert wieder ein Gerüst für die Implementierung der Befehlsausführung.
module Interpreter exposing (..)
type Befehl
= LI -- links
| RE -- rechts
| VW Int -- vorwärts ...
| WH Int (List Befehl) -- Wiederholung ...
type alias Programm = List Befehl
type Richtung
= N -- Norden
| O -- Osten
| S -- Süden
| W -- Westen
type alias Akteur = (Int, Int, Richtung)
type alias Zustand = (Akteur, Programm)
programm1: Programm
programm1 = [VW 2, RE, VW 4, LI, VW 2]
programm2: Programm
programm2 = [VW 2, WH 4 [VW 2, RE], VW 2]
programm3: Programm
programm3 = [WH 2 [VW 10, WH 4 [VW 2, RE]]]
akteur: Akteur
akteur = (0,0,N)
zustand: Zustand
zustand = (akteur, programm1)
exeProgramm: Zustand -> Zustand
exeProgramm ((posx, posy, richtung), programm) =
case programm of
[] ->
((posx, posy, richtung), programm)
befehl::restProgramm ->
case befehl of
LI ->
case richtung of
N -> exeProgramm ((posx, posy, W), restProgramm)
O -> exeProgramm ((posx, posy, N), restProgramm)
S -> exeProgramm ((posx, posy, O), restProgramm)
W -> exeProgramm ((posx, posy, S), restProgramm)
RE ->
case richtung of
N -> exeProgramm ((posx, posy, O), restProgramm)
O -> exeProgramm ((posx, posy, S), restProgramm)
S -> exeProgramm ((posx, posy, W), restProgramm)
W -> exeProgramm ((posx, posy, N), restProgramm)
VW x ->
case richtung of
N -> exeProgramm ((posx, posy+x, N), restProgramm)
O -> exeProgramm ((posx+x, posy, O), restProgramm)
S -> exeProgramm ((posx, posy-x, S), restProgramm)
W -> exeProgramm ((posx-x, posy, W), restProgramm)
WH n befehle ->
if n == 0 then
exeProgramm ...
else
exeProgramm ...
test =
exeProgramm (akteur, programm2)
> import Interpreter exposing (..)
> test
((0,4,N),[]) : Zustand
Aufgabe 4
Ergänze die fehlenden Teile im Quelltext. Teste anschließend mit unterschiedlichen Daten.