Посоветуйте хорошую книгу по Haskell для начинающих.

Ну и сломает себе жизнь привычкой к нормальной типизации и грести на галере уже не сможет.

Я сломал себе жизнь. Посоветуйте мне книгу «как перестать вспоминать о хаскеле, и начать жить».

А я думал, погромированием занимаются, чтобы писать клёвые проги, которые что-то делают.

Бро, тебя ждет разочарование. Меня тоже привлекала идея «писать клевые проги», но потом я понял, что люди находятся в кодинге ровно по двум сценариям:
- аутист, бегущий от жизни в кодинг ради кодинга - тогда хаскель идет в плюс;
- работать на галере гребцом или надсмотрщиком - хаскель противопоказан.
Никто не пишет клевые проги, которые работают, оба класса пишут бесполезное говно, просто, вторые их впаривают кому-то, а первые - нет.

Обе категории пишут ровно тот код, на который есть спрос, либо академический, либо бизнес. И хорошо если академический спрос еще и платежеспособный :)

Все пишут по разному, кто-то как индусы и американцы очень плохо и говнокод, и получаются только ФУ-35, а кто-то старается и получается вроде даже летающий, а если и падающий, то точно в цель!

Как начать жить? Очень просто - уехать из силиконовой долины на ранчо пасти коров, чистый метан и сероводород!

Обе категории пишут ровно тот код, на который есть спрос, либо академический, либо бизнес. И хорошо если академический спрос еще и платежеспособный

Да, это просто самая писечка - писать бесполезное говно, за которое тебе будут давать гранты и которое нельзя использовать для нужд коммерции.

Как начать жить? Очень просто - уехать из силиконовой долины на ранчо пасти коров, чистый метан и сероводород!

Коров тут вокруг достаточно, так что сам не пасу. Я сомневаюсь, что у пастухов и фермеров здесь есть счастливая жизнь.

Как пасти котов - замечательная книжка!

Надоело кодить или хаскелить, может пасти котов будет интереснее теперь?

Если надоело пасти коров, то можно поехать обратно в город, вдыхать на стройках полной грудью чистейший асбест и цемент.

А я думал, погромированием занимаются, чтобы писать клёвые проги, которые что-то делают.

Бро, тебя ждет разочарование. Меня тоже привлекала идея «писать клевые проги», но потом я понял, что люди находятся в кодинге ровно по двум сценариям:

- аутист, бегущий от жизни в кодинг ради кодинга - тогда хаскель идет в плюс;

- работать на галере гребцом или надсмотрщиком - хаскель противопоказан.

Никто не пишет клевые проги, которые работают, оба класса пишут бесполезное говно, просто, вторые их впаривают кому-то, а первые - нет.

Пасиб).
На самом деле писать в некротред нет желания, но я хотя бы почитал тред, свои комментарии и остался ими доволен.

Какой-то инглишмен запостил в тред ровно годовой давности. Я даже не обратил внимания на год. «25-26 апреля - вроде свежачок», подумал я.

Есть такая специальность: инженер-математик, он же, математик-программист или прикладной математик. У этой специальности в ходу разные названия, по крайней мере были разные названия, когда я учился. У меня диплом по ней. Так что, для таких как я вполне хорош хаскель. Тут даже можно съюморить: хаскель настолько прикладной, насколько прикладной является сама математика. Кто-то поймет, а кто-то ухмыльнется. Если серьезно, то хаскель применяют в продакшене, но по понятным причинам не так часто, как мне бы хотелось.

авторством Романа Душкина

Можно листать ради пафосного академического стиля изложения

я бы смотрел на C#, а потом F# чтобы «догнаться» и не слишком отстать от реалий современного вАйТи.

А в этом ракурсе, что на счёт Kotlin. Он из той же оперы что C#, но более практичен, чем F#.

Однозначно: http://learnyouahaskell.com/

Есть русскоязычный перевод печатной версии («изучай Haskell во имя добра» в русском переводе).

