Александр Скуснов

использовать show и map

1) Отображение - дело непростое. ФП предназначено для расчётов, а не для отображений. А именно: подаёте на вход функции параметры и получаете результат. Обычно под отображением понимают преобразование типа к строковому виду. В Haskell строка это список символов:
type String = [Char]
Если вы что-то делаете в интерпретаторе, то там ещё вычисления (и вывод) происходят в монаде IO.
Для вывода многих типов есть функция show.

2)

как теперь вывести список чаров

можете в интерпретаторе так и написать: ['a', 'b', 'c']
Есть синтаксический сахар: список char можно выводить в виде строки, т.е. без скобок, но в двойных кавычках: "abc"

если он отображается как список стрингов

нет такого. Список char отображается в двух видах (см. выше), они равнозначны.

почему список символов отображается как строка символов?

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

1) Каррирование позволяет функции скармливать аргументы по-одному (несколько, не все сразу), т.е. возможно частичное применение.
Напр., (+) x y имеет тип:
a -> a -> a
Чтобы понять, какая стрелка первая, пользуемся ассоциативностью (здесь правой):
а -> (a -> a)
Поэтому в Haskell все каррированные функции это функции одного аргумента. Формально сложение, это функция, принимающая один аргумент (типа а) и выдающая функцию (типа a -> a). Но это философия. Для удобства и скобки можно не писать, и предоставить (если нужно) плюсу два аргумента (тогда результатом будет число).
2) В формальном подходе map тоже функция одного аргумента:
(a -> b) -> ([a] -> [b])
(это классическое определение функтора по теории категорий).
Но благодаря каррированию, можно также представить map как функцию (высшего порядка, т.к. первый аргумент - функция) принимающую два аргумента: функцию и список. Результат - список.
Первый аргумент типа (a -> b), второй типа [a].
3) там, где :: , пишутся типы аргументов и результата. Сами аргументы и тело функции (выражение) пишутся ниже через =.
(при этом может быть применён бесточечный стиль, когда не все аргументы перечислены, напр.:
mysum = (+)
или mysum x = (+) x
или mysum x y = (+) x y -- здесь все аргументы)

1) скобки в описании типа расставляются вправо, так что может быть любое количество аргументов:
fun:: a -> (a -> (a -> a))
2) частичное применение означает, что функции можно скармливать аргументы по одному в любом количестве.
(в режиме оператора можно подсунуть второй, а первый - потом).
3) про каррирование. Есть вид передачи параметров в других языках fun(p1, p2, p3). На Haskell это передача одной группы (кортежа). Есть функции высшего порядка curry и uncurry, которые вашу функцию переводят в противоположный тип.

У меня maxBound ::Int чётко 2^31 (т.е 4 байта, старший бит - знак)

Один из вариантов (простенький, но не оптимальный) такой:

Prelude> [(bull, cow, calf) | bull<-[1..10], cow<-[1..20],calf<-[1..200], bull + cow + calf == 100, 10*bull + 5*cow +calf/2 == 100]
[(1.0,9.0,90.0)]

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

Не знаю, как с русским, но первая функция (потом вы назвали её второй) это фильтр:

import Data.Char
f1 = filter isAlpha    -- или isLetter

> f1 "a,b,c"
> "abc"

Пролога не знаю, но функциональный стиль действительно декларативный. Напр. x = x +1 в императивном означает сложить значение x с единицей и положить результат в x.
В ФП это будет рекурсивный вызов функции x.
По поводу решения. Напр., в Матлабе эта система записывается как A*x = b, где А - матрица 2х2, x - вектор 2х1 неизвестных (x и y), а b - вектор 2х1 левой части. Решение находится в виде левого деления: x = A \ b.
На Хаскеле надо бы описать тип данных "матрица" и оператора "левое деление" (можно методом треугольника) и тогда - вуаля, всё получится.

Есть интересные лекции по функциональному программированию Дмитрия Сошникова (правда, в основном, на F#).
Допустим, видишь x = 2+3.
Можно сказать: подсчитай выражение и результат положи в ячейку x.
А функциональный программист скажет: вы описали (метод расчёта) функцию х (т.е. у вас не команды, а определение функции). Из кучи определений компилятор постарается найти сокращённый вариант, который будет решением при подстановке данных.

Если последний аргумент встречается справа тоже на последнем месте, то их можно не писать. Это называется бесточечным стилем.
fun x y z = (...) z
и fun x y = (...)
это одно и тоже.

Есть курс Дмитрия Сошникова на Интуите. Хотя он голосует за F#, но мне больше понравился Haskell.