Haskell高阶列表函数为何将函数作为首个参数？

Great question! This design choice is deeply tied to Haskell's core functional programming principles, and it's all about making common functional patterns cleaner and more flexible. Let's break down the key reasons:

1. Currying and Partial Application Are First-Class Citizens #

Every function in Haskell is automatically curried, meaning a function that takes multiple arguments can be called with fewer arguments to return a new, reusable function. By putting the function parameter first, partial application becomes trivial and intuitive.

For example:

-- Create a reusable function that adds 2 to every element of a list
addTwoToAll :: [Int] -> [Int]
addTwoToAll = map (+2)

-- Now we can use this function anywhere
addTwoToAll [1,3,5]  -- Output: [3,5,7]
addTwoToAll [10,20,30]  -- Output: [12,22,32]

If map took the list first, we'd have to write a clunkier lambda to get the same reusable function:

-- Less elegant alternative if map were list-first
addTwoToAll xs = xs `map` (+2)

Currying and partial application are foundational to Haskell's style, so this parameter order makes those patterns feel second nature.

2. Function Composition Flows More Smoothly #

Haskell uses the . operator for function composition, which lets you chain operations into a single, reusable pipeline. Placing the function first makes these pipelines read like a logical sequence of transformations (aligning with how composition works from right to left).

Take your example:

-- Instead of nested calls
filter (<4) (map (+2) [1,3,5])

-- We can compose the operations first
processList :: [Int] -> [Int]
processList = filter (<4) . map (+2)

-- Then apply it to the list
processList [1,3,5]  -- Output: [3]

This "define the pipeline, then feed data into it" pattern is everywhere in Haskell. If the parameters were reversed, composition would feel forced—you'd have to wrap everything in lambdas to make it work.

3. It Prioritizes "What You're Doing" Over "What You're Doing It To" #

In functional programming, we often think in terms of operations (functions) rather than objects or data structures. By putting the function first, Haskell makes the core logic of the call immediately visible.

When you see map (+2) [1,3,5], you first notice "we're adding 2 to each element"—the list is secondary. This aligns with the functional mindset of building up reusable operations and then applying them to data as needed.

Compare this to Scala's OO-influenced approach: List(1,3,5) map (_ +2) focuses first on the data (the list), then the operation. That makes sense for Scala's hybrid OO/functional design, but Haskell leans fully into the functional priority of operations.

4. Flexible Infix Syntax (When You Want It) #

As you noted, Haskell lets you turn any binary function into an infix operator with backticks:

(+2) `map` [1,3,5]

This gives you the option to write code that reads similarly to Scala when it's more readable, but the default prefix order still supports the core functional patterns we talked about. It's the best of both worlds—flexibility without sacrificing the power of currying and composition.

内容的提问来源于stack exchange，提问作者Izbassar Tolegen