R: Створена сторінка: {{SEO|title=Haskell — функціональна мова програмування, чисті функції, типи, монади, lazy evaluation, GHC, Cabal, Stack і безпечна архітектура|description=Haskell — Wiki-стаття про чисту функціональну мову програмування Haskell. Розглянуто pure functions, immutability, lazy evaluation, referential transparency, algebraic data ty...

2026-05-08T20:29:09Z

Створена сторінка: {{SEO|title=Haskell — функціональна мова програмування, чисті функції, типи, монади, lazy evaluation, GHC, Cabal, Stack і безпечна архітектура|description=Haskell — Wiki-стаття про чисту функціональну мову програмування Haskell. Розглянуто pure functions, immutability, lazy evaluation, referential transparency, algebraic data ty...

Нова сторінка

{{SEO|title=Haskell — функціональна мова програмування, чисті функції, типи, монади, lazy evaluation, GHC, Cabal, Stack і безпечна архітектура|description=Haskell — Wiki-стаття про чисту функціональну мову програмування Haskell. Розглянуто pure functions, immutability, lazy evaluation, referential transparency, algebraic data types, pattern matching, type classes, monads, functors, applicatives, GHC, GHCi, Cabal, Stack, GHCup, Haskell Language Server, Hackage, Stackage, тестування, QuickCheck, property-based testing, web/backend, компіляцію, продуктивність, обмеження, практичне використання та місце Haskell у сучасній розробці.|keywords=Haskell, функціональне програмування, functional programming, pure functions, immutability, lazy evaluation, referential transparency, algebraic data types, pattern matching, type classes, monads, functor, applicative, GHC, GHC 9.14, GHC 9.12, Cabal, Stack, GHCup, Haskell Language Server, Hackage, Stackage, QuickCheck, property based testing, Haskell backend, Haskell web, typed functional programming, програмування Haskell|alternativeTo=імперативне програмування зі станом всюди; runtime-помилки через слабку типізацію; бізнес-логіка без математичної моделі; код без referential transparency; складні side effects без контролю; тестування лише прикладами без property-based testing; архітектура без сильних типів; обробка помилок через неявні exceptions}}

'''Haskell''' — це чиста функціональна мова програмування зі статичною типізацією, lazy evaluation, immutable data, algebraic data types, pattern matching, type classes і сильним акцентом на математичну коректність програм.

Haskell часто використовують для навчання функціональному мисленню, компіляторів, формальних моделей, financial systems, backend-сервісів, DSL, research, high-assurance code, parserів, складної бізнес-логіки й задач, де типи можуть запобігти великій кількості помилок.

<div style="background:#eef6ff;border-left:6px solid #2f80ed;padding:14px 18px;margin:16px 0;border-radius:8px;">
'''Коротко:''' Haskell — це мова, де функції чисті, дані immutable, типи дуже сильні, а side effects явно контролюються. Вона вимагає іншого мислення, але допомагає писати дуже передбачуваний код.
</div>

Офіційна сторінка Haskell описує мову як purely functional programming language із referential transparency, immutability і lazy evaluation. <ref>https://www.haskell.org/</ref>

== Головна ідея ==

Головна ідея Haskell — будувати програми як композицію чистих функцій і точно описаних типів.

У звичайному імперативному стилі програма часто змінює стан:

* змінні перезаписуються;
* об’єкти мутують;
* функції можуть змінювати глобальні дані;
* side effects приховані;
* порядок виконання дуже важливий.

У Haskell підхід інший:

* значення immutable;
* функції не змінюють світ без явного типу;
* типи описують можливі стани;
* багато помилок ловить компілятор;
* програма будується через композицію функцій.

<div style="background:#f6ffed;border-left:6px solid #27ae60;padding:14px 18px;margin:16px 0;border-radius:8px;">
'''Проста аналогія:''' Haskell змушує спочатку чітко описати “які значення можливі”, а вже потім писати код. Це схоже на креслення перед будівництвом, а не ремонт під час руху.
</div>

== Актуальний стан інструментів ==

Станом на травень 2026 року офіційна сторінка GHC показує серед останніх релізів '''GHC 9.12.4''' від 27 березня 2026 року і '''GHC 9.14.1''' від 19 грудня 2025 року. <ref>https://www.haskell.org/ghc/</ref>

Офіційна сторінка Haskell Downloads рекомендує встановлювати Haskell через '''GHCup''', який може встановити GHC, cabal-install, Stack і Haskell Language Server. <ref>https://www.haskell.org/downloads/</ref>

GHC також запровадив LTS-підхід: Haskell.org повідомляв, що GHC починає підтримувати LTS release/branch із довшим періодом підтримки, орієнтовно від двох до трьох років. <ref>https://www.haskell.org/ghc/blog/20250702-ghc-release-schedules.html</ref>

<div style="background:#fff7e6;border-left:6px solid #f2994a;padding:14px 18px;margin:16px 0;border-radius:8px;">
'''Для документації:''' у Haskell-проєктах важливо фіксувати версії GHC, Cabal/Stack і package set. Різні версії compiler і dependencies можуть суттєво впливати на build.
</div>

== GHC ==

'''GHC''' або '''Glasgow Haskell Compiler''' — головний компілятор Haskell.

GHC включає:

* compiler;
* runtime system;
* GHCi;
* optimizer;
* extensions;
* profiling support;
* documentation;
* libraries;
* package support.

GHC є фактичним стандартом для сучасного Haskell.

Офіційна сторінка GHC описує його як state-of-the-art open source compiler and interactive environment for Haskell. <ref>https://www.haskell.org/ghc/</ref>

== GHCi ==

'''GHCi''' — інтерактивне середовище Haskell.

Приклад:

<pre>
ghci
Prelude> 2 + 3
5
Prelude> map (*2) [1,2,3]
[2,4,6]
</pre>

GHCi корисний для:

* навчання;
* швидкої перевірки functions;
* type exploration;
* debugging;
* prototyping;
* REPL workflow.

== GHCup ==

'''GHCup''' — рекомендований installer і manager для Haskell toolchain.

Через GHCup можна встановлювати:

* GHC;
* cabal-install;
* Stack;
* Haskell Language Server.

Офіційна сторінка Haskell Downloads прямо рекомендує GHCup для Linux, macOS, FreeBSD, Windows або WSL2. <ref>https://www.haskell.org/downloads/</ref>

== Cabal ==

'''Cabal''' — build system і package description format для Haskell.

Cabal використовується для:

* опису packages;
* builds;
* dependencies;
* tests;
* benchmarks;
* library/executable targets;
* Hackage packages.

Типові команди:

<pre>
cabal update
cabal build
cabal test
cabal run
</pre>

Haskell documentation page містить Cabal User Guide серед основних довідників Haskell tooling. <ref>https://www.haskell.org/documentation/</ref>

== Stack ==

'''Stack''' — альтернативний build tool для Haskell.

Stack фокусується на reproducible builds і curated package sets через Stackage.

Документація Stack описує, що Stack керує GHC installations і автоматично вибирає потрібну версію GHC для проєкту. <ref>https://docs.haskellstack.org/en/stable/</ref>

Типові команди:

<pre>
stack new my-project
stack build
stack test
stack run
</pre>

== Haskell Language Server ==

'''Haskell Language Server''' або '''HLS''' — language server для редакторів.

Він дає:

* автодоповнення;
* diagnostics;
* go to definition;
* hover info;
* code actions;
* formatting;
* type information;
* інтеграцію з VS Code, Vim, Emacs та іншими редакторами.

Haskell Language Server releases підтримують конкретні версії GHC, тому сумісність HLS і GHC потрібно перевіряти. <ref>https://github.com/haskell/haskell-language-server/releases</ref>

== Hackage ==

'''Hackage''' — центральний repository Haskell packages.

Там публікуються libraries і tools.

Hackage корисний для:

* пошуку libraries;
* перегляду package documentation;
* version history;
* dependencies;
* maintainers;
* source tarballs.

Перед використанням package варто перевіряти maintenance, compatibility, license і recent releases.

== Stackage ==

'''Stackage''' — curated package set для Haskell.

Ідея Stackage — мати набір package versions, які разом проходять build.

Це допомагає зменшити dependency conflicts.

Stackage має:

* LTS snapshots;
* nightly snapshots;
* GHC version binding;
* curated ecosystem.

Наприклад, Stackage Nightly 2026-05-06 використовував GHC 9.12.4. <ref>https://www.stackage.org/nightly-2026-05-06</ref>

== Чиста функція ==

'''Чиста функція''' — функція, яка:

* для однакових inputs завжди повертає однаковий output;
* не змінює зовнішній стан;
* не має прихованих side effects.

Приклад:

<pre>
add :: Int -> Int -> Int
add a b = a + b
</pre>

Ця функція чиста: вона лише обчислює суму.

== Referential transparency ==

'''Referential transparency''' означає, що expression можна замінити його значенням без зміни поведінки програми.

Наприклад:

<pre>
add 2 3
</pre>

можна замінити на:

<pre>
5
</pre>

Це робить код передбачуванішим і полегшує reasoning.

Офіційна сторінка Haskell називає referential transparency однією з ключових властивостей мови. <ref>https://www.haskell.org/</ref>

== Immutability ==

У Haskell значення immutable за замовчуванням.

Приклад:

<pre>
x = 10
</pre>

Це не змінна у звичному імперативному сенсі. Це binding імені <code>x</code> до значення <code>10</code>.

Immutability допомагає:

* уникати випадкової зміни стану;
* спрощувати reasoning;
* краще працювати з concurrency;
* зменшувати кількість bugs.

== Lazy evaluation ==

'''Lazy evaluation''' означає, що вирази обчислюються не одразу, а коли результат справді потрібен.

Приклад:

<pre>
take 5 [1..]
</pre>

У Haskell це працює: нескінченний список <code>[1..]</code> не обчислюється повністю. Беруться лише перші 5 елементів.

<div style="background:#eef6ff;border-left:6px solid #2f80ed;padding:14px 18px;margin:16px 0;border-radius:8px;">
'''Цікаво:''' lazy evaluation дозволяє працювати з потенційно нескінченними структурами. Але вона також може створювати performance surprises, якщо не розуміти, коли саме обчислюються значення.
</div>

== Strictness ==

'''Strictness''' — протилежний підхід до lazy evaluation: значення обчислюється раніше.

У Haskell іноді потрібно явно керувати strictness, щоб уникнути:

* memory leaks;
* накопичення thunks;
* неочікуваного використання пам’яті;
* performance problems.

Для цього використовують:

* bang patterns;
* seq;
* strict data fields;
* strict libraries;
* profiling.

== Thunk ==

'''Thunk''' — відкладене обчислення.

Через lazy evaluation Haskell може створювати thunks замість негайного обчислення значень.

Це корисно для laziness, але якщо thunks накопичуються, може зрости використання пам’яті.

== Типи ==

Haskell має сильну статичну типізацію.

Приклад:

<pre>
name :: String
name = "Haskell"

count :: Int
count = 10
</pre>

Типи допомагають:

* ловити помилки під час компіляції;
* документувати наміри;
* моделювати domain;
* забороняти неможливі стани;
* робити refactoring безпечнішим.

== Type inference ==

Haskell має потужний type inference.

Можна написати:

<pre>
double x = x * 2
</pre>

GHC сам виведе тип.

Але в production-коді часто корисно писати type signatures:

<pre>
double :: Num a => a -> a
double x = x * 2
</pre>

Type signatures документують код і допомагають ловити помилки раніше.

== Algebraic Data Types ==

'''Algebraic Data Types''' або '''ADT''' — один із найсильніших інструментів Haskell.

Приклад:

<pre>
data OrderStatus
= Draft
| Paid
| Cancelled
</pre>

Це означає: статус замовлення може бути тільки Draft, Paid або Cancelled.

ADT допомагають явно описувати domain states.

== Product types і sum types ==

Product type містить кілька полів.

Приклад:

<pre>
data Customer = Customer
{ customerId :: Int
, customerName :: String
}
</pre>

Sum type описує вибір між варіантами.

Приклад:

<pre>
data PaymentResult
= PaymentOk
| PaymentDeclined String
| PaymentError String
</pre>

Sum types дозволяють моделювати бізнес-логіку без неявних null або magic strings.

== Pattern matching ==

'''Pattern matching''' — спосіб розібрати значення за формою.

Приклад:

<pre>
statusText :: OrderStatus -> String
statusText Draft = "Чернетка"
statusText Paid = "Оплачено"
statusText Cancelled = "Скасовано"
</pre>

Pattern matching робить код дуже читабельним для обробки ADT.

== Guards ==

Guards дозволяють писати умовну логіку.

Приклад:

<pre>
discount :: Int -> Int
discount amount
| amount > 10000 = 20
| amount > 5000 = 10
| otherwise = 0
</pre>

Guards часто роблять код чистішим, ніж nested if.

== Maybe ==

'''Maybe''' — тип для значення, яке може бути відсутнім.

Приклад:

<pre>
data Maybe a = Nothing | Just a
</pre>

Практичне використання:

<pre>
findCustomer :: Int -> Maybe Customer
</pre>

Це означає: customer може бути знайдений або ні.

<div style="background:#f6ffed;border-left:6px solid #27ae60;padding:14px 18px;margin:16px 0;border-radius:8px;">
'''Практична користь:''' замість null Haskell використовує тип <code>Maybe</code>. Компілятор змушує вас обробити випадок, коли значення немає.
</div>

== Either ==

'''Either''' часто використовується для результату з помилкою.

Приклад:

<pre>
parseAmount :: String -> Either String Int
</pre>

Це означає:

* <code>Right Int</code> — успішний результат;
* <code>Left String</code> — помилка.

Either корисний для validation, parsing, API responses і business rules.

== Type classes ==

'''Type class''' — механізм ad-hoc polymorphism.

Приклад:

<pre>
class Printable a where
printValue :: a -> String
</pre>

Тип може мати instance:

<pre>
instance Printable Customer where
printValue customer = customerName customer
</pre>

Type classes схожі на interfaces, але мають іншу семантику й велику роль у Haskell ecosystem.

== Eq, Ord, Show, Read ==

Базові type classes:

* <code>Eq</code> — порівняння на рівність;
* <code>Ord</code> — порядок;
* <code>Show</code> — перетворення в рядок;
* <code>Read</code> — читання з рядка.

Приклад:

<pre>
data Status = Draft | Paid
deriving (Eq, Show)
</pre>

<code>deriving</code> автоматично створює instances.

== Functor ==

'''Functor''' — type class для контейнерів або контекстів, над якими можна застосувати функцію.

Ключова функція:

<pre>
fmap :: Functor f => (a -> b) -> f a -> f b
</pre>

Приклад:

<pre>
fmap (+1) (Just 10)
-- Just 11
</pre>

Functor дозволяє працювати з “значенням у контексті”, не витягуючи його вручну.

== Applicative ==

'''Applicative''' — abstraction між Functor і Monad.

Вона дозволяє застосовувати function у контексті до value у контексті.

Приклад ідеї:

<pre>
pure (+) <*> Just 2 <*> Just 3
-- Just 5
</pre>

Applicative часто використовують у validation, parsing і configuration.

== Monad ==

'''Monad''' — abstraction для послідовного поєднання обчислень у контексті.

Ключова ідея: результат одного кроку впливає на наступний крок.

Приклад із Maybe:

<pre>
findCustomer customerId >>= findPrimaryEmail
</pre>

Якщо customer не знайдено, наступний крок не виконується.

<div style="background:#fff7e6;border-left:6px solid #f2994a;padding:14px 18px;margin:16px 0;border-radius:8px;">
'''Без містики:''' монада — це не “магія”. Це спосіб акуратно з’єднувати обчислення, які мають контекст: Maybe, Either, IO, список, state, parser тощо.
</div>

== IO Monad ==

'''IO''' — тип для операцій, які взаємодіють із зовнішнім світом.

Приклад:

<pre>
main :: IO ()
main = putStrLn "Hello, Haskell"
</pre>

IO потрібен для:

* читання файлів;
* запису файлів;
* network;
* database;
* console;
* random;
* time;
* взаємодії з OS.

Haskell не забороняє side effects. Він робить їх явними у типах.

== do notation ==

'''do notation''' — синтаксис для послідовних monadic operations.

Приклад:

<pre>
main :: IO ()
main = do
putStrLn "What is your name?"
name <- getLine
putStrLn ("Hello, " ++ name)
</pre>

Це схоже на імперативний код, але типи все одно контролюють effects.

== Higher-order functions ==

Haskell активно використовує functions як values.

Приклади:

<pre>
map (*2) [1,2,3]
filter even [1..10]
foldr (+) 0 [1,2,3]
</pre>

Higher-order functions дозволяють будувати дуже компактні transformations.

== Function composition ==

Композиція функцій записується через <code>.</code>.

Приклад:

<pre>
normalizeName :: String -> String
normalizeName = trim . toLower
</pre>

Це означає: спочатку <code>toLower</code>, потім <code>trim</code>.

Function composition — один із ключових стилів Haskell-коду.

== Currying ==

У Haskell функції технічно приймають один аргумент і можуть повертати функцію.

Приклад:

<pre>
add :: Int -> Int -> Int
add a b = a + b
</pre>

Це можна читати як:

<pre>
Int -> (Int -> Int)
</pre>

Тому можна частково застосовувати функції:

<pre>
add10 = add 10
add10 5
-- 15
</pre>

== Recursion ==

У Haskell loops часто виражаються через recursion або higher-order functions.

Приклад:

<pre>
sumList :: [Int] -> Int
sumList [] = 0
sumList (x:xs) = x + sumList xs
</pre>

У production-коді часто використовують готові functions на кшталт <code>sum</code>, <code>map</code>, <code>fold</code>.

== Lists ==

List — базова структура даних.

Приклад:

<pre>
numbers :: [Int]
numbers = [1,2,3,4]
</pre>

Операції:

<pre>
head numbers
tail numbers
map (*2) numbers
filter even numbers

Haskell - Історія редагувань

R в 20:35, 8 травня 2026