Index verbessert; Inhalte zum Lambda-Kalkül hinzugefügt

documents/Programmierparadigmen/Haskell.tex

@@ -87,6 +87,9 @@ hat einen Speicherverbrauch von $\mathcal{O}(n)$. Durch einen
 \inputminted[numbersep=5pt, tabsize=4]{haskell}{scripts/haskell/fakultaet-akkumulator.hs}
 
 \subsection{Listen}
+Listen sind in Haskell 0-indiziert, d.~h. das erste Element jeder Liste hat
+den Index 0.
+
 \begin{itemize}
     \item \texttt{[]} erzeugt die leere Liste,
     \item \texttt{[1,2,3]} erzeugt eine Liste mit den Elementen $1, 2, 3$
@@ -148,7 +151,7 @@ in etwa folgendem Haskell-Code:
           \texttt{tail "ABCDEF"} gibt \texttt{"BCDEF"} zurück.
 \end{itemize}
 
-\subsection{Let und where}\xindex{let}\xindex{where}%
+\subsection{Let und where}\xindex{let (Haskell)@\texttt{let} (Haskell)}\xindex{where (Haskell)@\texttt{where} (Haskell)}%
 \inputminted[numbersep=5pt, tabsize=4]{haskell}{scripts/haskell/let-where-bindung.hs}
 
 \subsection{Funktionskomposition}\xindex{. (Haskell)}\xindex{Funktionskomposition}%
@@ -223,12 +226,12 @@ Ein paar Beispiele zur Typinferenz:
     \label{fig:haskell-type-hierarchy}
 \end{figure}
 
-\subsection{type}\xindex{type}%
+\subsection{type}\xindex{type (Haskell)@\texttt{type} (Haskell)}%
 Mit \texttt{type} können Typsynonyme erstellt werden:
 
 \inputminted[numbersep=5pt, tabsize=4]{haskell}{scripts/haskell/alt-types.hs}
 
-\subsection{data}\xindex{data}%
+\subsection{data}\xindex{data (Haskell)@\texttt{data} (Haskell)}%
 Mit dem Schlüsselwort \texttt{data} können algebraische Datentypen\xindex{Datentyp!algebraischer}
 erzeugt werden:
 
@@ -267,7 +270,7 @@ sich das ganze sogar noch kürzer schreiben:
 \subsection{Fibonacci}\xindex{Fibonacci}
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=fibonacci.hs]{haskell}{scripts/haskell/fibonacci.hs}
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=fibonacci-akk.hs]{haskell}{scripts/haskell/fibonacci-akk.hs}
-\xindex{zipWith}
+\xindex{zipWith (Haskell)@\texttt{zipWith} (Haskell)}
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=fibonacci-zip.hs]{haskell}{scripts/haskell/fibonacci-zip.hs}
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=fibonacci-pattern-matching.hs]{haskell}{scripts/haskell/fibonacci-pattern-matching.hs}
 
@@ -276,7 +279,7 @@ wird wie folgt erzeugt:
 
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=fibonacci-stream.hs]{haskell}{scripts/haskell/fibonacci-stream.hs}
 
-\subsection{Polynome}\xindex{Polynome}\xindex{zipWith}\xindex{foldr}\xindex{tail}%
+\subsection{Polynome}\xindex{Polynome}\xindex{zipWith (Haskell)@\texttt{zipWith} (Haskell)}\xindex{Folds!foldr (Haskell)@\texttt{foldr} (Haskell)}\xindex{tail (Haskell)@\texttt{tail} (Haskell)}%
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=polynome.hs]{haskell}{scripts/haskell/polynome.hs}
 
 \subsection{Hirsch-Index}\xindex{Hirsch-Index}\xindex{Ord}\xindex{Num}%
@@ -293,7 +296,7 @@ wird wie folgt erzeugt:
 
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=intersect.hs]{haskell}{scripts/haskell/intersect.hs}
 
