Haskell优化无限列表实现

Question

My code gives the wanted result but I wonder if there is a better way to code this. This is the given example:

pair [ 1 , 2 , 3 , 4 , 5 , 6 , ... ]
[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] , ... ]

and the given code:

pair::[a] -> [[a]]
pair =

My solution:

pair :: [a] -> [[a]]
pair (x:y:xs) = ((x:y:[]):[]) ++ pair xs

Answer 1

Using the cons operator : will be much more performant than concatenating lists:

pair :: [a] -> [[a]]
pair (x:y:xs) = [x, y] : pair xs

The reasoning is that lists in Haskell are linked lists where each item points to the next until the end of the list. Pushes and Pops are cheap when done at the head of the list because you are only pointing the head at the head of an existing list.

When you concatenate two linked list, you are essentially rebuilding the complete first list so that its last element can point at the first element of the second list.

The performance gain is minor in your example since you only have two elements in your list, but as a general rule, if you're dealing with operations on the head of the list, it's almost always going to be more performant to use cons.