2.2-haskell_defs.tex

\documentclass[alsotrans,beameroptions={aspectratio=169}]{beamerswitch}
\usepackage{fprog}

\title{Дефиниране на функции в Haskell}

\date{13 ноември 2024 г.}

\lstset{language=Haskell,style=Haskell}

\begin{document}

\begin{frame}
  \titlepage
\end{frame}

\section{Разглеждане на случаи}

\begin{frame}[fragile]
  \frametitle{Разглеждане на случаи}

  Можем да дефинниране на функции с разглеждане на случаи по параметрите.\\
  Условието на всеки случай се нарича \textbf{пазач}.
  \begin{itemize}
    \item{} <име> \{<параметър>\}\\
      \hspace{3ex} \{ \tta| <пазач> \tta= <израз> \}$^+$
      \pause
    \item{} <име> <параметър$_1$> <параметър$_2$> ... <параметър$_k$>\\
      \hspace{3ex} \tta| <пазач$_1$> \tta= <израз$_1$>\\
      \hspace{3ex} \ldots\\
      \hspace{3ex} \tta| <пазач$_n$> \tta= <израз$_n$>\\
      \pause
    \item ако <пазач$_1$> е \lst{True} връща <израз$_1$>, а ако е \lst{False}:
    \item \ldots
    \item ако <пазач$_n$> е \lst{True} връща <израз$_n$>, а ако е \lst{False}:
    \item \alert{грешка!}
      \pause
    \item За удобство \lst{Prelude} дефинира \lst{otherwise = True}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Разглеждане на случаи --- примери}

\begin{lstlisting}
fact n
  | n == 0  = 1
  | n > 0   = n * fact (n - 1)
  @\onslide<6->{| n < 0\hspace{3.7ex}= error "подадено отрицателно число"}@
\end{lstlisting}
\onslide<+->
\begin{itemize}[<+->]
\item \evalstoerrp{fact (-5)}
\item добра практика е да имаме изчерпателни случаи
\item можем да използваме стандартната функция \lst{error}
\end{itemize}
\onslide<+->
\onslide<+->
\begin{lstlisting}
grade x
  | x >= 5.5    = "Отличен"
  | x >= 4.5    = "Много добър"
  | x >= 3.5    = "Добър"
  | x >= 3      = "Среден"
  | otherwise   = "Слаб"
\end{lstlisting}
\end{frame}

\section{Локални дефиниции}

\begin{frame}
  \frametitle{Локални дефиниции с \tt{let}}

  \begin{itemize}
  \item \tta{let} \{ <дефиниция> \}$^+$\\
    \tta{in} <тяло>
    \pause
  \item
    \begin{tabular}[t]{@{}ll}
      \tta{let}&<дефиниция$_1$>\\
               &<дефиниция$_2$>\\
               &\ldots\\
               &<дефиниция$_n$>\\
      \multicolumn2{@{}l}{\tta{in} <тяло>}
    \end{tabular}
    \pause
  \item{} <дефиниция$_i$> се въвеждат едновременно
  \item областта на действие на дефинициите е само в рамките на \lst{let} конструкцията
  \item може да са взаимно рекурсивни
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Примери за \tt{let}}

  \begin{itemize}[<+->]
  \item \evalsto{let x = 5 in x + 3}8
  \item \evalstops{%
      \begin{tabular}[t]{@{}l@{ }l@{}}
        \lst{let}&\tt{f x = y + x}\\
           &\tt{y = 7}\\
         \lst{in}&\tt{f 2 * y}
      \end{tabular}}{63}
  \item \tt{%
    \begin{tabular}[t]{@{}l@{ }l@{ }l@{}}
      fact2 n = &\lst{let} fact n = &\lst{if} n == 0 \lst{then} 1\\
                &             &\lst{else} n * fact (n-1)\\
                &\lst{in} (fact n)\^{}2&
    \end{tabular}}
  \item В интерактивен режим (GHCi) \lst{let} може да се използва без \lst{in} за въвеждане на нови дефиниции
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Локални дефиниции с \tt{where}}

  \begin{itemize}
  \item
    % TODO: може ли да се направи без таблица?
    \begin{tabular}[t]{@{}l@{\hspace{5ex}}ll}
      \multicolumn3{@{}l}{<дефиниция-на-функция>}\\
      &\tta{where}&\{ <дефиниция> \}$^+$
    \end{tabular}
    \pause
  \item
    \begin{tabular}[t]{@{}l@{\hspace{5ex}}ll}
      \multicolumn3{@{}l}{<дефиниция-на-функция>}\\
      &\tta{where}&<дефиниция$_1$>\\
      &&<дефиниция$_2$>\\
      &&\ldots\\
      &&<дефиниция$_n$>\\
    \end{tabular}
    \pause
  \item{} <дефиниция$_i$> се въвеждат едновременно
  \item областта на действие на дефинициите е само в рамките на дефиницията на <функция>
  \item може да са взаимно рекурсивни
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Примери за \tt{where}}

