Курс Хаскель от джуна до мидла

( sphereVolume

, sphereArea

, cubeVolume

, cubeArea

) where

-- реализации...

Всё, что не экспортировано, остаётся приватным.

7.3. Импорт

import Data.List

import Data.List (nub, sort)

import Data.List hiding (nub)

import qualified Data.Map as M

import Data.Map (Map)

import Data.Map as Map

Примеры:

import qualified Data.Map as Map

Map.lookup "key" myMap

7.4. Стандартные модули, которые нужно знать

Prelude — загружается автоматически

Data.List

Data.Maybe

Data.Either

Data.Tuple

Data.Char

Data.Map (контейнер)

Data.Set

Data.Text (позже)

Control.Monad

Control.Applicative

System.IO

Text.Printf

и многие другие

7.5. Структура проекта

my-project/

src/

MyProject/

Lib.hs

Types.hs

Utils.hs

Main.hs

test/

my-project.cabal

stack.yaml (если stack)

README.md

7.6. Иерархия модулей

module MyProject.Types where

module MyProject.Utils where

module MyProject.Lib where

import MyProject.Types

import MyProject.Utils

7.7. Экспорт типов и конструкторов

data Point = Point Double Double

-- экспортировать только тип, без конструкторов:

module Geometry (Point) where

-- экспортировать всё:

module Geometry (Point(..)) where

-- или выборочно:

module Geometry (Point(Point)) where

7.8. Прагмы и расширения языка

