《Real World Haskell》中splitLines函数的表达式求值逻辑咨询

Great question—let’s unpack this step by step, since lazy evaluation and Haskell’s pattern matching rules are key to understanding what’s happening here.

1. When does break’s result get evaluated? #

Haskell uses lazy evaluation, which means expressions are only computed when their values are actually needed. The break isLineTerminator cs call returns a tuple (pre, suf), but this tuple isn’t fully evaluated the moment you bind it in the let clause.

Instead:

• If you need the value of pre (like when we use it as the head of the result list), break will run just far enough to collect all characters until the first line terminator, then stop. It won’t touch the suf part yet.
• If you later need suf (like in the case expression), break will have already captured that remaining portion of the string, so accessing it just uses the already-determined suffix—break only traverses the string once total.

2. Execution flow of your splitLines function #

Let’s walk through your code line by line, using the full (assumed) definition:

splitLines [] = []
splitLines cs = 
  let (pre, suf) = break isLineTerminator cs
  in pre : case suf of
             ('\r':'\n':rest) -> splitLines rest
             ('\r':rest)      -> splitLines rest
             ('\n':rest)      -> splitLines rest
             _                -> []

Here’s the step-by-step execution when you call splitLines on a non-empty string:

1. Bind the tuple (but don’t compute it yet): The let clause creates a binding for (pre, suf) to the result of break, but no computation happens here—this is just a reference to the expression.
2. Trigger break to get pre: The expression pre : case ... needs to build a list. In Haskell, to construct a list x : xs, you first need to know the value of x (the head). So we need pre now. This triggers break to run: it scans cs until it hits the first line terminator, returns pre as the substring up to that point, and suf as the rest of the string starting with the terminator.
3. Process the suffix with case: Now that pre is known (and the first element of the result list is set), we need to compute the rest of the list—the result of the case suf of expression. This is when we actually inspect suf:
   • If suf starts with \r\n, we skip both characters and recursively call splitLines on the remaining string.
   • If it starts with just \r or \n, we skip that single character and recurse.
   • If suf is empty (no more line terminators), we return an empty list to end the result list.
4. Recurse until done: Each recursive call to splitLines repeats this same process: bind the tuple, trigger break to get the next line’s pre, then process the suffix.

To answer your specific question: You don’t "execute the let clause first" in a strict, eager way. The let binding is just a definition—computation only starts when parts of the tuple are needed. The pre gets evaluated first (to build the list head), then suf gets evaluated when the case expression needs to match against it.

Example walkthrough with "hello\r\nworld" #

• First call: splitLines "hello\r\nworld"
  • break runs until it hits \r, returning pre = "hello", suf = "\r\nworld"
  • case suf matches ('\r':'\n':rest) where rest = "world", so we recurse with splitLines "world"
• Second call: splitLines "world"
  • break scans the entire string (no line terminators), so pre = "world", suf = []
  • case suf matches the _ clause, returns []
• Final result: ["hello", "world"]

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