вторые их впаривают кому-то, а первые - нет.

Ну почему же, первые могут рассказывать о превосходстве их язычков и писать книжки.

Мда... Человек конкретный вопрос задал, без намёков на неопределённость даже, а вы тут детсад развели, со своими Elixir, C#, вы ещё JS/Ruby/Python/PHP посоветуйте человеку вместо Haskell изучать. Amateurs...

K&R

Чувак, мне 15 лет.

Возьми Kotlin, пиши программы под комп, сервак, андроид и ios. Не насилуй свой мозг.

Мда... Человек конкретный вопрос задал, без намёков на неопределённость даже, а вы тут детсад развели, со своими Elixir, C#, вы ещё JS/Ruby/Python/PHP посоветуйте человеку вместо Haskell изучать. Amateurs...

Прежде всего, человек ставил ошибочно просьбу «Желательно чтобы с Hello World начали», потому что в хаскеле нужно начинать с чисел фибоначи. А это значит, что ему нужен не хаскель.
У меня та же проблема была, на самом деле, потому что большинство материалов для новичков составлены академиками с короткими пиписьками, желающими компенсировать свои недостатки пафосностью и корректностью изложения, вместо объяснения простым языком. По этой причине интернет набит «объяснениями» монад, хотя большинство этих объяснений только запутывают - это какая-то специальная олимпиада «сделай самое странное и запутанное руководство по примитивной вещи».

А лучше пивасика пусть попьёт перед телеком, и футбик посмотрит (нет).

Нет, не значит. Haskell может применяться в самых разных предметных областях с некоторыми исключениями, и дробить числа - отнюдь не самое частое применение.

Я думаю что смогу объяснить что такое монадки без магии, если нужно. Только объяснять я буду сначала ADT и тайпклассы, простым языком.

Ну и сравнения у тебя.

Кстати, Haskell ближе к пивасику и телеку, равно как и к маменькому борщу, чем котлин.

Haskell может применяться в самых разных предметных областях

Но не применяется.

а дальше идёт запутка.

Возможно, тебе не хватает базовых знаний по программированию. А может и математике.

Надо понимать, что Haskell - маргинальный язык. Попробуй начать с простого языка общего назначения. Есть смысл посмотреть на новые и уже выстрелевшие языки - Kotlin, Swift. А может стоит подумать о C# и Java. А может и C++.

Уберите свой жир, у меня пальцы соскальзывают с клавиатуры.

Тобою нет конечно, не дорос ещё, маленький.

Попробуй начать с простого языка общего назначения.

А может и C++.

Да-да, только C++ для простоты тут и не хватало, с макросами для шаблонов с constexpr-ами и всякой магией с потерянными поинтерами. Давайте устроим диванный эксперимент. Реализуйте пожалуйста банальный quick sort на C++, покажите нам его простоту? Вот я на Haskell с закрытыми глазами написал реализацию:

quickSort :: Ord a => [a] -> [a]
quickSort [] = []
quickSort (x : xs) =
  quickSort (filter (<= x) xs) ++ [x] ++ quickSort (filter (> x) xs)

Напишите на C++ альтернативную реализацию, чтоб работало с любым входным типом данных (который можно сортировать), чтоб увидеть его всеобъемлющую простоту.

Ну в проде конечно же нет. Но вообще думаю я знаю Хаскель не хуже тебя. Для общего развития весьма полезно. Но не для прода.

А почему не для прода по вашему (я вот использую, не один год)?

Вот я на Haskell с закрытыми глазами написал реализацию

Кхм... Оцени плиз сложность своего «quick» sort'а. А потом напиши настоящую быструю сортировку. И вот тогда сравним.

