% 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}

