Revert "Use dropWhileEndLE p instead of reverse . dropWhile p . reverse"

This reverts commit 2a885688.

compiler/basicTypes/OccName.lhs

@@ -833,7 +833,7 @@ tidyOccName env occ@(OccName occ_sp fs)
         Nothing -> (addToUFM env fs 1, occ)
   where
     base :: String  -- Drop trailing digits (see Note [TidyOccEnv])
-    base = dropWhileEndLE isDigit (unpackFS fs)
+    base = reverse (dropWhile isDigit (reverse (unpackFS fs)))
 
     find n
       = case lookupUFM env new_fs of

compiler/utils/Util.lhs

@@ -23,8 +23,6 @@ module Util (
         mapAndUnzip, mapAndUnzip3, mapAccumL2,
         nOfThem, filterOut, partitionWith, splitEithers,
 
-        dropWhileEndLE,
-
         foldl1', foldl2, count, all2,
 
         lengthExceeds, lengthIs, lengthAtLeast,
@@ -595,18 +593,6 @@ dropTail n xs
     go _      _      = []  -- Stop when ys runs out
                            -- It'll always run out before xs does
 
--- dropWhile from the end of a list. This is similar to Data.List.dropWhileEnd,
--- but is lazy in the elements and strict in the spine. For reasonably short lists,
--- such as path names and typical lines of text, dropWhileEndLE is generally
--- faster than dropWhileEnd. Its advantage is magnified when the predicate is
--- expensive--using dropWhileEndLE isSpace to strip the space off a line of text
--- is generally much faster than using dropWhileEnd isSpace for that purpose.
--- Specification: dropWhileEndLE p = reverse . dropWhile p . reverse
--- Pay attention to the short-circuit (&&)! The order of its arguments is the only
--- difference between dropWhileEnd and dropWhileEndLE.
-dropWhileEndLE :: (a -> Bool) -> [a] -> [a]
-dropWhileEndLE p = foldr (\x r -> if null r && p x then [] else x:r) []
-
 snocView :: [a] -> Maybe ([a],a)
         -- Split off the last element
 snocView [] = Nothing
@@ -665,7 +651,7 @@ cmpList cmp (a:as) (b:bs)
 
 \begin{code}
 removeSpaces :: String -> String
-removeSpaces = dropWhileEndLE isSpace . dropWhile isSpace
+removeSpaces = reverse . dropWhile isSpace . reverse . dropWhile isSpace
 \end{code}
 
 %************************************************************************

libraries/base/GHC/Windows.hs

@@ -69,7 +69,6 @@ import GHC.Base
 import GHC.IO
 import GHC.Num
 import System.IO.Error
-import Util
 
 import qualified Numeric
 
@@ -121,7 +120,7 @@ errCodeToIOError fn_name err_code = do
     -- XXX we should really do this directly.
     let errno = c_maperrno_func err_code
 
-    let msg' = dropWhileEndLE isSpace msg -- drop trailing \n
+    let msg' = reverse $ dropWhile isSpace $ reverse msg -- drop trailing \n
         ioerror = errnoToIOError fn_name errno Nothing Nothing
                     `ioeSetErrorString` msg'
     return ioerror

utils/hpc/HpcMarkup.hs

@@ -140,16 +140,6 @@ charEncodingTag =
     "<meta http-equiv=\"Content-Type\" " ++
           "content=\"text/html; " ++ "charset=" ++ show localeEncoding ++ "\">"
 
--- Add characters to the left of a string until it is at least as
--- large as requested.
-padLeft :: Int -> Char -> String -> String
-padLeft n c str = go n str
-  where
-    -- If the string is already long enough, stop traversing it.
-    go 0 _       = str
-    go k []      = replicate k c ++ str
-    go k (_:xs)  = go (k-1) xs
-
 genHtmlFromMod
   :: String
   -> Flags
@@ -220,7 +210,8 @@ genHtmlFromMod dest_dir flags tix theFunTotals invertOutput = do
   content <- readFileFromPath (hpcError markup_plugin) origFile theHsPath
 
   let content' = markup tabStop info content
-  let addLine n xs = "<span class=\"lineno\">" ++ padLeft 5 ' ' (show n) ++ " </span>" ++ xs
+  let show' = reverse . take 5 . (++ "       ") . reverse . show
+  let addLine n xs = "<span class=\"lineno\">" ++ show' n ++ " </span>" ++ xs
   let addLines = unlines . map (uncurry addLine) . zip [1 :: Int ..] . lines
   let fileName = modName0 ++ ".hs.html"
   putStrLn $ "Writing: " ++ fileName
@@ -372,14 +363,10 @@ openTick (TopLevelDecl True 1)
 openTick (TopLevelDecl True n0)
          = "<span class=\"funcount\">-- entered " ++ showBigNum n0 ++ " times</span>" ++ openTopDecl
   where showBigNum n | n <= 9999 = show n
-                     | otherwise = case n `quotRem` 1000 of
-                                     (q, r) -> showBigNum' q ++ "," ++ showWith r
+                     | otherwise = showBigNum' (n `div` 1000) ++ "," ++ showWith (n `mod` 1000)
         showBigNum' n | n <= 999 = show n
-                      | otherwise = case n `quotRem` 1000 of
-                                      (q, r) -> showBigNum' q ++ "," ++ showWith r
-        showWith n = padLeft 3 '0' $ show n
-
-
+                      | otherwise = showBigNum' (n `div` 1000) ++ "," ++ showWith (n `mod` 1000)
+        showWith n = take 3 $ reverse $ ("000" ++) $ reverse $ show n
 
 closeTick :: String
 closeTick = "</span>"
@@ -475,7 +462,7 @@ instance Monoid ModuleSummary where
 
 writeFileUsing :: String -> String -> IO ()
 writeFileUsing filename text = do
-  let dest_dir = dropWhileEndLE (\ x -> x /= '/') $ filename
+  let dest_dir = reverse . dropWhile (\ x -> x /= '/') . reverse $ filename
 
 -- We need to check for the dest_dir each time, because we use sub-dirs for
 -- packages, and a single .tix file might contain information about

utils/hpc/HpcUtils.hs

@@ -3,10 +3,6 @@ module HpcUtils where
 import Trace.Hpc.Util
 import qualified Data.Map as Map
 
-dropWhileEndLE :: (a -> Bool) -> [a] -> [a]
--- Spec: dropWhileEndLE p = reverse . dropWhileEnd . reverse
-dropWhileEndLE p = foldr (\x r -> if null r && p x then [] else x:r) []
-
 -- turns \n into ' '
 -- | grab's the text behind a HpcPos; 
 grabHpcPos :: Map.Map Int String -> HpcPos -> String