如何结合二元和一元函数来获得折叠的阶跃函数？

Question

在阅读Chapter 4 from Real World Haskell 时，我用以下几行解决了第 97 页的练习 1

asInt :: String -> Int
asInt ('-':x) = asInt x
asInt xs = foldl (\a x -> a*10 + digitToInt x) 0 xs

然后我从链接页面检查了一些cmets，并验证了这是大多数人采用的解决方案。

另一方面，我认为最好不要将函数编写为 lambda (\a x -> a*10 + digitToInt x)，因为它非常冗长，并且会为参数（a 和 x）命名，而实际上不需要给定一个，但作为其他函数的“组合”，即二元函数(*)、(+)和一元函数digitToInt；但是我不知道如何将这三个组合成一个与上面的 lambda 等效的二进制函数。

我认为构成的成分是(*10)，必须作用于foldl 的累加器的一元函数digitToInt，作用于列表元素xs 的一元函数，以及@ 987654334@，那得把这两者结合起来。

Answer 1

如果在调用foldl之前将每个数字转换为整数会更简单：

asInt xs = foldl (\a x -> a*10 + x) 0 (map digitToInt xs)
    -- == foldl ((+) . (10 *)) 0 (map digitToInt xs)

您可以进一步 eta 转换为

asInt = foldl ((+) . (10 *)) 0 . map digitToInt

（我相信，由于列表融合，不会创建由map 生成的中间列表。digitToInt 的每次调用的输出都会被foldl 立即使用，而不是放入列表。）

Answer 2

（你想了解无意义的函数在这里是如何工作的，所以在这里。）

首先。

(\a x -> a*10 + digitToInt x)
= 
(\a x -> (+) ((*10) a) (digitToInt x))
= 
(curry $ (+) . (*10) . fst <*> digitToInt . snd)
=
(curry $ uncurry (+) . ((*10) *** digitToInt))

第二个。

(\a x -> a*10 + digitToInt x)
= 
(\a x -> (+) ((*10) a) (digitToInt x))
= 
(\a x -> ((+) . (*10)) a . digitToInt $ x)
= 
(\a   -> ((+) . (*10)) a . digitToInt    )
= 
(\a   -> (. digitToInt) ( ((+) . (*10)) a ) )
= 
(\a   -> (. digitToInt) . ((+) . (*10)) $ a )
= 
         (. digitToInt) .  (+) . (*10)

它是如何工作的

首先。

(curry $ (+) . (*10) . fst <*> digitToInt . snd)  a  x
= {-  curry f a b  =  f (a, b)                               -}
        ((+) . (*10) . fst <*> digitToInt . snd) (a, x)
= {-  (f <*> g) a  =  f a (g a)   ;   (f . g) a  =  f (g a)  -}
   ((+) . (*10)) (fst (a, x)) (digitToInt ( snd  (a, x)))
=
   ((+) . (*10))       a      (digitToInt            x  )
= {-  (f . g) a  =  f (g a)   ;   (`c` b) a  =  (a `c` b)    -}
    (+)   (a*10)              (digitToInt            x  )
= {-  (c) a b  =  (a `c` b)                                  -}
          (a*10)            +  digitToInt            x

和，

(curry $ uncurry (+) . ((*10) *** digitToInt))  a  x
= {-  curry f a b  =  f (a, b)                -}
        (uncurry (+) . ((*10) *** digitToInt)) (a, x)
= {-  (f *** g) a  =  (f $ fst a, g $ snd a)  -}
         uncurry (+) (  (*10) a , digitToInt       x )
= {-  uncurry f (a, b)  =  f a b              -}
                 (+) (  (*10) a) (digitToInt       x )
= {-  (`c` b) a  =  (a `c` b)                 -}
                 (+)   (a*10)    (digitToInt       x )
= {-  (c) a b  =  (a `c` b)                   -}
                       (a*10)  +  digitToInt       x

第二个。

           ((. digitToInt) . (+) . (*10)) a x
= {-  (f . g) a  =  f (g a)     -}
           ((. digitToInt) . (+)) ((*10) a) x
= {-  (`c` b) a  =  (a `c` b)   -}
           ((. digitToInt) . (+)) (a*10)    x
= {-  (f . g) a  =  f (g a)     -}
            (. digitToInt) ( (+)  (a*10) )  x
= {-  (`c` b) a  =  (a `c` b)   -}
 ((+) (a*10) . digitToInt)                  x
= {-  (f . g) a  =  f (g a)     -}
  (+) (a*10) ( digitToInt                   x )
= {-  (c) a b  =  (a `c` b)     -}
      (a*10) + digitToInt                   x  

另一种可能性是部分无点，

foldl  (\a -> (a*10 +) . digitToInt)  ...

它比完整的 lambda 更短，但比所有完全无点的版本更具可读性。