{-# LANGUAGE OverloadedStrings #-}

{-# LANGUAGE FlexibleContexts #-}

{-# LANGUAGE InstanceSigs #-}

Пока можно не углубляться, но знать, что они существуют, нужно.

7.9. Хорошие практики организации

• Один модуль — одна ответственность

• Не делать гигантских модулей

• Явно указывать экспорт

• Использовать qualified import для больших библиотек (Map, Set, Text, ByteString)

• Избегать import *

Упражнения к главе 7

1. Создайте модуль Geometry с функциями для круга, прямоугольника и треугольника. Экспортируйте только нужное.

2. Напишите программу, которая использует qualified import Data.List и Data.Char.

3. Разделите небольшой проект на 3–4 модуля.

ЧАСТЬ II. ТИПЫ И АБСТРАКЦИИ

ГЛАВА 8. АЛГЕБРАИЧЕСКИЕ ТИПЫ ДАННЫХ (ADT)

8.1. data — создание новых типов

data Bool = False | True

deriving (Eq, Ord, Show, Read, Enum, Bounded)

data Color = Red | Green | Blue

deriving (Eq, Show)

data Point = Point Double Double

deriving (Show)

data Shape

= Circle Double

| Rectangle Double Double

| Triangle Double Double Double

deriving (Show)

8.2. Работа с ADT через паттерн-матчинг

area :: Shape -> Double

area (Circle r) = pi * r * r

area (Rectangle w h) = w * h

area (Triangle a b c) =

let p = (a + b + c) / 2

in sqrt (p * (p - a) * (p - b) * (p - c))

8.3. Record syntax

data Person = Person

{ firstName :: String

, lastName :: String

, age :: Int

, height :: Float

} deriving (Show)

p = Person "Иван" "Иванов" 30 1.80

firstName p

age p

Обновление (на самом деле создание нового):

p2 = p { age = 31 }

8.4. Параметризованные типы

data Maybe a = Nothing | Just a

data Either a b = Left a | Right b

data Tree a = Empty | Node a (Tree a) (Tree a)

8.5. Рекурсивные типы

data List a = Nil | Cons a (List a)

data Nat = Zero | Succ Nat

data Expr

= Const Int

| Add Expr Expr

| Mul Expr Expr

| Var String

8.6. newtype

newtype Zoom = Zoom Double

deriving (Show)

Отличие от data: в runtime нет накладных расходов, это просто обёртка.

newtype Identity a = Identity a

newtype Sum a = Sum a

newtype Product a = Product a

8.7. type — синонимы

type String = [Char]

type Name = String

type Point = (Double, Double)

type AssocList k v = [(k, v)]

8.8. Примеры проектирования

-- Деньги

newtype Money = Money Integer deriving (Eq, Ord, Show)

-- Идентификаторы

newtype UserId = UserId Int deriving (Eq, Show)

newtype OrderId = OrderId Int deriving (Eq, Show)

-- Состояния

data OrderStatus

= Pending

| Paid

| Shipped

| Delivered

| Cancelled

deriving (Eq, Show)

Упражнения к главе 8

1. Создайте тип данных для представления двоичного дерева поиска.

2. Напишите функции insert, lookup, toList для него.

3. Создайте тип Expr для арифметических выражений и функцию eval.

4. Используя record syntax, опишите сущность "Книга" и функции работы с ней.

5. Сделайте newtype для Email и Phone и функции валидации.

ГЛАВА 9. TYPE CLASSES: EQ, ORD, SHOW, READ, NUM И ДРУГИЕ

9.1. Что такое type class

Type class — это интерфейс (набор методов), который могут реализовывать разные типы.

class Eq a where

(==) :: a -> a -> Bool

(/=) :: a -> a -> Bool

x /= y = not (x == y) -- реализация по умолчанию

9.2. Основные классы

Eq, Ord, Show, Read, Enum, Bounded

Num, Real, Integral, Fractional, Floating, RealFrac, RealFloat

9.3. deriving

data Color = Red | Green | Blue

deriving (Eq, Ord, Show, Read, Enum, Bounded)

Теперь можно:

Red == Green

Red < Green

show Red

read "Red" :: Color

succ Red

minBound :: Color

9.4. Ручная реализация

instance Eq Color where

Red == Red = True

Green == Green = True

Blue == Blue = True

_ == _ = False

9.5. Ограничения в сигнатурах

elem :: Eq a => a -> [a] -> Bool

sort :: Ord a => [a] -> [a]

show :: Show a => a -> String

9.6. Num и компания

(+) (-) (*) negate abs signum fromInteger

Для целых: div, mod, quot, rem

Для дробных: (/), recip, fromRational

9.7. Создание собственного класса

class Describable a where

describe :: a -> String

instance Describable Bool where

describe True = "Истина"

describe False = "Ложь"

instance Describable Int where

describe n = "Число " ++ show n

9.8. Подклассы

class Eq a => Ord a where

compare :: a -> a -> Ordering

(<) (<=) (>) (>=)

max, min

class Functor f where ...

9.9. Полезные советы

• Всегда добавляйте deriving (Eq, Show) минимум.

• Для ключей Map/Set нужен Ord.

• Не злоупотребляйте Read (лучше парсеры).

• Используйте newtype + instance, когда нужно особое поведение (Monoid для Sum/Product).

Упражнения к главе 9

1. Создайте тип DaysOfWeek и реализуйте Eq, Ord, Show вручную.

2. Сделайте класс YesNo (как в LYAH) и instances для Bool, Maybe, списков, Int.

3. Реализуйте instance Num для типа, представляющего комплексные числа (упрощённо).

ГЛАВА 10. MAYBE, EITHER И ОБРАБОТКА ОШИБОК

10.1. Проблема частичных функций

head [] — runtime exception

"abc" !! 5 — exception

div 5 0 — exception

В чистом функциональном мире мы предпочитаем явно обозначать возможное отсутствие значения или ошибку.

10.2. Maybe

data Maybe a = Nothing | Just a

safeHead :: [a] -> Maybe a

safeHead [] = Nothing

safeHead (x:_) = Just x

safeDiv :: Double -> Double -> Maybe Double

safeDiv _ 0 = Nothing

safeDiv x y = Just (x / y)

10.3. Работа с Maybe

fromMaybe :: a -> Maybe a -> a

fromMaybe def Nothing = def

fromMaybe _ (Just x) = x

maybe :: b -> (a -> b) -> Maybe a -> b

isJust, isNothing

mapMaybe

catMaybes

10.4. Either

data Either a b = Left a | Right b

По соглашению Left — ошибка, Right — успех.

safeDivE :: Double -> Double -> Either String Double

safeDivE _ 0 = Left "Деление на ноль"

safeDivE x y = Right (x / y)

10.5. Цепочки вычислений

До появления do-нотации и монад приходилось писать так:

f :: Int -> Maybe Int

f x = case safeHead [1..x] of

Nothing -> Nothing

Just y -> case safeDiv (fromIntegral y) 2 of

Nothing -> Nothing

Just z -> Just (round z)

Это неудобно. Именно поэтому появились Functor, Applicative и Monad.

10.6. Either для накопления ошибок (позже)

Обычный Either останавливается на первой ошибке.

Для накопления используют Validation из пакетов (semigroupoids и т.д.) или свои типы.

10.7. Практические рекомендации

• Предпочитайте Maybe/Either исключениям в чистом коде.

• В IO-исключениях используйте Control.Exception, но аккуратно.

• Для парсинга и валидации — Either или специальные типы.

• Всегда обрабатывайте оба случая.

Упражнения к главе 10

1. Напишите safeTail, safeLast, safeInit.

2. Реализуйте функцию lookup в ассоциативном списке, возвращающую Maybe.

3. Напишите функцию, которая читает число из строки (используя reads) и возвращает Either.

4. Создайте цепочку из трёх функций, возвращающих Maybe, и обработайте все случаи.

ГЛАВА 11. ФУНКТОРЫ (FUNCTOR)

11.1. Идея

Functor — это то, что можно "отобразить" (map over).

class Functor f where

fmap :: (a -> b) -> f a -> f b

Инфиксный оператор: <$>

fmap = (<$>)

11.2. Instances

instance Functor Maybe where

fmap _ Nothing = Nothing

fmap f (Just x) = Just (f x)

instance Functor [] where

fmap = map

instance Functor (Either e) where

fmap _ (Left e) = Left e

fmap f (Right x) = Right (f x)

instance Functor ((->) r) where

fmap = (.)

11.3. Законы функторов

1. fmap id = id

2. fmap (f . g) = fmap f . fmap g

Они гарантируют, что fmap не меняет структуру, а только значения внутри.

11.4. Примеры

fmap (+1) (Just 5) -- Just 6

fmap (*2) [1,2,3] -- [2,4,6]

fmap (++ "!") (Right "Hi") -- Right "Hi!"

fmap length (Just "hello") -- Just 5

11.5. Functors вложенные

fmap (fmap (*2)) [Just 1, Nothing, Just 3]

-- [Just 2, Nothing, Just 6]

11.6. Полезные функции

void :: Functor f => f a -> f ()

(<$) :: a -> f b -> f a

Упражнения к главе 11

1. Реализуйте instance Functor для Tree a.

2. Реализуйте instance Functor для Pair a b (мапит только второй компонент).

3. Проверьте законы функтора для Maybe на нескольких примерах.

4. Напишите функцию, которая применяет функцию ко всем значениям внутри Either в списке.

ГЛАВА 12. APPLICATIVE

12.1. Зачем нужен Applicative

Functor позволяет применять функцию одного аргумента.

А что если функция находится внутри контекста, и аргументы тоже?

class Functor f => Applicative f where

pure :: a -> f a

(<*>) :: f (a -> b) -> f a -> f b

12.2. Maybe

instance Applicative Maybe where

pure = Just

Nothing <*> _ = Nothing

_ <*> Nothing = Nothing

Just f <*> Just x = Just (f x)

Пример:

(+) <$> Just 3 <*> Just 5 -- Just 8

(+) <$> Just 3 <*> Nothing -- Nothing

12.3. Списки

instance Applicative [] where

pure x = [x]

fs <*> xs = [f x | f <- fs, x <- xs]

(*) <$> [1,2,3] <*> [10,100]

-- [10,100,20,200,30,300]

12.4. Either

instance Applicative (Either e) where

pure = Right

Left e <*> _ = Left e

_ <*> Left e = Left e

Right f <*> Right x = Right (f x)

12.5. Полезные комбинаторы

liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c

liftA3 ...

*> и <*

sequenceA

traverse

for

12.6. Когда использовать

• Когда нужно применить n-арную функцию к значениям в контексте.

• Валидация нескольких полей.

• Независимые эффекты (в отличие от монад, где есть зависимость).

Упражнения к главе 12

1. Реализуйте instance Applicative для Tree (если возможно).

2. Напишите функцию, которая складывает два Maybe Int с помощью Applicative.

3. Используя liftA2, создайте функцию безопасного деления двух Maybe Double.

4. Объясните разницу между fmap и <*> .

ГЛАВА 13. МОНАДЫ (MONAD) — ОТ ТЕОРИИ К ПРАКТИКЕ

13.1. Определение

class Applicative m => Monad m where

return :: a -> m a -- то же, что pure

(>>=) :: m a -> (a -> m b) -> m b

(>>) :: m a -> m b -> m b

m >> k = m >>= \_ -> k

13.2. Maybe как монада

instance Monad Maybe where

return = Just

Nothing >>= _ = Nothing

Just x >>= f = f x

Теперь цепочки выглядят красиво:

safeHead [1,2,3] >>= \x ->

safeDiv (fromIntegral x) 2 >>= \y ->

Just (y * 10)

Или с do-нотацией:

do

x <- safeHead [1,2,3]

y <- safeDiv (fromIntegral x) 2

return (y * 10)

13.3. do-нотация

Это синтаксический сахар:

do

a <- ma

b <- mb

return (a + b)

разворачивается примерно в:

ma >>= \a ->

mb >>= \b ->

return (a + b)

13.4. Список как монада

instance Monad [] where

return x = [x]

xs >>= f = concatMap f xs

do

x <- [1,2,3]

y <- [10,20]

return (x * y)

-- [10,20,20,40,30,60]

Это похоже на list comprehension.

13.5. Either как монада

instance Monad (Either e) where

return = Right

Left e >>= _ = Left e

Right x >>= f = f x

13.6. Законы монад

1. return a >>= f ≡ f a

2. m >>= return ≡ m

3. (m >>= f) >>= g ≡ m >>= (\x -> f x >>= g)

13.7. Полезные функции

mapM, mapM_

forM, forM_

sequence, sequence_

when, unless

join

liftM, liftM2 (устаревают в пользу <$> и liftA2)

filterM

foldM

replicateM

13.8. Writer, Reader, State — краткий обзор

Позже, когда понадобится:

• Reader — передача окружения

• Writer — накопление лога

• State — изменяемое состояние в чистом виде

• RWS — комбинация

В реальном коде часто используют mtl или transformers.

13.9. Практический пример — безопасные вычисления

type Error = String

type Result a = Either Error a

safeDiv :: Double -> Double -> Result Double

safeDiv _ 0 = Left "деление на ноль"

safeDiv x y = Right (x / y)

compute :: Double -> Double -> Double -> Result Double

compute a b c = do

x <- safeDiv a b

y <- safeDiv x c

return (y + 1)

Упражнения к главе 13

1. Перепишите цепочку Maybe без do-нотации и с do-нотацией.

2. Напишите функцию, которая берёт список Maybe и возвращает Maybe списка (sequence).

3. Реализуйте mapM самостоятельно через рекурсию.

4. Напишите небольшой "калькулятор" на Either, который поддерживает +, -, *, / и обрабатывает ошибки.

ЧАСТЬ III. ПРАКТИКА И УГЛУБЛЕНИЕ (К УРОВНЮ MIDDLE)

ГЛАВА 14. ВВОД-ВЫВОД (IO) И РАБОТА С ФАЙЛАМИ

14.1. Почему IO особенный

IO a — это описание действия, которое, будучи выполненным, произведёт значение типа a (и, возможно, побочные эффекты).

main :: IO ()

14.2. Основные действия

putStr, putStrLn, putChar

getLine, getChar, getContents

print -- putStrLn . show

readFile, writeFile, appendFile

interact

14.3. do-нотация в IO

main = do

putStrLn "Как вас зовут?"

name <- getLine

putStrLn $ "Привет, " ++ name ++ "!"

14.4. return и pure в IO

return "hello" :: IO String

14.5. Работа с файлами

main = do

content <- readFile "input.txt"

writeFile "output.txt" (map toUpper content)

14.6. Ленивый vs строгий IO

readFile — ленивый (может привести к проблемам с блокировками файлов).

Для больших файлов и продакшена лучше использовать Data.Text.IO или ByteString + strict.

14.7. Исключения в IO

import Control.Exception

try, catch, handle, bracket, finally

bracket — очень важный комбинатор для ресурсов:

bracket

(openFile "file.txt" ReadMode)

hClose

(\h -> do ...)

14.8. Аргументы командной строки

import System.Environment

main = do

args <- getArgs

prog <- getProgName

...

14.9. Случайные числа, время и т.д.

import System.Random

import Data.Time

Упражнения к главе 14

1. Напишите программу, которая читает файл и выводит количество строк, слов и символов.

2. Сделайте интерактивный todo-list в консоли (добавление, просмотр, удаление).

3. Напишите программу, которая копирует файл.

4. Обработайте случай отсутствия файла с помощью catch.

ГЛАВА 15. ЛЕНИВОСТЬ, СТРОГОСТЬ И ПРОИЗВОДИТЕЛЬНОСТЬ

15.1. Ленивость по умолчанию

Выражение не вычисляется, пока его значение не понадобится.

Создаются thunk'и.

15.2. Проблемы ленивости

• Утечки памяти (накопление больших цепочек thunk'ов)

• Непредсказуемое использование памяти

• Сложность рассуждения о производительности

15.3. Средства контроля

seq :: a -> b -> b

($!) :: (a -> b) -> a -> b

BangPatterns: f !x = ...

StrictData

foldl' вместо foldl

deepseq / force

15.4. Пример утечки

sum [1..10000000] с foldl (+) 0 может съесть много памяти.

foldl' (+) 0 — нормально.

15.5. Профилирование

ghc -O2 -prof -fprof-auto Program.hs

./Program +RTS -p

15.6. Рекомендации

• Используйте foldl' для свёрток.

• Для больших структур данных смотрите в сторону strict-версий или unboxed types.

• Не бойтесь ! в record-полях, когда нужна строгость.

• Измеряйте, а не гадайте.

Упражнения к главе 15

1. Сравните foldl и foldl' на большом списке (по времени и памяти).

2. Напишите строгую версию списка (data StrictList a = SNil | SCons !a !(StrictList a)).

3. Используйте seq, чтобы заставить вычисление произойти.

ГЛАВА 16. ТЕСТИРОВАНИЕ (HUNIT, QUICKCHECK, TASTY)

16.1. Зачем тестировать

Даже с мощной системой типов нужны тесты.

16.2. HUnit — юнит-тесты

import Test.HUnit

test1 = TestCase (assertEqual "описание" ожидаемое реальное)

16.3. QuickCheck — property-based testing

import Test.QuickCheck

prop_reverse :: [Int] -> Bool

prop_reverse xs = reverse (reverse xs) == xs

quickCheck prop_reverse

16.4. tasty — современный фреймворк

Объединяет HUnit, QuickCheck, SmallCheck и другие.

16.5. Организация тестов в проекте

test-suite в cabal-файле.

16.6. Полезные практики

• Пишите свойства, а не только примеры.

• Используйте Arbitrary instances.

• Тестируйте граничные случаи.

• Интегрируйте тесты в CI.

Упражнения к главе 16

1. Напишите QuickCheck-свойства для своих функций сортировки и поиска.

2. Создайте HUnit-тесты для функций работы с Maybe/Either.

3. Соберите небольшой test-suite с tasty.

ГЛАВА 17. ПАРАЛЛЕЛИЗМ И КОНКУРЕНТНОСТЬ

17.1. Разница

Parallelism — использование нескольких ядер для ускорения.

Concurrency — управление несколькими потоками выполнения (даже на одном ядре).

17.2. parallel пакет

import Control.Parallel.Strategies

parMap, using, rpar, rseq, parList и т.д.

17.3. async

import Control.Concurrent.Async

concurrently, mapConcurrently, race, withAsync

17.4. STM (Software Transactional Memory)

import Control.Concurrent.STM

Очень мощная абстракция для безопасной работы с разделяемым состоянием.

17.5. Базовые примитивы

forkIO, MVar, Chan, QSem и т.д.

17.6. Рекомендации

• Для чистых вычислений — Strategies / parallel.

• Для IO-конкурентности — async.

• Для сложного разделяемого состояния — STM.

• Избегайте голых MVar, если можно обойтись более высокоуровневыми инструментами.

Упражнения к главе 17

1. Распараллельте вычисление тяжёлой чистой функции на списке.

2. Напишите программу, которая одновременно качает несколько URL (с помощью async и http-client).

3. Создайте простой пример с STM.

ГЛАВА 18. ПАРСЕРЫ И РАБОТА С ТЕКСТОМ

18.1. Почему не regex и read

Для серьёзного парсинга нужны комбинаторы.

18.2. Attoparsec / Megaparsec

Megaparsec — более удобный и информативный в ошибках.

Attoparsec — очень быстрый (особенно с ByteString).

18.3. Базовые идеи

satisfy, char, string, takeWhile, many, some, choice, (<|>), try

18.4. Пример простого парсера

parseNumber = ...

parseExpr = ...

18.5. Работа с Text и ByteString

Data.Text

Data.Text.Encoding

Data.ByteString

Data.ByteString.Lazy

18.6. JSON — Aeson

decode, encode, FromJSON, ToJSON

deriveJSON

Упражнения к главе 18

1. Напишите парсер простых арифметических выражений.

2. Спарсите CSV-файл.

3. Напишите FromJSON / ToJSON для своего типа данных.

ГЛАВА 19. ЛУЧШИЕ ПРАКТИКИ, СТИЛЬ КОДА И АРХИТЕКТУРА

19.1. Стиль

• Следуйте Hindley-Milner style guide / style guide от Johan Tibell / Facebook и т.д.

• Имена: camelCase для функций, PascalCase для типов.

• Явные экспорты.

• Не слишком длинные строки.

• Осмысленные имена.

19.2. Организация кода

• Тонкий слой IO на границе.

• Чистая бизнес-логика внутри.

• Новые типы (newtype) для идентификаторов и единиц измерения.

• Избегайте "stringly-typed" программирования.

19.3. Обработка ошибок

• Maybe для отсутствия значения.

• Either / ExceptT для ошибок с информацией.

• Исключения — только для действительно исключительных ситуаций в IO.

19.4. Производительность

• Профилируйте.

• Используйте правильные структуры данных (Vector, HashMap, Text, ByteString).

• Strictness там, где нужно.

19.5. Документация

Haddock-комментарии.

Примеры в документации.

19.6. Архитектурные подходы

• ReaderT + IO для окружения.

• mtl-стиль или concretе monad stacks.

• Free / Final Tagless (для продвинутых).

• Effect systems (polysemy, effectful) — современный тренд.

Упражнения к главе 19

1. Возьмите свой старый код и приведите его к хорошему стилю.

2. Добавьте newtype для всех идентификаторов.

3. Разделите чистую логику и IO.

ГЛАВА 20. МИНИ-ПРОЕКТЫ И ПЕРЕХОД К МИДЛ-УРОВНЮ

20.1. Что должен уметь Middle Haskell-разработчик

• Уверенно писать чистый и IO-код.

• Понимать и использовать Functor / Applicative / Monad / Traversable / Foldable.

• Уметь проектировать ADT.

• Писать тесты (unit + property).

• Работать с текстовыми форматами и парсерами.

• Понимать основы производительности и ленивости.

• Читать чужой код на Hackage.

• Использовать Cabal/Stack, HLS, hoogle.

20.2. Мини-проекты для портфолио

1. Консольный менеджер задач с сохранением в файл / JSON.

2. Простой статический сайт-генератор.

3. Парсер и интерпретатор небольшого языка.

4. Клиент к какому-нибудь публичному API (с async и aeson).

5. Небольшая игра (текстовая RPG или тетрис в терминале).

6. Утилита командной строки с optparse-applicative.

20.3. Дальнейшее развитие

• Книги: "Haskell in Depth", "Parallel and Concurrent Programming in Haskell", "Algebra-Driven Design".