lecture8_laziness.tex

\documentclass[11pt]{beamer}
\input{lecture_preamble.tex}

\title{Лекция 8: ленивость}

\begin{document}
\begin{frame}[plain]
  \maketitle
\end{frame}

\begin{frame}[fragile]
  \frametitle{Передача по значению}
  \begin{itemize}
    \item Как вычисляется выражение вида \haskinline|f(g(x, y), h(z))| в привычных языках?
          \pause
    \item Сначала вычисляются аргументы \haskinline|g(x, y)| и \haskinline|h(z)| (гарантированно в этом порядке или нет), потом их значения передаются в \haskinline|f|.
    \item Это называется передачей аргументов по значению.
    \item Для вычисления выражения нужно вычислить все подвыражения.
    \item Исключения в C-подобных языках?
          \pause
    \item \haskinline|&&|, \haskinline{||}, \haskinline|? :|.
          \pause
    \item В них вычисляется первый операнд, а второй (и третий для \haskinline|? :|) "--- только если необходимо.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Передача по имени}
  \begin{itemize}
    \item Как можно сделать по-другому?
          \pause
    \item Макросы в C "--- каждое использование аргумента заменяется на переданное выражение (а не на его значение).
    \item И это рекурсивно: макросы в этом определении тоже будут заменены на своё определение.
    \item Это передача по имени (почти).
          \pause
    \item У настоящей передачи по имени нет таких проблем со скобками, как в макросах C.
          \pause
    \item Аналогичное поведение переменных в командной строке и скриптах Windows и Linux.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Сравнение на примерах 1}
  \begin{itemize}
    \item Если рассмотреть
          \begin{haskell}
            x = 2 + 2
            y = x + x
          \end{haskell}
          то при передаче по значению будет вычислено \pause
          \begin{haskell}
            x = 4
            y = 4 + 4
          \end{haskell}
          а при передаче по имени "--- \pause
          \begin{haskell}
            x = 2 + 2
            y = (2 + 2) + (2 + 2)
          \end{haskell}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Сравнение на примерах 2}
  \begin{itemize}
    \item
          \begin{haskell}
            if1(x, y, z) = if x then y else z

            if1(true, 1, 1 / 0)
          \end{haskell}
          Что случится при передаче по значению? А по имени?
          \pause
    \item По значению: ошибка.
          \pause
    \item По имени: \haskinline|1|.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Какой порядок лучше?}
  \begin{itemize}
    \item Плюсы передачи по имени:
          \pause
          \begin{itemize}
            \item Можно избежать ошибок.
            \item Можно избежать лишних вычислений
                  \pause (представьте, что в предыдущем примере вместо \haskinline|1 / 0| вызов сложной функции).
          \end{itemize}
          \pause
    \item Главный минус:
          \pause
          \begin{itemize}
            \item Можно сделать очень много лишних вычислений.
                  \pause
            \item Как только мы используем какую-то переменную более одного раза
                  \pause (если переменные в её определении не изменились).
          \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Передача по необходимости}
  \begin{itemize}
    \item В Haskell используется передача по необходимости:
    \item Как передача по имени, но значение каждой переменной вычисляется только один раз.
          \pause
    \item Это имеет смысл потому, что все переменные неизменяемы.
          \pause
    \item При этом значения тоже не обязательно вычислять \enquote{до конца}: мы хотим, чтобы
          \begin{haskell}
            length [1/0, 1/0, 1/0]
          \end{haskell}
          возвращало \haskinline|3|.
          \pause
    \item Ленивость в том или ином виде есть во многих языках (пример: \haskinline|System.Lazy<T>| в .NET).
    \item Но в Haskell она встроена очень глубоко.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Нормальная форма}
  \begin{itemize}
    \item Выражение находится в нормальной форме, если там нет ничего, что можно вычислить (редуцировать).
    \item Примеры: \pause
          \begin{haskell}
            42
            (2, "hello")
            \x -> (x + 1)
          \end{haskell}
    \item Примеры выражений не в нормальной форме: \pause
          \begin{haskell}
            1 + 2                 
            (\x -> x + 1) 2       
            "he" ++ "llo"         
            (1 + 1, 2 + 2)
            let x = 1 in x
          \end{haskell}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Теоремы о нормальных формах в лямбда-исчислении}
  \begin{itemize}
    \item В лямбда-исчислении можно доказать:
    \item Два порядка вычисления одного выражения не могут привести к разным значениям (нормальным формам).
    \item Но может случиться, что один из них даёт значение, а другой "--- нет.
    \item Если какой-то порядок приводит к значению, то передача по имени и по необходимости тоже к нему приведут.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Слабая заголовочная нормальная форма}
  \begin{itemize}
    \item Выражение находится в слабой заголовочной нормальной форме (WHNF), если это:
          \begin{itemize}
            \item Лямбда.
            \item Литерал.
            \item Конструктор данных, возможно с аргументами.
            \item Функция от $n$ аргументов c $m<n$ аргументами.
          \end{itemize}
          Аргументы здесь "--- любые выражения \pause
          (а для НФ они тоже должны быть в НФ).
    \item Примеры: \pause
          \begin{haskell}
            (1 + 1, 2 + 2)       -- (,) (1 + 1) (2 + 2)
            \x -> 2 + 2 + x
            (1/0) : take 4 [1..]
            (+) 1
          \end{haskell}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Отложенные вычисления}
  \begin{itemize}
    \item В Haskell во время исполнения переменная может указывать не только на значение, а на невычисленное выражение (thunk).
    \item Если мы напишем
          \begin{haskell}
            x = (length [1,3], 1/0)
          \end{haskell}
          то \haskinline|x| вначале указывает именно на thunk.
    \item После этого
          \begin{haskell}
            case x of
              (y, z) -> ...
          \end{haskell}
          требует вычислить внешний конструктор \haskinline|x| (привести к WHNF), и в памяти будет \pause
          \begin{haskell}
            x: (*thunk1*, *thunk2*)  *thunk1*: length [1,3]
            y: *thunk1*              *thunk2*: 1/0
            z: *thunk2*
          \end{haskell}

  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Отложенные вычисления}
  \begin{itemize}
    \item Если это
          \begin{haskell}
            case x of
              (y, z) -> print y
          \end{haskell}
          то \haskinline|y| тоже потребуется вычислить, и получим \pause
          \begin{haskell}
            x: (2, *thunk2*)         *thunk1*: 2
            y: 2                     *thunk2*: 1/0
            z: *thunk2*
          \end{haskell}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{\haskinline|:print|}
  \begin{itemize}
    \item Мы можем увидеть частично вычисленные выражения в GHCi с помощью команд \href{https://downloads.haskell.org/~ghc/8.6.3/docs/html/users_guide/ghci.html#ghci-cmd-:print}{\haskinline|:print|} и \href{https://downloads.haskell.org/~ghc/8.6.3/docs/html/users_guide/ghci.html#ghci-cmd-:sprint}{\haskinline|:sprint|}:
          \begin{haskell}
            ghci> x = (length [1,3], 1/0 :: Double)
            ghci> :sprint x
            x = _
            ghci> case x of (y, z) -> 0
            0
            ghci> :sprint x
            x = (_,_)
            ghci> case x of (y, z) -> y
            2
            ghci> :sprint x
            x = (2,_)
          \end{haskell}
          \pause
    \item Также посмотрите \href{http://felsin9.de/nnis/ghc-vis/}{ghc-vis} (для старых GHC).
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Примеры}
  \begin{itemize}
    \item Ещё примеры:
          \pause
    \item
          \begin{haskell}
            square x = x*x
            square (square (1+1))
          \end{haskell}
    \item \haskinline|length (take 2 (filter even [1..]))|
          \pause
    \item
          \begin{haskell}
            (&&) :: Bool -> Bool -> Bool
            True  && x = x
            False && x = False
          \end{haskell}
          ведёт себя как в C автоматически.
          \pause
    \item Как определить вариант, который начинает вычисление с правого операнда?
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Минусы ленивости}
  \begin{itemize}
    \item Вроде бы можно гарантировать, что ленивые вычисления всегда делают не больше шагов, чем энергичные.
    \item Но каждый шаг занимает больше времени.
    \item Thunks могут занимать больше памяти, чем результат их вычисления (а могут и меньше).
    \item Классический пример:
          \begin{haskell}
            sum [] acc = acc
            sum (x:xs) acc = sum xs (x + acc)

            sum [1..100] 0!$\pause \rightsquigarrow$! sum 1:[2..100] 0!$\pause \rightsquigarrow$!
            sum [2..100] (1 + 0)!$\pause \rightsquigarrow$! sum 2:[3..100] (1 + 0)!$\pause \rightsquigarrow$!
            sum [3..100] (2 + (1 + 0))!$\pause \rightsquigarrow \ \ldots\ \rightsquigarrow$!
            (100 + ... + (1 + 0))!$\pause \rightsquigarrow $! 4950
          \end{haskell}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Минусы ленивости}
  \begin{itemize}
    \item Из-за этого \haskinline|foldl| "--- ловушка, практически всегда нужно либо \haskinline|foldr|, либо \haskinline|foldl'| (будет позже).
          \pause
    \item С другой стороны, заметьте, что в этом примере список \haskinline|[1..100]| никогда не появился целиком в памяти!
          \pause
    \item Ещё один интересный пример: \haskinline|length (take 2 (filter (< 1) [1..]))|.
    \item[]
      \pause
    \item Что же можно сделать?
          \pause
    \item Часто компилятор может оптимизировать ленивые вычисления (если знает, что это не изменит результата).
    \item Или...
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Строгие вычисления в Haskell: \haskinline|seq|}
  \begin{itemize}
    \item Мы можем управлять ленивостью явно.
    \item Базовый инструмент для этого: \enquote{волшебная} (её нельзя реализовать на самом Haskell) функция \haskinline|seq :: a -> b -> b|.
          \pause
    \item \haskinline|seq !$e_1$! !$e_2$!| сначала приводит $e_1$ к WHNF, а после этого возвращает $e_2$.
          \pause
    \item На практике всегда $e_1$ "--- переменная в $e_2$.
    \item Пример использования:
          \begin{haskell*}{escapeinside=||}
            f $! x = seq x (f x)
          \end{haskell*}
    \item Это аналог \haskinline|$|, только вычисляющий аргумент до WHNF перед вызовом функции.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{\haskinline|sum| через \haskinline|seq|}
  \begin{itemize}
    \item Теперь можем определить \haskinline|sum| так:\pause
          \begin{haskell*}{escapeinside=||}
            sum [] acc = acc
            sum (x:xs) acc = sum xs $! x + acc
          \end{haskell*}
    \item Или так:\pause
          \begin{haskell}
            sum [] acc = acc
            sum (x:xs) acc = let a1 = x + acc in 
                            a1 `seq` sum xs a1
          \end{haskell}
    \item И процесс вычисления:
          \begin{haskell}
            sum [1..100] 0 !$\rightsquigarrow$! sum 1:[2..100] 0 !$\pause \rightsquigarrow$!
            let a1 = 1 + 0 in a1 `seq` sum [2..100] a1 !$\pause \rightsquigarrow$!
            sum [2..100] 1 !$\rightsquigarrow$! sum 2:[3..100] 1 !$\pause \rightsquigarrow$!
            let a1 = 2 + 1 in a1 `seq` sum [3..100] a1 !$\pause \rightsquigarrow$!
            !$\rightsquigarrow\ \ldots\ \rightsquigarrow\ $!4950
          \end{haskell}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{\haskinline|foldl'|}
  \begin{itemize}
    \item Мы знаем, что сумма списка "--- частный случай свёртки.
    \item Для функций \haskinline|product|, \haskinline|minimum|, \haskinline|maximum| имеем ровно те же проблемы!
    \item Можем определить вариант \haskinline|foldl| (более общая версия в \haskinline|Data.Foldable|):
          \begin{haskell}
            foldl' :: (a -> b -> a) -> a -> [b] -> a
            foldl' f a []     = a
            foldl' f a (x:xs) = let a' = f a x
                                in a' `seq` foldl' f a' xs
          \end{haskell}
    \item \pause
          \begin{haskell}
            sum xs = foldl' (+) 0 xs
            product xs = foldl' (*) 1 xs
            minimum xs = foldl1' min xs
            ...
          \end{haskell}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Строгие переменные в образцах}
  \begin{itemize}
    \item В \haskinline|foldl'| параметр \haskinline|acc| вычисляется только до WHNF. Если мы вычисляем среднее так
          \begin{haskell}
            mean :: [Double] -> Double
            mean xs = s' / fromIntegral l'
              where (s', l') = foldl' step (0, 0) xs
                    step (s, l) a = (s + a, l + 1)
          \end{haskell}
          то в \haskinline|s| и \haskinline|l| снова накапливаются вычисления!
          \pause
    \item Включив \haskinline|BangPatterns|, сделаем их строгими:
          \begin{haskell*}{escapeinside=||}
            step (!s, !l) a = (s + a, l + 1)
          \end{haskell*}
    \item Это превращается в
          \begin{haskell}
            step (s, l) a = let s' = s + a; l' = l + 1
                            in s' `seq` l' `seq` (s', l')
          \end{haskell}
    \item Правила перевода \href{https://downloads.haskell.org/~ghc/8.6.3/docs/html/users_guide/glasgow_exts.html#recursive-and-polymorphic-let-bindings}{довольно сложные}.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Строгие поля в типах данных}
  \begin{itemize}
    \item Другой способ решить ту же проблему:
          \begin{haskellsmall*}{escapeinside=||}
            data SPair a b = SPair !a !b

            mean :: [Double] -> Double
            mean xs = s' / fromIntegral l'
            where SPair s' l' = foldl' step (0, 0) xs
                  step (SPair s l) a = SPair (s + a) (l + 1)
          \end{haskellsmall*}
          \pause
    \item Восклицательный знак означает, что любое вычисление значения с этим конструктором вычислит и эти поля (до WHNF).
    \item То есть конструктор работает как
          \begin{haskell}
            SPair a b = a `seq` b `seq` SPair' a b
          \end{haskell}
          где \haskinline|SPair'| "--- конструктор, который получится без строгих полей.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Дополнительное чтение}
  \begin{itemize}
    \item \href{https://blog.acolyer.org/2016/09/14/why-functional-programming-matters/}{Why Functional Programming Matters} (статья, написанная до появления собственно Haskell)
    \item \href{https://www.fpcomplete.com/blog/2017/09/all-about-strictness}{All About Strictness}
    \item \href{https://apfelmus.nfshost.com/articles/lazy-eval.html}{The Incomplete Guide to Lazy Evaluation}
    \item \href{https://en.wikibooks.org/wiki/Haskell/Laziness}{Laziness в Haskell Wikibook}
  \end{itemize}
\end{frame}

\end{document}