无法理解非部分应用函数作为参数提供的高阶函数调用的结果

Question

I have a high-order function declaration to apply a function given as an argument twice:

twice :: (a -> a) -> a -> a
twice f x = f (f x)

The confusion comes from this GHCi session:

*Main> let _4 = twice twice
*Main> let __4 = twice twice (*2)
*Main> let _16 = _4 _4
*Main> let __16 = _4 __4
*Main> _16 (*2) 2
231584178474632390847141970017375815706539969331281128078915168015826259279872
*Main> __16 2
131072

It is kinda clear with __16 , because what's going on is just "multiplying" of this function call, so we'll actually get (2 ^ 16) * 2 after it's invocation. As far as I can understood it happens because function given as a parameter is already partially applied, so the type of either __4 and __16 is (Num a) => a -> a .

But the result of invocation of _16 with given function and integer arguments just leads me into confusion. I can understand that the type of either _4 and _16 are raw (are equal to twice function's signature, but are nested under the hood), but it gives me no clue about why the results differ so much. I just can't get program's semantics after providing a function that is not partially applied as an argument. Can somebody please explain why is this number just SO GREAT?

Answer 1

With Church numerals, the application of two numerals ab is equivalent to the exponential b^a . So, _4 _4 corresponds to 4^4=256 , not 16 .

Roughly: _4 f means f . f . f . f f . f . f . f f . f . f . f , ie "doing f four times, or "multiplying f by four". So, _4 _4 f means "multiplying f by four, four times", hence 4^4 .

Indeed:

> 2^256 * 2 :: Integer
231584178474632390847141970017375815706539969331281128078915168015826259279872

Answer 2

Looking at a reducing __16 2 a bit:

__16 2 = _4 __4 2
       = (twice twice) (twice twice (*2)) 2
       = twice (twice (twice twice (*2)) 2
       = twice (twice (twice (twice (*2)) 2

compared to

_16 (*2) 2 = _4 _4 (*2) 2
           = (twice twice) (twice twice) (*2) 2
           = twice (twice (twice twice)) (*2) 2

Notice with the __16 version, you are just directly doubling the number of times you apply (*2) with each twice . If you look carefully, you will see that the _16 version is parenthesized slightly differently. You are first doubling the doubling operation itself , and then you are applying that to (*2) and 2 .

The first few steps of reducing _16 (*2) 2 might look like this, following from above

     twice (twice (twice twice)) (*2) 2
   = twice (twice (\x -> twice (twice x))) (*2) 2
   = twice (\z -> (\x -> twice (twice x)) ((\y -> twice (twice y)) z)) (*2) 2
   = twice (\z -> (\x -> twice (twice x)) (twice (twice z))) (*2) 2
   = twice (\z -> twice (twice (twice (twice z)))) (*2) 2
   = (\z -> twice (twice (twice (twice z)))) ((\w -> twice (twice (twice (twice w)))) (*2)) 2
   = ((\z -> twice (twice (twice (twice z)))) (twice (twice (twice (twice (*2)))))) 2
   = twice (twice (twice (twice (twice (twice (twice (twice (*2)))))))) 2
   = ...

The innermost twice (*2) gives you two (*2) s. The next twice doubles that to 4 (*2) s, the one after that doubles that again to 8 (*2) s and so on. There are eight twice s in the above expression, so you end up with 2^8 = 256 (*2) s, so the result is 2 * (2^(2^8)) = 2 * (2^256) = 231584178474632390847141970017375815706539969331281128078915168015826259279872 .

Answer 3

twice isn't "twice", it's "squared" :

(^.) :: (a -> a) -> Int -> (a -> a)
(f^.n) x = foldr ($) x [f | _ <- [1..n]]   

((^.m) . (^.n)) f x = ((f^.n)^.m) x     
                  = foldr ($) x [f^.n | _ <- [1..m]]
                  = (f^.(m * n)) x
                  = (^.(m * n)) f x      

twice = (^.2)      -- f^.2 = f . f      f squared

_4   = twice twice
_4 f = (^.2) (^.2) f = ((^.2) . (^.2)) f = (f^.2)^.2 = f^.4    
_4   = (^.4)

       (^.3) (^.3) f = ((^.3) . (^.3) . (^.3)) f =
                     = ((^.3) . (^.3)) (f^.3)
                     =  (^.3) ((f^.3)^.3)
                     =   ((f^.3)^.3)^.3 = f^.(3*3*3) = f^.(3^3) = f^27 

       (^.4) (^.3) f = (((f^.3)^.3)^.3)^.3 = f^.(3*3*3*3) = f^.(3^4) = f^81

And in general,

       (^.m) (^.n) f = f^.(n^m)     

Functional composition is multiplication, and application is (reverse) exponentiation.

Thus we have

_16 f x = _4 _4 f x = (^.4) (^.4) f x = (f^.(4^4)) x = (f^.256) x

_16 (*2) 2 = ((*2)^.256) 2 = (* (2^256)) 2 = 2^257

*Main> _16 (*2) 2
231584178474632390847141970017375815706539969331281128078915168015826259279872

*Main> 2^257
231584178474632390847141970017375815706539969331281128078915168015826259279872