\begin{lstlisting}
sumLastDigits n = lastDigit n + lastDigit (stripDigit n)
 where lastDigit  = (`mod` 10)
       stripDigit = (`div` 10)
\end{lstlisting}
\pause
\begin{lstlisting}
quadratic a b c
 | a == 0     = "линейно уравнение"
 | d > 0      = "две реални решения"
 | d == 0     = "едно реално решение"
 | otherwise  = "няма реални решения"
 where d = b^2 - 4*a*c
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Пример за комбиниране на \tt{let} и \tt{where}}

\begin{lstlisting}
area x1 y1 x2 y2 x3 y3 =
   let a = dist x1 y1 x2 y2
       b = dist x2 y2 x3 y3
       c = dist x3 y3 x1 y1
       p = (a + b + c) / 2
   in sqrt (p * (p - a) * (p - b) * (p - c))
   where dist u1 v1 u2 v2 = sqrt (du^2 + dv^2)
          where du = u2 - u1
                dv = v2 - v1
\end{lstlisting}
\end{frame}

\begin{frame}
  \frametitle{Сравнение на \tt{let} и \tt{where}}

  \begin{itemize}[<+->]
  \item \lst{let} е израз, който може да участва във всеки израз
  \item \lst{where} може да се използва само в рамките на дефиниция
  \item \lst{where} дефинициите са видими при всички случаи с пазачи
  \item \lst{let} са удобни когато има само едно <тяло>
  \item стилистична разлика:
    \begin{itemize}
    \item с \lst{let} помощните дефиниции се дават първи
    \item с \lst{where} акцентът пада върху основната дефиниция
    \end{itemize}
  \end{itemize}
\end{frame}

\section{Двумерен синтаксис}

\begin{frame}[fragile]
  \frametitle{Подравняване на дефинициите}

  \begin{columns}[onlytextwidth]
    \begin{column}{0.35\textwidth}
\begin{lstlisting}
let h = f + g
    b x = 2
in  b h
\end{lstlisting}
    \end{column}
    \pause
    \begin{column}{0.3\textwidth}
      а защо не:
    \end{column}
    \begin{column}{0.35\textwidth}
\begin{lstlisting}
let h = f + g b
    x = 2
in  b h
\end{lstlisting}
    \end{column}
  \end{columns}
  \vspace{1em}
\onslide<+->
\begin{itemize}[<+->]
\item \alert{Подравняването в Haskell има значение!}
\item Обхватът на блок от дефиниции се определя от това как са подравнени.
\item Дефинициите \textbf{точно подравнени} по първата са в същия блок
\item Дефинициите \textbf{вдясно} от първата са в нов вътрешен блок
\item Дефинициите \textbf{вляво} от първата са във външния блок
\end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Двумерен синтаксис --- пример}
  % TODO: може ли да стане по-лесно с TikZ?
{\ttfamily
\begin{tabular}{|lllll|}
\hline
\multicolumn 5{|l|}{area x1 y1 x2 y2 x3 y3 =}\\[0.5em]
\cline{3-4}
   &let &\multicolumn 2{|l|}{a = dist x1 y1 x2 y2}&\\
      &&\multicolumn 2{|l|}{b = dist x2 y2 x3 y3}&\\
      &&\multicolumn 2{|l|}{c = dist x3 y3 x1 y1}&\\
      &&\multicolumn 2{|l|}{p = (a + b + c) / 2}&\\
\cline{3-4}&&&&\\
   &\multicolumn 4{l|}{in sqrt (p * (p - a) * (p - b) * (p - c))}\\[0.5em]
\cline{3-5}
   &where &\multicolumn 3{|l|}{dist u1 v1 u2 v2 = sqrt (du\^{}2 + dv\^{}2)}\\
\cline{4-4}
          &&\multicolumn 1{|l}{where} &\multicolumn 1{|l|}{du = u2 - u1}&\\
          &&\multicolumn 1{|l}{}&\multicolumn 1{|l|}{dv = v2 - v1}&\\
\cline{4-4}
&&\multicolumn 3{|l|}{}\\
\cline{3-5}&&&&\\
\hline
\end{tabular}}
\end{frame}

