mirror of
https://github.com/MartinThoma/LaTeX-examples.git
synced 2025-04-25 06:18:05 +02:00
Index verbessert; Inhalte zum Lambda-Kalkül hinzugefügt
This commit is contained in:
Martin Thoma
parent
2c4f3e97bf
commit
338b7a2b45
9 changed files with 138 additions and 50 deletions
|
|
@ -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}
|
||||
|
|
|
|||
|
|
@ -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}
|
||||
|
|
@ -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.
|
||||
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -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}
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
% \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}
|
||||
% \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?
|
||||
% Wer trinkt Wasser? Wem gehört das Zebra?
|
||||
|
||||
\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=zebraraetsel.pro]{prolog}{scripts/prolog/zebraraetsel.pro}
|
||||
% \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=zebraraetsel.pro]{prolog}{scripts/prolog/zebraraetsel.pro}
|
||||
|
||||
TODO
|
||||
% TODO
|
||||
|
||||
\section{Zahlen generieren}
|
||||
\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
|
||||
|
|
|
|||
|
|
@ -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 %
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
|
|
|
|||
|
|
@ -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$
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue