Haskell标准库（base包/Prelude）为何未内置split函数？

Great question! This is one of those quirks that catches many developers coming to Haskell from imperative or multi-paradigm languages off guard. Let's break down the main reasons:

• Haskell prioritizes a minimal, orthogonal core library
  The Prelude is designed to give you a small set of powerful, composable primitives rather than every convenience function you might think of. A basic split function can be easily built using existing functions like break or span—no need to bake it into the core. For example, here's a simple implementation that splits on a single delimiter:

  split :: Eq a => a -> [a] -> [[a]]
  split _ [] = []
  split delim str =
    let (chunk, rest) = break (== delim) str
    in chunk : case rest of
                 [] -> []
                 (_:remaining) -> split delim remaining
  

  This aligns with Haskell's functional programming ethos: build complex behavior by combining simple, reusable parts.

• words and lines solve specific, high-frequency problems
  Those two functions aren't general split utilities—they're optimized for super common use cases: splitting on whitespace (for text processing) or line breaks (for handling files/input). These operations are so ubiquitous that they deserve a dedicated spot in the Prelude, but a general split is less universally needed, and its behavior can vary (do you skip empty chunks? handle multi-character delimiters?).

• Third-party libraries fill the gap better
  The split package on Hackage doesn't just replicate a basic split—it offers a ton of flexibility: splitting on multiple delimiters, keeping or discarding empty segments, splitting on predicates, and more. By leaving this functionality to third-party libraries, the Haskell core team avoids cluttering the Prelude with edge cases and keeps the core library lean and stable.

• Historical and design conservatism
  The Prelude has evolved slowly and carefully over time. Adding a new function requires asking: does this truly belong in the minimal core? Will it confuse new users by adding unnecessary complexity? The core team tends to err on the side of keeping things simple, especially since a general split can be implemented or imported easily.

At the end of the day, it's all about Haskell's design philosophy: prioritize composability over convenience, keep the core minimal, and let the ecosystem handle specialized tools.

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