Haskell Currying

Question

За последние два часа я читал о каррировании в Haskell, и все ресурсы показывают, как функции с несколькими параметрами фактически возвращают другие функции, но не так, как их определения выглядят, так что вот о чем идет речь ,

Определим функцию:

myFunc :: (Num a) => a -> a -> a 
myFunc x y = x * 2 + x * y 

:t (myFunc 2) печатает Num a => a -> a, то есть функция, которая принимает число, а также выводит номер. Однако, как выглядит определение функции, возвращаемое (myFunc 2)? Подходит ли компилятор x в определении, а новая функция становится чем-то вроде myFunc' y = 2 * 2 + 2 * y?

Как рекурсия обрабатывает карри? Если я определяю функцию

replicate' :: (Integral i, Ord i) => i -> a -> [a] 
replicate' n x 
    | n <= 0 = [] 
    | otherwise = x : replicate' (n - 1) x 

, что функция, возвращаемая (replicate' 3) в контексте (replicate 3) 'a'?

Answer 1

Это replicate' определено в явном кэрри виде:

replicate' :: (Integral i, Ord i) => i -> (a -> [a]) 
replicate' n 
    | n <= 0  = const [] 
    | otherwise = \x -> x : replicate' (n - 1) x 

Итак, replicate' 3 вычисляет выражение

if 3 <= 0 then const [] 
       else \x -> x : replicate' 2 x 

который только

\x -> x : replicate' 2 x 

Если он определен только с “ неявное каррирование ”, то компилятор может или не может вытащить условие n <= 0 из x связывания, поэтому на самом деле вы можете просто в конечном итоге с

\x -> if 3 <= 0 then const [] 
        else \x -> x : replicate' 2 x 

Answer 2

Я думаю, вы смешиваете две разные вещи

• выделки
• частичное применение функции

первый является

     ------currying-----> 
     f :: (a,b) -> c      f' :: a -> b -> c 
         <----uncurrying----- 

преобразования функцию, которая принимает tuple аргументов whi ch означает один аргумент двух объединенных вещей - в функцию, которая принимает один аргумент и создает функцию!

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

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

f :: a -> b -> c 

действительно

f :: a -> (b -> c) 

по крайней мере, в Haskell способ определения функций.