\documentclass[14pt]{beamer}
\usepackage{beamerthemeshadow}
%\usepackage{beamerthemesidebar}
\usepackage{graphicx}

\usepackage{polski}
\usepackage[latin2]{inputenc}


\newcommand{\net}[0]{{\tt .NET}}
\newcommand{\kw}[1]{{\textcolor{kwcolor}{\tt #1}}}

\definecolor{kwcolor}{rgb}{0.2,0.4,0.0}
\definecolor{lgray}{rgb}{0.8,0.8,0.8}

\title{Metaprogramowanie w Nemerle}
\author{Kamil Skalski}
\institute{Instytut Informatyki Uniwersytetu Wroc³awskiego}
\date{17 kwietnia 2004 roku}


\begin{document}

\section{Wprowadzenie}

\frame{\titlepage}

\frame{
\frametitle{Metaprogramowanie}
\begin{itemize}
  \item operacje na drzewach sk³adniowych wyra¿eñ i typów
  \item homogeniczny meta-jêzyk
  \item wykonywanie dowolnych obliczeñ w fazie kompilacji (czytanie plików, zagl±danie
        do bazy danych, itp.)
  \item integracja z procesem kompilacji (³adowane dynamicznie modu³y kompilatora)
\end{itemize}
}


\frame{
\frametitle{Co zyskujemy?}

\begin{itemize}
  \item elegancki sposób na rozszerzanie sk³adni jêzyka
  \item analiza kodu i danych dostêpnych w czasie kompilacji
  \item inlining, partial evaluation i optymalizacje
  \item specjalizowane pod-jêzyki ({\tt printf}, wyra¿enia regularne, SQL)
  \item implementacja interpreterów
\end{itemize}
}

\frame[containsverbatim]{
\frametitle{Przyk{\l}adowe u¿ycie makr}

\begin{verbatim}
def s = 10;
sql_loop ("SELECT name FROM Produkt"
          " WHERE Produkt.size = $s")
  printf ("%s ma rozmiar: %d\n", name, s);
...
tab [Random()] <-> tab[Random()];
...
def r = rotate ((1.1, 0.3), Math.Pi / 2.0)
\end{verbatim}
}


\frame{
\frametitle{Dlaczego komplikowaæ semantykê programu?}

\begin{itemize}
  \item ka¿dy ma mo¿liwo¶æ rozbudowywania jêzyka
  \item u¿ycie makr jest identyczne do wywo³ania funkcji 
  \item skracaj± kod niedaj±cy siê ³atwo rozdzieliæ na funkcje 
  \item ewentualne b³êdy w meta-programie wykrywane s± w czasie kompilacji
\end{itemize}
}

\section{Operowanie na kodzie programu}

\frame[containsverbatim]{
\frametitle{Drzewa sk{\l}adniowe jako dane}

\begin{verbatim}
macro foreach (i : name, coll, body) { 
<[
  def enumerator = $coll.GetEnumerator ();
  def loop () {
    when (enumerator.MoveNext ()) {
      def $(i : name) = enumerator.Current;
      $body;
      loop (); 
    }
  }; loop ()
]> }
\end{verbatim}
}

\section{Symbole w przekszta{\l}canym kodzie}

\frame[containsverbatim]{
\frametitle{Higiena makr}
Symbole wprowadzane przez makro nie koliduj± z nazwami zdefiniowanymi w kontek¶cie
jego u¿ycia, ani w kodzie przekazanym mu przez parametry. 

\begin{itemize}
\item ka¿de wykonanie makra ma swój unikalny ,,kolor'', którym oznaczane s± u¿yte 
  w nim identyfikatory
\item mo¿liwe jest ³amanie higieny np. poprzez wykorzystanie koloru z miejsca u¿ycia makra
  (wprowadzane symbole pochodz± wtedy z kontekstu wywo³ania makra)
\end{itemize}
}

\frame[containsverbatim]{
\frametitle{Koliduj±ce symbole}
\begin{verbatim}
macro identity (e) { 
  <[ def f (x) { x }; f ($e) ]> 
}
\end{verbatim}

U¿ycie \emph{identity} w kontek¶cie

\begin{verbatim}
def f (y) { y + 1 }; identity (f (2))
\end{verbatim}

zostaje przekszta³cone na

\begin{verbatim}
def f_23 (x_23) { x_23 }; f_23 (f (2))
\end{verbatim}
}

\frame[containsverbatim]{
\frametitle{Kontrolowane ³amanie higieny}
\begin{verbatim}
print ("Ala ma $k kotów.")
\end{verbatim}

Podczas przekszta³cenia na

\begin{verbatim}
Write ("ala ma " + k.ToString () + " kotów")
\end{verbatim}

tworzone jest odwo³anie do zmiennej \emph{k} pochodz±cej z miejsca u¿ycia 
\emph{print}. Dziêki u¿yciu funkcji \emph{UseSiteSymbol("k")} wygenerowany
symbol w kodzie wynikowym ma ten sam kolor co wywo³anie makra \emph{print}.
}

\frame[containsverbatim]{
\frametitle{Wi±zanie definicji globalnych}
\begin{verbatim}
using System.Text.RegularExpressions;
...
<[ def r = Regex ("a+.*") ]>
\end{verbatim}

Otwarte przestrzenie nazw s± zapamiêtane w symbolach, dziêki czemu wygenerowany kod
ma postaæ

\begin{verbatim}
def r = System.Text.RegularExpressions.
        Regex ("a+.*")
\end{verbatim}

\emph{UseSiteSymbol} zmienia tak¿e kontekst symboli globalnych.
}

\section{Odwo{\l}ywanie siê do procedur kompilatora}

\frame[containsverbatim]{
\frametitle{Typowanie drzew sk{\l}adniowych}
\begin{verbatim}
macro if (cond, e1, e2) {  
  def tcond = TypedExpr (cond);
  def te1 = TypedExpr (e1);
  def te2 = TypedExpr (e2);
  if (tcond.Type == <[ ttype: bool ]> ) <[ 
    match ($(tcond : typed)) { 
      | true => $(te1 : typed) 
      | false => $(te2 : typed) 
    } ]>
  else
    throw Error ("condition isn't boolean") }
\end{verbatim}
}

\section{Zastosowania w tworzeniu oprogramowania}

\frame[containsverbatim]{
\frametitle{Makra na definicjach typów}
\begin{verbatim}
[SerializeBinary]
class Klient {
  ...
  Dodaj ([NotNull] t : Tranzakcja) : void
}
[MembersFrom ("Producent.xml")]
class Producent { ... }
\end{verbatim}

Atrybuty modyfikuj±ce dowolnie kod klas w czasie kompilacji.
}

\section{Podsumowanie}

\frame{
\frametitle{Status}

\begin{itemize}
  \item makra wykonywane podczas kompilacji
  \item uruchamianie procedur typowania
  \item system higieny
  \item wi±zanie symboli globalnych
  \item rozszerzenia sk³adniowe
  \item \textcolor{blue}{\tt http://nemerle.org/}
\end{itemize}
}

\frame{
\frametitle{Do zrobienia}

\begin{itemize}
  \item makra na deklaracjach typów
  \item API do procedur typuj±cych
  \item generacja kodu w czasie wykonania programów
  \item kontrola typów w kodzie tworzonym przez cytowanie
  \item Aspects-Oriented Programming
\end{itemize}
}

\end{document}

% vim: language=polish