Voorbeelden

1 files changed, 121 insertions, 0 deletions

diff --git a/introexmp.tex b/introexmp.tex
new file mode 100644
index 0000000..8585b88
--- /dev/null
+++ b/introexmp.tex
@@ -0,0 +1,121 @@
+% vim: set spelllang=nl:
+\subsection{Voorbeelden}
+\label{sec:intro:exmp}
+Nu we alle commando's hebben gezien bekijken we nog een paar voorbeelden die
+aangeven hoe conditionele executie kan worden in Smurf.
+
+% Dit is waarschijnlijk te veel anders.
+%
+%\begin{exmp}
+%	Het volgende programma implementeert een simpel bestelsysteem:
+%	\begin{smurf}
+%		"ijs" "0" p \\
+%		"pizza" "1" p \\
+%		"Wil je ijs (0) of pizza (1)?\textbackslash{}n" o \\
+%		"Ik ga " i g + " voor je maken!" + o
+%	\end{smurf}
+%	We zetten de variabelen \verb$0$ en \verb$1$ tot \verb$ijs$ en \verb$pizza$.
+%	Vervolgens vragen we de gebruiker een keuze te maken. Met \smurfinline{ig}
+%	kan de gebruiker in feite kiezen welke variabele wordt opgehaald.
+%
+%	De uitvoer kan er dus uitzien als:
+%	\begin{verbatim}
+%		Wil je ijs (0) of pizza (1)?
+%		1
+%		Ik ga pizza voor je maken!
+%	\end{verbatim}
+%\end{exmp}
+
+\begin{exmp}
+	Dit programma laat de gebruiker kiezen welke functie er wordt uitgevoerd:
+	\begin{smurf}
+		"h""head"p "t""tail"p \\
+		"Voer een string in.\textbackslash{}n"o iq \\
+		"Wil je de head of de tail?\textbackslash{}n"o \\
+		ig +"o"+ x
+	\end{smurf}
+	Allereerst zetten we de variabelen \verb$head$ en \verb$tail$ tot \verb$h$ en
+	\verb$t$, de commando's voor de head en tail van een string. We vragen de
+	gebruiker om een string en zetten die in quotes zodat ze gebruikt kan worden
+	in een Smurfprogramma. We vragen de gebruiker om `head' of `tail' in te
+	voeren en halen de bijbehorende functie op. Op dit moment kan de stack eruit
+	zien als \verb$h$, \verb$"mijn string"$ (bovenste element eerst). Met
+	\smurfinline{+"o"+} bouwen we hiervan het programma \smurfinline{"mijn
+	string"ho}, wat we met \smurfinline{x} uitvoeren. De uitvoer van het
+	programma is dus `m', in dit geval.
+\end{exmp}
+
+\begin{exmp}
+	Het volgende programma is een Smurf interpreter:
+	\begin{smurf}
+		ix
+	\end{smurf}
+	We halen input op van de gebruiker en voeren dit uit als Smurfprogramma.
+\end{exmp}
+
+Ten slotte geven we nog een wat groter voorbeeld waar recursie wordt
+voorgedaan:
+
+\begin{exmp}
+	Dit programma geeft als output de input, de tail van de input, de tail van de
+	tail van de input, etc., tot en met de lege string.
+	\begin{smurf}
+		\footnotesize
+		i "s"p \\
+		"s"g"\textbackslash{}n"+o \\
+		"t\textbackslash{}"s\textbackslash{}"p\textbackslash{}"s\textbackslash{}"g\textbackslash{}"\textbackslash{}\textbackslash{}n\textbackslash{}"+o\textbackslash{}"c\textbackslash{}"p\textbackslash{}"c\textbackslash{}"gq\textbackslash{}"s\textbackslash{}"gq\textbackslash{}"c\textbackslash{}"g++q\textbackslash{}"x\textbackslash{}"+\textbackslash{}"s\textbackslash{}"gp\textbackslash{}"\textbackslash{}"\textbackslash{}"\textbackslash{}"p\textbackslash{}"s\textbackslash{}"ggx" "c"p \\
+		"c"gq "s"gq "c"g++ \\
+		x
+	\end{smurf}
+	Met de eerste twee regels halen we input op en sturen die naar de output. Ook
+	wordt de input in een variabele \verb$s$ opgeslagen.
+	De derde regel zet een Smurfprogramma in \verb$c$.
+	In de vierde regel plakken we dat gequotifiede programma, de gequotifiede
+	input en het programma aan elkaar vast. Het resultaat voeren we uit.
+
+	Op dit moment voeren we dus het programma uit dat bestaat uit twee keer een
+	string pushen en vervolgens het programma uit \verb$c$. Dan bekijken we nu
+	dit programma, wat we in de derde regel hierboven hebben gedefinieerd, in een
+	iets makkelijkere opmaak:
+	\begin{smurf}
+		t "s"p "s"g "\textbackslash{}n"+o \\
+		"c"p \\
+		"c"gq "s"gq "c"g++ \\
+		q"x"+ "s"gp \\
+		""""p \\
+		"s"ggx
+	\end{smurf}
+	Met de eerste regel slaan we de tail van de oude input op in \verb$s$. We
+	sturen deze tail ook naar de output. Hierna staat alleen nog de eerste string
+	op de stack, d.w.z. het programma waar we naar kijken. Dit slaan we op in
+	\verb$c$.
+	De derde regel hier is hetzelfde als de vierde regel hierboven: we maken een
+	nieuw programma, wat er precies hetzelfde uitziet als dit, behalve dat we van
+	de tweede string één karakter hebben weggehaald.
+
+	Het is verleidelijk op dit moment weer \smurfinline{x} te gebruiken. We
+	moeten echter eerst nog controleren of we niet met de lege string te maken
+	hebben. We maken dus van het nieuwe programma wederom een nieuw programma,
+	wat bestaat uit het pushen van het oude programma en vervolgens
+	\smurfinline{x} aanroepen. Dit programma slaan we op in de variabele met als
+	naam de waarde van \verb$s$ (de input).
+
+	Mocht deze input de lege string zijn, dan overschrijft de vijfde regel dit
+	programma met een leeg programma. Vervolgens halen we in de zesde regel het
+	programma (of het lege programma, in het geval van de lege string) op, en
+	voeren dit uit. Door deze laatste paar regels zullen we dus niet
+	\smurfinline{t} uitvoeren op de lege string.
+
+	\medskip
+	De uitvoer van dit programma met de input `smurf' is dus:
+
+	\begin{verbatim}
+		smurf
+		murf
+		urf
+		rf
+		f
+
+	\end{verbatim}
+\end{exmp}
+