\begin{frame}
  \frametitle{Алтернативен синтаксис за блокове}
  \begin{itemize}[<+->]
  \item Всъщност подравняването е синтактична захар за блок в Haskell
  \item \tta\{ \{ <дефиниция> \tta; \} \tta\}
  \item \tta\{ <дефиниция$_1$> \tta; \ldots <дефиниция$_n$> [\tta;] \tta\}
  \item Интуитивни правила:
    \begin{itemize}
    \item при първия символ на дефиниция --- запомни позицията и сложи \tta\{
    \item новият ред е подравнен по първия --- сложи \tta;
    \item новият ред е по-наляво --- сложи \tta\}
    \item новият ред е по-надясно --- не слагай нищо, счита се за продължение на предния ред
    \end{itemize}
  \item Пазачите не използват синтаксис за блокове, можем безопасно да ги пишем и на един ред:
  \item \tt{fact n | n == 0 = 1 | otherwise = n * fact (n-1)}
  \end{itemize}
\end{frame}

\section{Образци}

\begin{frame}[fragile]
  \frametitle{Поредица от равенства}

  \sizeboth\small
  Можем да дефинираме функция с поредица от равенства:
\begin{lstlisting}
fact 0 = 1
fact n = n * fact (n-1)
\end{lstlisting}
  \pause
  Можем да имаме произволен брой равенства...
\begin{lstlisting}
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)
\end{lstlisting}
  \pause
  \ldots или варианти за различните параметри
\begin{lstlisting}
gcd 0 0 = error "@няма най-голям общ делител@"
gcd x 0 = x
gcd 0 y = y
gcd x y
 | x > y     = gcd (x-y) y
 | otherwise = gcd x (y-x)
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Образци}

  \begin{itemize}[<+->]
  \item Как се разбира кое равенство да се използва?
  \item Видът на формалните параметри наричаме \alert{образец}
  \item Търси се на кой образец пасва фактическия параметър
  \item Избира се първият образец \alert{отгоре надолу}
  \item Видове образци:
    \begin{itemize}
    \item \textbf{литерали} --- пасват при точно съвпадение
    \item \textbf{променливи} --- пасват винаги
    \item \textbf{анонимен образец \tt\_} ---  пасва винаги без да свързва фактическата стойност с име
    \end{itemize}
  \item Пример:
    \begin{onlyenv}<-9>
\begin{lstlisting}
False && _ = False
_     && b = b
\end{lstlisting}
    \end{onlyenv}
    \begin{onlyenv}<10->
\begin{lstlisting}
(&&) False _ = False
(&&) _     b = b
\end{lstlisting}
    \end{onlyenv}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Повторение на променливи}
  \begin{itemize}[<+->]
  \item Можем ли да напишем
\begin{lstlisting}
gcd 0 0 = error "@няма най-голям общ делител@"
gcd x 0 = x
gcd 0 y = y
@\alert{gcd x x = x}@
gcd x y
 | x > y     = gcd (x-y) y
 | otherwise = gcd x (y-x)
\end{lstlisting}
  \item \alert{Не!}
  \item Всички променливи в образците трябва да са уникални
  \item Няма унификация, както в Пролог
    \begin{itemize}
    \item Има езици за функционално и логическо програмиране, в които това е позволено (напр. Curry)
    \end{itemize}
\end{itemize}
\end{frame}

\end{document}