Haskell

Для людей с извращённым чувством юмора так называемые «эксперты» из Википедии предлагают статью, озаглавленную   **Haskell** .

sequence_ $ ["Пх'нглуи", "мглв'нафх", "Ктулху", "Р'льех", "вгах'нагл", "фхтагн", "!"] >>= (\x -> [print x])~ Ктулху про Haskell
The speed of light sucks~ Кармак про всякое
There are only two kinds of languages: the ones people complain about and the functional ones~ ТрупСтрауса про Haskell

## История Haskell — Версия о Божественной Сущности

**Haskell**  — священный язык программирования, дарованный шаманам  *Бубенлэнда*  их верховным божеством Комонада как универсальное средство для общения и духовного очищения, подходящее как божественным сущностям, так и (некоторым) простым смертным, переболевшим тяжёлыми стадиями интеллекта. Из-за своего происхождения язык всегда был функционально чист.

В честь своего божества и его щедрого подарка шаманы несколько раз в год проводили вычисление Великого Факториала. Со временем шаманам этот праздник надоел, они совсем обленились и перестали вычислять Великий Факториал. От этого Комонада периодически приходила в гнев и отправляла ответственных шаманов очищать моск к Ктулху, своему соседу по пантеону. И однажды великий шаман Карри выдвинул величайшую теорию Ленивого Вычисления Великого Факториала. Суть её состояла в том, что постоянно считать Великий Факториал необязательно, его нужно вычислять только тогда, когда Комонада находится в плохом расположении духа, чтобы избежать зохавывания Ктулху. Теория стала главенствующей, а к набору особенностей Haskell добавилась ещё исключительная ленивость.

Комонада была единственным божеством, общавшимся со своими шаманами на чистых языках, и это крайне злило других богов, особенно Сотону. Он создал армию ужасных демонов и приказал им испортить Haskell. Демоны начали искажать Haskell, внося в него злые сущности — древние рунические заклинания, называемые Монадами. В течение тысячелетий Монады разлагали язык изнутри, что в итоге привело к катастрофическому перевороту — Священные Бесконечные Списки Сообщений из Haskell 1.4 (известного также как Haskell 88) были предательски убиты, а на их месте воцарилась Демоническая АрхиМонада ЙО.

Как это произошло — неизвестно, ибо ЙО до этого из-за своей исключительной грязности и пошлости не могла проникнуть ни в один язык.

Опасность ЙО заключается в том, что вместо того, чтобы изменять своё восприятие мира, она изменяет сам мир, и неосторожное с ней обращение может привести к турбулентностям в фундаментальных слоях материи вселенной, результирующих в феерическом и глобальном ППЦ’е. Также Сотоной был введён исключительно похабный легион Монадных Трансформеров, позволяющих засовывать одни монады в другие. Как правило, обычно ЙО засовывается в другие монады, появившиеся в Haskell гораздо раньше. Ввиду огромного размера ЙО, программы с использованием Монадных Трансформеров не рекомендуется читать детям до 16 лет и незамутнённым девушкам.

Окончательное падение бастиона чистоты Haskell произошло одновременно с вводом Сотоной в язык механизма самовольного написания монад. Ранние чистые спецификации языка отправились фтопку. Сотона активно распространяет заблуждение, что современный диалект Haskell 98 — это и есть ТруЪ Haskell. На самом деле это лишь жалкое подобие первоначального божественного языка.

Фашисты, боровшиеся за чистоту немецкой расы, также боролись и за чистоту языка. Они пытались восстановить
магические спецификации первозданного Haskell’а. Восстановленный язык должен был называться Haskell88 (как и
последний чистый вариант, существовавший ещё во времена шумерчегов), и планировалось сделать данный язык государственным. В последней сохранившейся версии их языка — Haskell88.14hh были введены монады SS и SD, которые очистили язык от всех других монад, кроме великой монады ЙО. Этот результат не устроил Адольфа Гитлера. По его указу был собран УберШтурманКонсилиум самых лучших УберШтурманУмов Германии. На УберШтурманКонсилиуме было решено провести УберШтурманЭксперимент по геноциду монады ЙО. Достоверно известно, что после непродолжительного времени после начала эксперимента Третий Рейх пал, что ещё раз подчеркнуло исключительную опасность монады ЙО.

## Более реалистичная версия

Haskell возник как результат пьянки между Ричардом Столлманом, Гордоном Фрименом и Хаскеллом Карри. Название языка возникло
как подтверждение ответа на фундаментальный вопрос «ты меня уважаешь?», логотип был предложен Фрименом, а предложение Столлмана добавить скобок было отправлено фтопку вместе с самим Столлманом.

Для придания статуса серьёзности данной ошибке молодости была придумана  *Версия о божественной сущности* .

## Факты новейшей истории

- Греки нагло сплагиатили логотип Хаскелла в качестве 13-й буквы своего алфавита

