Например: есть функция (+) :: Int -> Int -> Int (немного упростил)
Можно скормить ей один аргумент:
(+) 1 :: Int -> Int
Получится функция, которая добавляет единичку
Потом можно ещё один аргумент
(+) 1 2 :: Int то же что 3

Первый аргумент испаряется что-ли?

первый аргумент сохраняется в замыкании

А что это?

Я только короткое знаю

plus a b = a + b
plus a = \b -> a + b
plus 5 = \b -> 5 + b

let f = plus 5
f 10 = (\b -> 5 + b) 10 = 5 + 10 = 15

Почему это полезно: потому что можно написать

Haskell> let plusThree = (+) 3
Haskell> map plusThree [1..10]
[4,5,6,7,8,9,10,11,12,13]

Или сразу map (+3) [1..10]

a -> a -> a применяешь первый аргумент, получаешь функцию вида a -> a, применяешь второй аргумент, получаешь результат a

Они все запоминаются до тех пор, пока не получится окончательное значение

Замыкание — это механизм запоминания

Хорошо, я понимаю так.

Допустим есть функция с типом
(a -> a) -> a

Эта функция, сначала из первого значения типа a делает второе значение типа а, потом первое значение типа a, забывается и испаряется, и уже из полученного второго значения типа а, делается третье значение типа a

Так что-ли?

Нет, из-за скобок совсем другое получилось

Тогда ничего не понятно

Вот же, это просто разные типы

Это разве не то же самое, что и принятие двух аргументов?

все проще, лямбды имеют рантаймное представление, лямбда это пара из ссылку на функцию и среза скоупа в момент создания этой лямбды

f =
 let t = 5
 in \x -> x + t

g =
 let t = 10
 in \x -> x + t

вроде абсолютно две одинаковые лямбды, \x -> x + t, но они имеют разный срез скоупа (+, и t = 5 и 10), поэтому это две разные в рантайме лямбды, и мы можем вызвать f 2 и получить 7, хоть уже нет у нас t в скоупе, это сохранилось в срезе скоупа лямбды

Почти то же, но не совсем

И что означает это "не совсем"

Вот это