Если серьёзно и без жира, то для прода - самое оно, т.к. в «проде» очень много ошибок, багов, тупых и обидных. Haskell, как никто другой (из практически применимых, для прода) позволяет защищаться от них, отбрасывая все элементарные недоразумения ещё в компайл-тайме. Не раз делал значительные изменения в кодовой базе за раз, в десятках модулей, и просто правил ошибки пока не скомпилится, в итоге один-два бага всплывало, а в целом всё было отлично. Я себе ничего подобного ни с одним другим языком представить не могу.

Нет, давай ты напишешь свою реализацию на C++ без оглядки на сложность и прочие оптимизации. Самую простую и краткую, какую ты сможешь. Мы сейчас говорим про простоту, любые оптимизации как правило эту простоту преуменьшают, некоторые до степени write-only, это отдельный разговор. Если что, на следующей итерации приведём оптимизированные примеры, давай начнём с «простого»?

Камон, это же уже баян в хаскель сообществе. Нет, это не qsort

без оглядки на сложность и прочие оптимизации

При чем тут оптимизации? Твоя быстрая сортировка совсем не быстрая. По определению.

Вот тебе не самая эффективная реализация, но это таки быстрая сортировка

template <class ForwardIt>
void quicksort(ForwardIt first, ForwardIt last)
{
    if (first == last)
        return;

    auto pivot = *std::next(first, std::distance(first, last) / 2);

    ForwardIt middle1 = std::partition(first, last,
                                       [pivot](const auto &em) { return em < pivot; });
    ForwardIt middle2 = std::partition(middle1, last,
                                       [pivot](const auto &em) { return !(pivot < em); });
 
    quicksort(first, middle1);
    quicksort(middle2, last);
}

Можно написать еще проще и еще менее эффективно=)

template <class It>
void quicksort(It first, It last)
{
    if (first == last)
        return;

    auto x = *next(first, distance(first, last) / 2);

    auto m1 = partition(first, last,
                        [=](auto y) { return y < x; });
    auto m2 = partition(m1, last,
                        [=](auto y) { return y >= x; });
 
    quicksort(first, m1);
    quicksort(m2, last);
}

И это настоящая быстрая сортировка в отличие от.

Давай тогда ещё проще, пусть менее эффективно.

А местным господам предоставляем высказать своё мнение, что проще:

Это:

quickSort :: Ord a => [a] -> [a]
quickSort [] = []
quickSort (x : xs) =
  quickSort (filter (<= x) xs) ++ [x] ++ quickSort (filter (> x) xs)

или это:

template <class ForwardIt>
void quicksort(ForwardIt first, ForwardIt last)
{
    if (first == last)
        return;

    auto pivot = *std::next(first, std::distance(first, last) / 2);

    ForwardIt middle1 = std::partition(first, last,
                                       [pivot](const auto &em) { return em < pivot; });
    ForwardIt middle2 = std::partition(middle1, last,
                                       [pivot](const auto &em) { return !(pivot < em); });
 
    quicksort(first, middle1);
    quicksort(middle2, last);
}

Хотя я спешу заметить, что в данном коде в функцию передаётся не список, а 2 указателя, это не альтернативная реализация, жду настоящий аналог, чтобы по интерфейсу соответствовало. И, как я уже сказал, можно вообще любые оптимизации опустить, сейчас мы сравниваем «простоту» самого простого решения.

По прежнему жду варианта с передачей списка в качестве аргумента, а не указателей.

передаётся не список, а 2 указателя

Так ты еще помимо алгоритмов и C++ не знаешь=)

Возможно, но это никак ваши аргументы о «простоте» не делает сильнее.

А от тебя будет вариант с быстрой сортировкой?=)

Добавь к моему варианту

template<typename T>
void quicksort(T & xs)
{
    quicksort(xs.begin(), xs.end());
}

Итак, господа, проще это:

template<typename T>
void quicksort(T & xs)
{
    quicksort(xs.begin(), xs.end());
}

template <class It>
void quicksort(It first, It last)
{
    if (first == last)
        return;

    auto cmp = [=](auto y) {
        return y < *first;
    };
    auto m = partition(first, last, cmp);

    quicksort(first, m);
    quicksort(m, last);
}