- В 1998 году вышел героический эпос Полуразвал о хаскеллере, чисто функциональными методами осуществившем полный garbage collection

- Для мирового сообщества Хаскелл играет несколько важных ролей, главенствующая среди которых — в жизни его (Хаскелла) создателей

- Haskell номинируется на звание «природного врага № 1 риальных пацанов от программирования»

- В языке Haskell Вечность (незавершаемая программа) — это разновидность Жопы (_|_), что доказывает его Труъ-происхождение

## Подозрения и теории заговора

- Монады — часть плана Ктулху по зохавыванию моска фсех (и Сотона тут не замешан)

- Культист Карри исказил священные тексты, назвав вечный язык своим именем

- ST — часть плана Сотоны по зохавыванию чистых функциональных фич Haskell, которые не может асилить ЙО.

## Особенности языка

- Haskell — пока ещё единственный язык программирования (не считая С++ и остальных С-подобных языков), в котором есть оператор  *«фтопку»*  (>>=)

- Программы на Haskell настолько ленивы, что по умолчанию вообще не хотят работать. Скорость и результаты работы всецело зависят от джедайской силы ( *force* ) хаскеллера.

- Одна из божественных сущностей, дожившая до времён Haskell98 — стиль-без-башни. Он позволяет записывать функции, не зная, кто, где, когда, как, почему, зачем будет их вызывать. Примеры шедевров:

 (. return) . (:) -- == \ x z -> [x, z]
 flip . ((flip . (flip .)) .) -- == \ f a0 a1 a2 a3 -> f a1 a2 a3 a0
 flip flip snd . (ap .) . flip flip fst . ((.) .) . flip . (((.) . (,)) .) -- == \ f1 f2 (a, b) -> (f1 a, f2 b) == bimap

Считается, что в будущем безбашенный Haskell-стиль по количеству скобок обгонит Лисп, что приведёт к зохавыванию последнего Haskell’ом и переделу Матрицы (которая, как известно, есть самоpaзродившаяся программа на Лиспе). Столлман с этим несогласен, но его мнение было отправлено фтопку ещё во время создания Haskell.

- Существует короткое заклинание, которое позволило Haskell поработить тысячи программистов:

  qs [] = []
  qs (x:xs) = (qs l) ++ [x] ++ (qs r) where (l,r) = partition (<x) xs

Его можно написать ещё короче (даже в олдовые 80 символов влезает)

 qs es=case es of{[]->[]; (x:xs)->qs l++[x]++qs r where(l,r)=partition(<x)xs}

Однако есть мнение, что сей "шедевр" создан Сотоной, ибо труЪ хаскеллист знает наизусть заклинание, которое работает в 50-200 раз быстрее (на данных, отсортированных по возрастанию и убыванию соответственно):

 ms ls|[]<-ls=[]|[x]<-ls=ls|True=on merge ms`uncurry`splitAt(length ls`div`2)ls where merge xs@(~(x:xs')) ys@(~(y:ys'))|[]<-xs=ys|[]<-ys=xs|x<y=x:merge xs' ys|True=y:merge xs ys'

Для новичков существует его Святое Толкование:

msort [ ] = [ ]
msort [x] = [x]
msort lst = on merge msort `uncurry` splitAt (length lst `div` 2) lst
  where
    merge [] ys = ys
    merge xs [] = xs
    merge xs@(x : xs') ys@(y : ys') = if x < y then x : merge xs' ys else y : merge xs ys'

Контрзаклятие, написанное на C, как правило бессильно, хотя и занимает куда больше места.

- Революции под лозунгом «порезать Haskell по самые монады», как правило, подавлялись Верховным Жрецом Григорием Перельманом.

- Вывод типов — фича, заложенная в Haskell самой Комонадой. Однако ввод типов никто никогда не реализовывал. Ботаны многих эпох выдвигали предположения, что однажды типы в Хаскелле закончатся, ибо вводить их некому. Тем не менее, никто не знает, почему этого до сих пор не произошло. Есть мнение, что, узнав ответ на этот вопрос, мы гораздо лучше будем понимать структуру Вселенной (в частности, разберёмся в принципах работы биореактора и малого адронного коллайдера).

## Изучение

Самый Мега-ТруЪ-одобрямс учебник по Haskell98 называется HSOE (Haskell SOtona Edition; что часто неверно расшифровывают как Haskell School Of Expression). Главной особенностью данного талмуда является наличие изображения моска правильно обученного хаскеллера на обложке, что позволяет на глаз оценивать прогресс обучения.

Другой популярный учебник по Haskell — YAHT (YA Havat Tebya), написанный ещё Ктулху III по заказу Комонады, к настоящему моменту безнадёжно устарел. Рецензии и поправки автору присылались, но он до сих пор не удосужился проснуться, чтобы их прочитать.

В среднем обучение Haskell’у начинается в 10-12 лет. Своевременное начало обучения гарантирует, что вы достигнете третьего уровня Силы уже к 75 годам. Не стоит откладывать на следующую жизнь то, что можно по крайней мере начать в этой.

