尝试此版本：

mergesort :: [String] -> [String]
mergesort = mergesort' . map wrap

mergesort' :: [[String]] -> [String]
mergesort' [] = []
mergesort' [xs] = xs
mergesort' xss = mergesort' (merge_pairs xss)

merge_pairs :: [[String]] -> [[String]]
merge_pairs [] = []
merge_pairs [xs] = [xs]
merge_pairs (xs:ys:xss) = merge xs ys : merge_pairs xss

merge :: [String] -> [String] -> [String]
merge [] ys = ys
merge xs [] = xs
merge (x:xs) (y:ys)
 = if x > y
        then y : merge (x:xs)  ys
        else x : merge  xs    (y:ys)

wrap :: String -> [String]
wrap x = [x]

1.坏主意是先拆分列表。而不是只做一个成员列表的列表。 haskell 很懒，它会在正确的时间完成。
1.然后合并成对的列表，直到只有一个列表。

在Haskell中，字符串是一个懒惰的字符列表，它的开销和任何其他列表一样。如果我记得2004年Simon佩顿Jones的给予，GHC中的空间开销是每个字符40字节。对于一个苹果对苹果的比较，你可能应该排序Data.ByteString，它的设计是为了提供与其他语言相当的性能。

更好的方法是拆分列表，以避免CesarB指出的问题：

split []             = ([], [])
split [x]            = ([x], [])
split (x : y : rest) = (x : xs, y : ys)
                       where (xs, ys) = split rest

mergeSort []  = []
mergeSort [x] = [x]
mergeSort xs  = merge (mergesort ys) (mergesort zs)
                where (ys, zs) = split xs

编辑：已修复。

我不确定这是否是您的问题的原因，但请记住列表是一种顺序数据结构，特别是length xs和splitAt n xs都需要花费与列表长度（O(n)）成比例的时间。
在C和Java中，您最有可能使用数组，这两种操作都需要恒定的时间（O(1)）。
编辑：回答你关于如何使它更有效的问题，你也可以在Haskell中使用数组。