quickSort :: Ord a => [a] -> [a]
quickSort [] = []
quickSort (x : xs) =
  quickSort (filter (<= x) xs) ++ [x] ++ quickSort (filter (> x) xs)

Во-первых, тут были и более лаконичные варианты на C++. Во-вторых, вот пример настоящего quicksort на Haskell

{-# LANGUAGE BangPatterns, ScopedTypeVariables #-}
module Main where
import           Control.Monad.Primitive
import           Control.Applicative ((<$>))
import qualified Data.Vector.Unboxed as V
import qualified Data.Vector.Unboxed.Mutable as M
import           System.Environment (getArgs)
import           System.Clock
import           System.Exit (exitFailure, exitSuccess)
import           Control.DeepSeq (deepseq)
import qualified Data.ByteString as BS
import           Data.ByteString.Char8 (readInt)

partition :: (PrimMonad m, Ord a, M.Unbox a) => Int -> M.MVector (PrimState m) a -> m Int
partition !pi !v = do
    pv <- M.unsafeRead v pi
    M.unsafeSwap v pi lastIdx
    pi' <- go pv 0 0
    M.unsafeSwap v pi' lastIdx
    return pi'
  where
    !lastIdx = M.length v - 1

    go !pv i !si | i < lastIdx =
       do iv <- M.unsafeRead v i
          if iv < pv
            then M.unsafeSwap v i si >> go pv (i+1) (si+1)
            else go pv (i+1) si
    go _   _ !si                = return si

qsort :: (PrimMonad m, Ord a, M.Unbox a) => M.MVector (PrimState m) a -> m ()
qsort v | M.length v < 2 = return ()
qsort v                    = do
    let !pi = M.length v `div` 2
    pi' <- partition pi v
    qsort (M.unsafeSlice 0 pi' v)
    qsort (M.unsafeSlice (pi'+1) (M.length v - (pi'+1)) v)

Прекрати тупняк, не позорь нас, хаскелистов!

Что тебя не устраивает? То, что это не настоящий quick sort?

не настоящий quick sort

Нонсенс, чушь. Quick sort это конкретный алгоритм с конкретными свойствами.

Это вопрос наличия функций filter, создающей новую последовательность, и конкатенации последовательностей. При их наличии будет тоже самое и в плюсах. В плюсах их нет, потому что за них засмеют. Возможно, ranges тут бы были в тему.

«Программируй на Haskell во имя добра»

В 15 лучше начать с Pascal. Не шучу.

И дедушка - такой молодой!

Тред не читал. Haskell from first principles.

Haskell может применяться в самых разных предметных областях с некоторыми исключениями, и дробить числа - отнюдь не самое частое применение.

У хаскеля все оч плохо для грязных операций. Каждый раз приходится нагибаться раком, чтобы сделать банальную вещь, и следить, чтобы не дай бог компилятор что-то не «оптимизировал». А практические задачи обычно состоят именно из грязных операций. Потому хаскель применяют в тех узких областях, где перекос идет в сторону чистых функций.

Я думаю что смогу объяснить что такое монадки без магии, если нужно. Только объяснять я буду сначала ADT и тайпклассы, простым языком.

Уже усложнил. Да, понимание ADT, типоклассов и их экземпляров нужно для написания монад, но не нужно для понимания самого принципа монад и чтения кода, использующего монады.

quickSort (x : xs) = quickSort (filter (<= x) xs) ++ [x] ++ quickSort (filter (> x) xs)

Что прикажете делать, если у меня массив уже отсортирован? Если, допустим, переписать функцию на кортежах и добавить к ключу еще и значение, то quickSort для дублирующих ключей перепутает порядок значений. А ведь этот алгоритм прежде всего уважается за высокую скорость и сохранение порядка, но на хаскеле он потерял оба этих качества.