## Классификация уровней Силы Haskell — программистов

### n00b — 1 уровень

Иногда задаёт вопрос «а где здесь переменные?»

Пишет Великий Факториал как:

  fac n = product [1..n]

### Beginner — 2 уровень

Написал туториал по применению и созданию монад (делает вид, что их понимает)

Пишет Великий Факториал как:

  arb = () 

  listenc n = replicate n arb
  listprj f = length . f . listenc

  listprod xs ys = [ i (x,y) | x<-xs, y<-ys ]
                   where i _ = arb

  facl []         = listenc  1
  facl n@(_:pred) = listprod n (facl pred)

  fac = listprj facl   

или как:

fac n = do cont <- callCC $ \h' -> do
                   when (n <= 1) $ Cont $ const 1
                   h' n
           return cont
  `runCont` (* (fac $ n - 1))

### Medium — 3 уровень

Самостоятельно написал компилятор Haskell на Haskell.

Пишет Великий Факториал как:

data Term = Occ Var
          | Use Prim
          | Lit Integer
          | App Term Term
          | Abs Var  Term
          | Rec Var  Term

type Var = String
type Prim = String

data Value = Num Integer
           | Bool Bool
           | Fun (Value -> Value)

instance Show Value where
  show (Num  n) = show n
  show (Bool b) = show b
  show (Fun  _) = ""

prjFun (Fun f) = f
prjFun _      = error «bad function value»

prjNum (Num n) = n
prjNum _      = error «bad numeric value»

prjBool (Bool b) = b
prjBool _       = error «bad boolean value»

binOp inj f = Fun (\i -> (Fun (\j -> inj (f (prjNum i) (prjNum j)))))

type Env = [(Var, Value)]

getval x env = case lookup x env of
                  Just v  -> v
                  Nothing -> error ("no value for " ++ x)

eval env (Occ x) = getval x env
eval env (Use c) = getval c prims
eval env (Lit k) = Num k
eval env (App m n) = prjFun (eval env m) (eval env n)
eval env (Abs x m) = Fun (\v -> eval ((x, v) : env) m)
eval env (Rec x m) = f where f = eval ((x, f) : env) m

times = binOp Num (*)
minus = binOp Num (-)
equal = binOp Bool (==)
cond = Fun (\b -> Fun (\x -> Fun (\y -> if (prjBool b) then x else y)))

prims = [ («*», times), («-», minus), («==", equal), ("if», cond) ]

facTerm = Rec «f» (Abs «n»
              (App (App (App (Use "if")
                   (App (App (Use "==") (Occ "n")) (Lit 0))) (Lit 1))
                   (App (App (Use "*")  (Occ "n"))
                        (App (Occ "f")  
                             (App (App (Use "-") (Occ "n")) (Lit 1))))))

fac n = prjNum (eval [] (App facTerm (Lit n)))

### Григорий Перельман — 4 уровень

Высший Жрец. Постиг комонады и забивает стрелки (arrows) подорожникам.

Пишет Великий Факториал как:

— explicit type recursion with functors and catamorphisms

newtype Mu f = In (f (Mu f))

unIn (In x) = x

cata phi = phi . fmap (cata phi) . unIn

— base functor and data type for natural numbers,
— using locally-defined «eliminators»

data N c = Z | S c

instance Functor N where
  fmap g  Z    = Z
  fmap g (S x) = S (g x)

type Nat = Mu N

zero = In Z
suck n = In (S n)

add m = cata phi where
  phi  Z    = m
  phi (S f) = suck f

mult m = cata phi where
  phi  Z    = zero
  phi (S f) = add m f

— explicit products and their functorial action

data Prod e c = Pair c e

outl (Pair x y) = x
outr (Pair x y) = y

fork f g x = Pair (f x) (g x)

instance Functor (Prod e) where
  fmap g = fork (g . outl) outr

— comonads, the categorical «opposite» of monads

class Functor n => Comonad n where
  extr :: n a -> a
  dupl :: n a -> n (n a)

instance Comonad (Prod e) where
  extr = outl
  dupl = fork id outr

gcata :: (Functor f, Comonad n) =>
           (forall a. f (n a) -> n (f a))
             -> (f (n c) -> c) -> Mu f -> c

gcata dist phi = extr . cata (fmap phi . dist . fmap dupl)

zygo chi = gcata (fork (fmap outl) (chi . fmap outr))

para :: Functor f => (f (Prod (Mu f) c) -> c) -> Mu f -> c
para = zygo In

fac = para phi where
  phi  Z             = suck zero
  phi (S (Pair f n)) = mult f (suck n)

int = cata phi where
  phi  Z    = 0
  phi (S f) = 1 + f

instance Show (Mu N) where
  show = show . int

### Самый сильный программист — 5 уровень

Забивает на стрелки и Перельмана и пишет факториал так, как хочет

  fac n = product [1..n]