Haskell в настоящем проекте

Да тут нет ничего сложного. Думайте о монаде, как о контексте.

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

А матан можно оставить для любителей — для того, что бы писать на haskell, он необязателен.

Конкретно этот пример требует понимания только типов данных, монад, библиотеки parsec и аппликативных функторов. Точнее даже не аппликативных функторов, а операторов <$> и <*> из Control.Applicative. Они делают простые вещи.

-- | Parses a BInt
getBInt :: Get BCode
getBInt = BInt . read <$> getWrapped 'i' 'e' intP
    where intP = ((:) <$> char '-' <*> getDigits) <|> getDigits

Ключевой момент здесь — тип Get a. Что это такое, я не знаю, в этом модуле не определён. Нужно найти откуда он импортируется и понять что он точно делает. По коду он похож на монаду парсинга, такую как в parsec.

getBInt :: Get BCode

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

BInt . read

Это бесточечная нотация www.haskell.org/haskellwiki/Pointfree.
Вот сигнатура оператора (.):

(.) :: (b -> c) -> (a -> b) -> a -> c   -- Defined in GHC.Base

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

(BInt . read)

Да, BInt — это один из конструкторов типа BCode. Это функция, которая принимает на вход Integer и возвращает BCode.

<$>

Это то же самое, что fmap. Принимает на вход чистую функцию и функцию с побочным зффектом. Сначала вычисляет функцию с побочным эффектом, берёт оттуда чистый результат, подаёт на вход чистой функции. Результат всего этого делает побочным.

getWrapped 'i' 'e' intP

Здесь происходит сам парсинг с побочным эффектом.

(:) -- оператор добавления элемента в начало списка
<$> <*> -- операторы из Control.Applicative, позволяют удобно комбинировать чистые функции и функции с эффектами.
<|> -- оператор выбора альтернатив парсера, такой же как в parsec.

Т.е. intP — это парсер, для которого валидными строками являются символ "-", а потом то, что парсится функцией getDigits, либо просто то, что парсится функцией
getDigits без минуса. Возвращает он всегда точно такую же строку, которую распарсил. getDigits — это одна или больше цифр, что понятно из кода ниже.

getWrapped 'i' 'e' intP

Это функция, которая делает из парсера intP новый парсер. Путём добавления в начало и в конец двух символов для парсинга.

-- | Get something wrapped in two Chars
getWrapped :: Char -> Char -> Get a -> Get a
getWrapped a b p = char a *> p <* char b

Операторы (*>) и (<*) я никогда раньше не использовал и не знал что такое. Берём hoogle www.haskell.org/hoogle/, вводим там (*>). Попадаем в документацию к модулю Control.Applicative:

(*>) :: f a -> f b -> f b
Sequence actions, discarding the value of the first argument.

(<*) :: f a -> f b -> f a
Sequence actions, discarding the value of the second argument. 

Всё ясно, будем знать.

Итог: 20 секунд на понимание кода и 10 минут на этот текст. Какие недели, о чём вы?

Надеюсь, не стоит приводить примеры из c++, c#, python, perl, которые произведут точно такое же впечатление на первый взгляд?

Что-то я увлёкся кодом.

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

Как быстро вольётся — сложный вопрос. Но есть же разные участки кода по сложности. Самые простые вещи, думаю, можно начать писать очень быстро.