-\subsection{Funktionen höherer Ordnung}\xindex{Folds}\xindex{foldl}\xindex{foldr}\label{bsp:foldl-und-foldr}
+\subsection{Funktionen höherer Ordnung}\xindex{Folds}\xindex{Folds!foldl (Haskell)@\texttt{foldl} (Haskell)}\xindex{Folds!foldr (Haskell)@\texttt{foldr} (Haskell)}\label{bsp:foldl-und-foldr}
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=folds.hs]{haskell}{scripts/haskell/folds.hs}
 
 \subsection{Chruch-Zahlen}
@@ -320,7 +323,7 @@ Knoten anwendet:
 
 \subsection{Standard Prelude}
 Hier sind die Definitionen eininger wichtiger Funktionen:
-\xindex{zipWith}\xindex{zip}
+\xindex{zipWith (Haskell)@\texttt{zipWith} (Haskell)}\xindex{zip (Haskell)@\texttt{zip} (Haskell)}
 \inputminted[numbersep=5pt, tabsize=4]{haskell}{scripts/haskell/standard-definitions.hs}
 
 \section{Weitere Informationen}

documents/Programmierparadigmen/Lambda.tex

@@ -164,7 +164,7 @@ Auch die gewohnten Operationen lassen sich so darstellen.
     \end{align*}
 \end{beispiel}
 
-\begin{beispiel}[Vorgänger-Operation]
+\begin{beispiel}[Vorgänger-Operation]\xindex{pred}\xindex{pair}\xindex{next}\xindex{fst}\xindex{snd}
     \begin{align*}
         \pair&:= \lambda a. \lambda b. \lambda f. f a b\\
         \fst &:= \lambda p. p (\lambda a. \lambda b. a)\\
@@ -239,10 +239,25 @@ zurückgibt:
 \end{definition}
 
 \begin{beispiel}[Kombinatoren\footnotemark]%
+    Folgende $\lambda$-Funktionen sind Beispiele für Kombinatoren:
     \begin{bspenum}
         \item $\lambda a.\ a$
         \item $\lambda a.\ \lambda b.\ a$
         \item $\lambda f.\ \lambda a.\ \lambda b. f\ b\ a$
