你会被currification弄糊涂（后面会有更多的介绍），你可以把(.)看作是接受两个参数（就像(+)一样）。

-- Associativity: infixr 9
--                             |- this parens. aren't necessary, but It helps to make them explicit
(.) :: (b -> c) -> (a -> b) -> (a -> c)
--     |- input 1  |- input 2  |- result function

字符串
现在，因为(.)是正确的，所以下面的两行代码是等效的

replicate 4 . reverse . take 3   
replicate 4 . (reverse . take 3) -- by right assoc. property

型
为了使这更明确，让我重写上面的代码

-- original
doSomething = replicate 4 . reverse . take 3 $ map (*2) [1..]

-- original with explicit parenthesis
doSomething = ( replicate 4 . (reverse . take 3) ) (map (*2) [1..])
              |               |- right assoc  -| | |              |
              |                                  | |              |
              |- these four are the result of deleting $ symbol  -|

-- factor out each parenthesis. Types are monomorphise for clarity.
doSomething = (replicateFour . takeThreeAndReverse) evenNumbers 
  where replicateFour       = replicate 4      -- :: [Int] -> [[Int]]  
        takeThreeAndReverse = reverse . take 3 -- :: [Int] -> [Int]
        evenNumbers         = map (*2) [1..]   -- :: [Int]

型
现在，我们在这里应用的技术被称为currying。可以总结为“一个接受两个参数的函数可以重写为一个接受一个参数的函数，并返回另一个接受一个参数的函数。”
一些python代码，以便于理解

# The following two are equivalent functions. 
def add(x, y):
  return x + y

def add_curry(x):
  def inner(y):
    return x + y
  return inner # we return a function not a value

add(3, 4) == add(3)(4) # notice double function call in RHS

型
现在，所有的haskell函数都是curried的，这实际上在函数式语言上很有意义，因为它简化了很多组合，并使语言在大多数情况下更符合人体工程学（当然，这是一个观点，其他人可能会有不同的看法）
咖喱在开始的时候可能会让人头疼，但最终它会变得很自然。克服它的最好方法是做大量的练习，并尝试使用大量的局部应用

简而言之，在多功能组合物的应用中，（t.z.f. g）”，函数composition的每个单独的composition将首先从右到左，通过点运算符的“infixr 9”的优先级进行评估，然后应用于参数“x”，因为组合和给定的参数由美元运算符分隔，美元运算符定义为优先级为“infixr 0”。

The composition: (t . z . f . g)

Each function's type:
t :: (d -> e)
z :: (c -> d)
f :: (b -> c)
g :: (a -> b)

Actual type: 
(t . z . f . g) :: a -> e

字符串
现在，由于currying，点运算符被定义为接受两个函数和一个值的三个参数，即“（b -> c）"，“（a -> b）”和“a”，如果点运算符只接受这两个函数，那么它将返回一个函数“（a -> c）”作为下一个点运算符的右操作数，依此类推。

Type in process for each composition with the dot operator:
(d -> e) . (c -> d) . (b -> c) . (a -> b) $ a
((d -> e) . (c -> d) . (b -> c) . (a -> b)) a
((d -> e) . (c -> d) . (a -> c)) a
((d -> e) . (a -> d)) a
(a -> e) a

型
在一个真实的案例中：

> :t (replicate 3 . reverse . take 3 . map (*3))
(replicate 3 . reverse . take 3 . map (*3))
  :: Num a => [a] -> [[a]]
> replicate 3 . reverse . take 3 . map (*3) $ [1..]
[[9,6,3],[9,6,3],[9,6,3]]

型
它像预期的那样工作：）
感谢@lsmor详细和鼓舞人心的回答。这篇文章是我的理解方式，不是关于哪个更好。非常感谢！