"foo" - "a -> b -> c". «foo. foo» также «a -> b -> c». Haskell относится к ним точно так же с точки зрения скорости?

Question

foo :: a -> b -> c 
foo = undefined 

ghci> :t foo 
foo :: a -> b -> c 

ghci> :t foo . foo 
foo . foo :: a -> b -> c 

ghci> :t foo . foo . foo 
foo . foo . foo :: a -> b -> c 

И так далее.

Типы те же. Мы также ясно видим, просто взглянув на типы, что все три эквивалентны. Они имеют одинаковый результат.

А как насчет скорости? Например, будет foo составлен для себя миллион раз с . автоматически (без оптимизации) бегать так же быстро, как foo? Если нет, будет ли оптимизация (O1 или O2) сделать это так?

Answer 1

Да, они выполняют то же самое, но только случайно. В GHCI:

> :i . 
(.) :: (b -> c) -> (a -> b) -> (a -> c)  -- Defined in ‘GHC.Base’ 
infixr 9 . 

Поскольку infixr, foo . foo . foo разбирает, как foo . (foo . foo), и поэтому мы можем писать ярлык foo . foo . foo . ... миллиард раз foldr. Итак:

> let foo :: a -> b -> c; foo = undefined 
> foldr (.) id (replicate 1000000000 foo)() 
*** Exception: Prelude.undefined 
CallStack (from HasCallStack): 
    error, called at libraries/base/GHC/Err.hs:79:14 in base:GHC.Err 
    undefined, called at <interactive>:1:5 in interactive:Ghci1 

Он возвращается почти сразу. С другой стороны, следующие два повисеть:

> foldl (.) id (replicate 1000000000 foo)() 
> foldr (flip (.)) id (replicate 1000000000 foo)() 

Однако, я должен еще раз подчеркнуть, что это совпадение реализации GHC, а не гарантия сделала семантику языка. Так получилось, что реализация GHC imprecise exceptions быстро замечает, что это будет ошибка (и выбрасывает самую левую ошибку foo) в случае foldr (.), но не так быстро отмечает foldl (.). И, конечно же, в случае, когда foo является не просто ошибкой, но и должен выполнять некоторые фактические вычисления, что вычисление нужно будет выполнять столько раз, сколько оно появляется в строке композиций - GHC довольно удивительно, но не волшебный ,