+        \item $\lambda x.\ \lambda y.\ x$\\
+              Diese $\lambda$-Funktion hat nur die gebundene Variable $x$, also
+              ist es ein Kombinator.
+    \end{bspenum}
+
+    Folgende $\lambda$-Funktionen sind keine Kombinatoren:
+    \begin{bspenum}
+        \item $\lambda x.\ y$
+        \item $x\ \lambda y.\ y$\\
+              Der Gesamtausdruck ist kein $\lambda$-Ausdruck, also ist es auch
+              kein Kombinator. Außerdem ist $x$ eine freie Variable.
+        \item $(\lambda x.\ x)\ y$\\
+              Der Ausdruck ist kein $\lambda$-Ausdruck, sondern eine
+              Funktionsanwendung. Also ist es kein Kombinator.
     \end{bspenum}
 \end{beispiel}
 \footnotetext{Quelle: \url{http://www.haskell.org/haskellwiki/Combinator}}
@@ -260,6 +275,9 @@ Insbesondere ist also $f \ g$ ein Fixpunkt von $g$.
     heißt $Y$-Kombinator.
 \end{definition}
 
+Der Y-Kombinator hat einen Paramter. Er nimmt eine nicht-rekursive Funktion
+und gibt eine rekursive zurück.
+
 \begin{behauptung}
     Der $Y$-Kombinator ist ein Fixpunktkombinator.
 \end{behauptung}
@@ -311,4 +329,5 @@ Insbesondere ist also $f \ g$ ein Fixpunkt von $g$.
 \begin{itemize}
     \item \url{http://c2.com/cgi/wiki?FreeVariable}
     \item \url{http://www.lambda-bound.com/book/lambdacalc/node9.html}
+    \item \url{http://mvanier.livejournal.com/2897.html}
 \end{itemize}

documents/Programmierparadigmen/Parallelitaet.tex

@@ -69,7 +69,11 @@ Dabei wird die Von-Neumann-Architektur als \textit{SISD-Architektur} und die
 PRAM-Architektur als \textit{SIMD-Architektur} klassifiziert. Es ist so zu
 verstehen, dass ein einzelner Befehl auf verschiedene Daten angewendet wird.
 
-Bei heutigen Multicore-Rechnern liegt MIMD vor.
+Bei heutigen Multicore-Rechnern liegt MIMD vor, da verschiedene Befehle in den
+Programmspeichern möglich sind.
+
+Ein Beispiel für die SIMD sind GPUs. Sie haben einen Befehl im Programmspeicher
+der auf verschiedenen Daten (Pixel) angewendet wird.
 
 MISD ist nicht so richtig sinnvoll.
 

documents/Programmierparadigmen/Programmierparadigmen.tex

@@ -111,6 +111,33 @@
   \penalty\@M% added line
 \endgroup}
 \makeatother
+% Unicode minted patch: http://tex.stackexchange.com/a/84883/5645
+\makeatletter
+\newcommand{\minted@write@detok}[1]{%
+  \immediate\write\FV@OutFile{\detokenize{#1}}}%
+
+\newcommand{\minted@FVB@VerbatimOut}[1]{%
+  \@bsphack
+  \begingroup
+    \FV@UseKeyValues
+    \FV@DefineWhiteSpace
+    \def\FV@Space{\space}%
+    \FV@DefineTabOut
+    %\def\FV@ProcessLine{\immediate\write\FV@OutFile}% %Old, non-Unicode version
+    \let\FV@ProcessLine\minted@write@detok %Patch for Unicode
+    \immediate\openout\FV@OutFile #1\relax
+    \let\FV@FontScanPrep\relax
+%% DG/SR modification begin - May. 18, 1998 (to avoid problems with ligatures)
+    \let\@noligs\relax
+%% DG/SR modification end
+    \FV@Scan}
+    \let\FVB@VerbatimOut\minted@FVB@VerbatimOut
+
+\renewcommand\minted@savecode[1]{
+  \immediate\openout\minted@code\jobname.pyg
+  \immediate\write\minted@code{\expandafter\detokenize\expandafter{#1}}%
+  \immediate\closeout\minted@code}
+\makeatother
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 
@@ -147,8 +174,8 @@
 \input{Java-Bytecode}
 
 \appendix
-\input{Bildquellen}
-\clearpage
+%\input{Bildquellen}
+%\clearpage
 \input{Abkuerzungen}
 \clearpage
 \input{Definitionen} 

documents/Programmierparadigmen/Prolog.tex

@@ -64,7 +64,7 @@ verglichen werden.
 
 \begin{beispiel}[Arithmetik in Prolog\footnotemark]
     \begin{bspenum}
-        \item \inputminted[numbersep=5pt, tabsize=4]{prolog}{scripts/prolog/even.pl}\xindex{even}
+        \item \inputminted[numbersep=5pt, tabsize=4]{prolog}{scripts/prolog/even.pl}\xindex{even (Prolog)@\texttt{even} (Prolog)}
         \item \inputminted[numbersep=5pt, tabsize=4]{prolog}{scripts/prolog/fibonacci2.pl}\xindex{fib}
     \end{bspenum}
 \end{beispiel}
@@ -172,39 +172,45 @@ Dieses skript soll man \texttt{swipl -f test.pl} aufrufen. Dann erhält man:
 \subsection{Delete}\xindex{remove}\xindex{delete}%
 \inputminted[numbersep=5pt, tabsize=4]{prolog}{scripts/prolog/delete.pl}
 
-\subsection{Zebrarätsel}
-Folgendes Rätsel wurde von \url{https://de.wikipedia.org/w/index.php?title=Zebrar%C3%A4tsel&oldid=126585006}
-entnommen:
-
-\begin{enumerate}
-    \item Es gibt fünf Häuser.
-    \item Der Engländer wohnt im roten Haus.
-    \item Der Spanier hat einen Hund.
-    \item Kaffee wird im grünen Haus getrunken.
-    \item Der Ukrainer trinkt Tee.
-    \item Das grüne Haus ist direkt rechts vom weißen Haus.
-    \item Der Raucher von Altem-Gold-Zigaretten hält Schnecken als Haustiere.
-    \item Die Zigaretten der Marke Kools werden im gelben Haus geraucht.
-    \item Milch wird im mittleren Haus getrunken.
-    \item Der Norweger wohnt im ersten Haus.
-    \item Der Mann, der Chesterfields raucht, wohnt neben dem Mann mit dem Fuchs.
-    \item Die Marke Kools wird geraucht im Haus neben dem Haus mit dem Pferd.
-    \item Der Lucky-Strike-Raucher trinkt am liebsten Orangensaft.
-    \item Der Japaner raucht Zigaretten der Marke Parliaments.
-    \item Der Norweger wohnt neben dem blauen Haus.
-\end{enumerate}
-
-Wer trinkt Wasser? Wem gehört das Zebra?
-
-\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=zebraraetsel.pro]{prolog}{scripts/prolog/zebraraetsel.pro}
-
-TODO
-
-\section{Zahlen generieren}
+% \subsection{Zebrarätsel}
+% Folgendes Rätsel wurde von \url{https://de.wikipedia.org/w/index.php?title=Zebrar%C3%A4tsel&oldid=126585006}
+% entnommen:
+
+% \begin{enumerate}
+%     \item Es gibt fünf Häuser.
+%     \item Der Engländer wohnt im roten Haus.
+%     \item Der Spanier hat einen Hund.
+%     \item Kaffee wird im grünen Haus getrunken.
+%     \item Der Ukrainer trinkt Tee.
+%     \item Das grüne Haus ist direkt rechts vom weißen Haus.
+%     \item Der Raucher von Altem-Gold-Zigaretten hält Schnecken als Haustiere.
+%     \item Die Zigaretten der Marke Kools werden im gelben Haus geraucht.
+%     \item Milch wird im mittleren Haus getrunken.
+%     \item Der Norweger wohnt im ersten Haus.
+%     \item Der Mann, der Chesterfields raucht, wohnt neben dem Mann mit dem Fuchs.
+%     \item Die Marke Kools wird geraucht im Haus neben dem Haus mit dem Pferd.
+%     \item Der Lucky-Strike-Raucher trinkt am liebsten Orangensaft.
+%     \item Der Japaner raucht Zigaretten der Marke Parliaments.
+%     \item Der Norweger wohnt neben dem blauen Haus.
+% \end{enumerate}
+
+% Wer trinkt Wasser? Wem gehört das Zebra?
+
+% \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=zebraraetsel.pro]{prolog}{scripts/prolog/zebraraetsel.pro}
+
+% TODO
+
+\subsection{Zahlen generieren}
 Folgendes Skript generiert durch reerfüllung die Zahlen $1, \dots, 10$:
 
 \inputminted[numbersep=5pt, tabsize=4]{prolog}{scripts/prolog/zahlen-bis-10.pl}
 
+\subsection{Reguläre ausdrücke}
+Folgendes Beispiel stammt aus der Programmierparadigmenklausur vom WS 2013/2014
+bei Prof. Dr. Snelting:
+
+\inputminted[numbersep=5pt, tabsize=4]{prolog}{scripts/prolog/regex.pl}
+
 \section{Weitere Informationen}
 \begin{itemize}
     \item \href{http://wiki.ubuntuusers.de/Prolog}{\path{wiki.ubuntuusers.de/Prolog}}: Hinweise zur Installation von Prolog unter Ubuntu

documents/Programmierparadigmen/Symbolverzeichnis.tex

@@ -36,6 +36,20 @@
 $\mathcal{M} \models \varphi$& Semantische Herleitbarkeit\newline Im Modell $\mathcal{M}$ gilt das Prädikat $\varphi$.\\
 $\psi \vdash \varphi$        & Syntaktische Herleitbarkeit\newline Die Formel $\varphi$ kann aus der Menge der Formeln $\psi$ hergeleitet werden.\\
 \end{xtabular}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Typinferenz                                                       %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section*{Typinferenz}
+
+\settowidth\mylengtha{$\tau \succeq \tau'$}
+\setlength\mylengthb{\dimexpr\columnwidth-\mylengtha-2\tabcolsep\relax}
+
+\begin{xtabular}{@{} p{\mylengtha} P{\mylengthb} @{}}
+$\Gamma \vdash t: \tau$   & Im Typkontext $\Gamma$ hat der Term $t$ den Typ $\tau$\\
+$a \Parr b$  & $a$ wird zu $b$ unifiziert\\
+$\tau \succeq \tau'$& $\tau$ wird durch $\tau'$ instanziiert\\\
+\end{xtabular}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % Weiteres                                                          %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

documents/Programmierparadigmen/Typinferenz.tex

@@ -49,27 +49,37 @@ wenn $\alpha$ ein String ist und $\beta$ boolesch.
 
 Die Menge aller Operationen, die auf die Variablen angewendet werden, nennt man
 \textbf{Typkontext}\xindex{Typkontext}. Dieser wird üblicherweise mit $\Gamma$
-bezeichnet.
+bezeichnet. Der Typkontext weist freien Variablen $x$ ihren Typ $\Gamma(x)$ zu.
 
 Das Ableiten einer Typisierung für einen Ausdruck nennt man \textbf{Typinferenz}\xindex{Typinferenz}.
 Man schreibt: $\vdash(\lambda x.2): \alpha \rightarrow \text{int}$.
 
 Bei solchen Ableitungen sind häufig viele Typen möglich. So kann der Ausdruck
-\[\lambda x.2\]
-Mit folgenderweise typisiert werden:
+\[\lambda x.\ 2\]
+folgenderweise typisiert werden:
 \begin{itemize}
-	\item $\vdash(\lambda x.2): \text{bool} \rightarrow int$
-	\item $\vdash(\lambda x.2): \text{int} \rightarrow int$
-	\item $\vdash(\lambda x.2): \text{Char} \rightarrow int$
-	\item $\vdash(\lambda x.2): \alpha \rightarrow int$
+	\item $\vdash(\lambda x.\ 2): \text{bool} \rightarrow int$
+	\item $\vdash(\lambda x.\ 2): \text{int} \rightarrow int$
+	\item $\vdash(\lambda x.\ 2): \text{Char} \rightarrow int$
+	\item $\vdash(\lambda x.\ 2): \alpha \rightarrow int$
 \end{itemize}
 
 In der letzten Typisierung stellt $\alpha$ einen beliebigen Typen dar.
 
+Wichtig ist , dass man sich von unten nach oben arbeitet.
+
+\begin{beispiel}[Typinferenz\footnotemark]
+    Typisieren Sie den Term
+    \[\lambda a.\ a\ \text{true}\]
+    unter Verwendung der Regeln \verb+Var+, \verb+Abs+ und \verb+App+.
+
+    \[\ABS: \frac{\APP \frac{\VAR \frac{(a:\alpha_2)(a) = \alpha_4}{a: \alpha_2 \vdash a: \alpha_4} \;\;\;\;\;\; a: \alpha_2 \vdash \text{true}: \text{bool}}{a: \alpha_2 \vdash a\ \text{true}: \alpha_3}}{\vdash \lambda a.\ a\ \text{true}: \alpha_1}\]
+\end{beispiel}
+\footnotetext{Dieses Beispiel stammt aus der Klausur vom WS2013/2014}
+
 \section{Typsystem}
 \begin{definition}[Typsystem $\Gamma \vdash t: T$\footnotemark]\label{def:typsystem-t1}\xindex{Typregel}\xindex{Typsystem}\xindex{APP@$\APP$}\xindex{ABS@$\ABS$}\xindex{VAR@$\VAR$}\xindex{CONST@$\CONST$}%
-	Ein Typkontext $\Gamma$ ordnet jeder freien Variable $x$ einen Typ $\Gamma(x)$
-	durch folgende Regeln zu:
+	Ein Typsystem besteht aus einem Typkontext $\Gamma$ und folgenden Regeln:
 
 	\begin{align*}
 		\CONST:&\frac{c \in \text{Const}}{\Gamma \vdash c: \tau_c}\\
@@ -129,7 +139,7 @@ ist eine polymorphe Hilfsfunktion, da sie beliebige Werte auf 2 Abbildet.
 Auch solche Ausdrücke sollen typisierbar sein.
 
 Die Kodierung 
-\[\text{let} x = t_1 \text{ in } t_2\]
+\[\text{let } x = t_1 \text{ in } t_2\]
 ist bedeutungsgleich mit
 \[(\lambda x.\ t_2) t_1\]
 
@@ -146,6 +156,11 @@ wird
 \[\text{let} x = t_1 \text{ in } t_2\]
 als neues Konstrukt im $\lambda$-Kalkül erlaubt.
 
+Der Term
+\[\text{let } x = t_1 \text{ in } t_2\]
+ist bedeutungsgleich zu
+\[\lambda x.\ (t_2)\ t_1\]
+
 \begin{definition}[Typschema]\xindex{Typschema}%
     Ein Typ der Gestalt $\forall \alpha_1.\ \forall \alpha_2.\ \dots\ \forall \alpha_n. \tau$
     heißt \textbf{Typschema}. Es bindet freie Variablen $\alpha_1, \dots, \alpha_n$

documents/Programmierparadigmen/X10.tex

@@ -40,7 +40,7 @@ Der Befehl \texttt{x10c HelloWorld.x10} erstellt eine ausführbare Datei namens
 \inputminted[numbersep=5pt, tabsize=4, frame=lines, label=HelloWorld.x10]{cpp}{scripts/x10/HelloWorld.x10}
 
 \section{Syntax}
-Genau wie Scala nutzt X10 \texttt{val}\xindex{val} und \texttt{var}\xindex{var}, wobei \texttt{val} für
+Genau wie Scala nutzt X10 \texttt{val}\xindex{val (X10)@\texttt{val} (X10)} und \texttt{var}\xindex{var (X10)@\texttt{var} (X10)}, wobei \texttt{val} für
 \enquote{value} steht und ein unveränderbarer Wert ist. \texttt{var} hingegen
 steht für \enquote{variable} und ist veränderbar.
 
@@ -71,7 +71,7 @@ Closres werden unterstützt:
 Durch \texttt{async S} kann das Statement \texttt{S} asynchron ausgeführt werden.
 Das bedeutet, dass ein neuer Kindprozess (eine Kind-Aktivität) erstellt wird, die
 \texttt{S} ausführt. Dabei wird nicht auf das Beenden von \texttt{S} gewartet.
-Will man das, so muss \texttt{finish}\xindex{finish} vor das Statement gestellt werden.
+Will man das, so muss \texttt{finish}\xindex{finish (X10)@\texttt{finish} (X10)} vor das Statement gestellt werden.
 
 \subsection{atomic}\xindex{atomic}%
 Durch \texttt{atomic S} wird das Statement \texttt{S} atomar ausgeführt. Auch
@@ -79,7 +79,7 @@ Methoden können atomar gemacht werden.
 
 \inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/x10/atomic-example.x10}
 
-\subsection[Bedingtes Warten]{Bedingtes Warten\footnote{WS 2013/2014, Kapitel 43, Folie 22}}\xindex{when}%
+\subsection[Bedingtes Warten]{Bedingtes Warten\footnote{WS 2013/2014, Kapitel 43, Folie 22}}\xindex{when (X10)@\texttt{when} (X10)}%
 Durch \texttt{when (E) S} kann eine Aktivität warten, bis die Bedingung \texttt{E}
 wahr ist um dann das Statement \texttt{S} auszuführen.
 
@@ -117,7 +117,7 @@ Arrays werden in X10 wie folgt definiert:
 
 Das ergibt den Array \texttt{[ 0, 2, 4, 6, 8 ]}.
 
-\subsection{struct}\xindex{struct}%
+\subsection{struct}\xindex{struct (X10)@\texttt{struct} (X10)}%
 In X10 gibt es, wie auch in C, den Typ \texttt{struct}. Dieser erlaubt im Gegensatz
 zu Objekten keine Vererbung, kann jedoch auch interfaces implementieren.