From 0ba209f121a2e56388062350d644d534aa6460fb Mon Sep 17 00:00:00 2001 From: sof Date: Mon, 30 Mar 1998 08:39:52 +0000 Subject: [PATCH] [project @ 1998-03-30 08:39:52 by sof] Common up error messages --- ghc/lib/std/PrelList.lhs | 59 +++++++++++++++++++++++++++++----------------- 1 file changed, 37 insertions(+), 22 deletions(-) diff --git a/ghc/lib/std/PrelList.lhs b/ghc/lib/std/PrelList.lhs index cae955e..b03bf92 100644 --- a/ghc/lib/std/PrelList.lhs +++ b/ghc/lib/std/PrelList.lhs @@ -44,21 +44,21 @@ infix 4 `elem`, `notElem` head :: [a] -> a head (x:_) = x -head [] = error "PreludeList.head: empty list" +head [] = errorEmptyList "head" last :: [a] -> a last [x] = x last (_:xs) = last xs -last [] = error "PreludeList.last: empty list" +last [] = errorEmptyList "last" tail :: [a] -> [a] tail (_:xs) = xs -tail [] = error "PreludeList.tail: empty list" +tail [] = errorEmptyList "tail" init :: [a] -> [a] init [x] = [] init (x:xs) = x : init xs -init [] = error "PreludeList.init: empty list" +init [] = errorEmptyList "init" null :: [a] -> Bool null [] = True @@ -97,7 +97,7 @@ foldl f z (x:xs) = foldl f (f z x) xs foldl1 :: (a -> a -> a) -> [a] -> a foldl1 f (x:xs) = foldl f x xs -foldl1 _ [] = error "PreludeList.foldl1: empty list" +foldl1 _ [] = errorEmptyList "foldl1" scanl :: (a -> b -> a) -> a -> [b] -> [a] scanl f q xs = q : (case xs of @@ -106,7 +106,7 @@ scanl f q xs = q : (case xs of scanl1 :: (a -> a -> a) -> [a] -> [a] scanl1 f (x:xs) = scanl f x xs -scanl1 _ [] = error "PreludeList.scanl1: empty list" +scanl1 _ [] = errorEmptyList "scanl1" -- foldr, foldr1, scanr, and scanr1 are the right-to-left duals of the -- above functions. @@ -114,7 +114,7 @@ scanl1 _ [] = error "PreludeList.scanl1: empty list" foldr1 :: (a -> a -> a) -> [a] -> a foldr1 f [x] = x foldr1 f (x:xs) = f x (foldr1 f xs) -foldr1 _ [] = error "PreludeList.foldr1: empty list" +foldr1 _ [] = errorEmptyList "foldr1" scanr :: (a -> b -> b) -> b -> [a] -> [b] scanr f q0 [] = [q0] @@ -125,7 +125,7 @@ scanr1 :: (a -> a -> a) -> [a] -> [a] scanr1 f [x] = [x] scanr1 f (x:xs) = f x q : qs where qs@(q:_) = scanr1 f xs -scanr1 _ [] = error "PreludeList.scanr1: empty list" +scanr1 _ [] = errorEmptyList "scanr1" -- iterate f x returns an infinite list of repeated applications of f to x: -- iterate f x == [x, f x, f (f x), ...] @@ -156,19 +156,19 @@ take :: Int -> [a] -> [a] take 0 _ = [] take _ [] = [] take n (x:xs) | n > 0 = x : take (n-1) xs -take _ _ = error "PreludeList.take: negative argument" +take _ _ = errorNegativeIdx "take" drop :: Int -> [a] -> [a] drop 0 xs = xs drop _ [] = [] drop n (_:xs) | n > 0 = drop (n-1) xs -drop _ _ = error "PreludeList.drop: negative argument" +drop _ _ = errorNegativeIdx "drop" splitAt :: Int -> [a] -> ([a],[a]) splitAt 0 xs = ([],xs) splitAt _ [] = ([],[]) splitAt n (x:xs) | n > 0 = (x:xs',xs'') where (xs',xs'') = splitAt (n-1) xs -splitAt _ _ = error "PreludeList.splitAt: negative argument" +splitAt _ _ = errorNegativeIdx "splitAt" #else /* hack away */ take :: Int -> [b] -> [b] @@ -181,30 +181,32 @@ take (I# n#) xs = takeUInt n# xs takeUInt :: Int# -> [b] -> [b] takeUInt n xs | n >=# 0# = take_unsafe_UInt n xs - | otherwise = error "take{PreludeList}: negative index" + | otherwise = errorNegativeIdx "take" take_unsafe_UInt 0# _ = [] -take_unsafe_UInt _ [] = [] -take_unsafe_UInt m (x:xs) = x : take_unsafe_UInt (m -# 1#) xs +take_unsafe_UInt m ls = + case ls of + [] -> ls + (x:xs) -> x : take_unsafe_UInt (m -# 1#) xs drop :: Int -> [b] -> [b] drop (I# n#) xs - | n# <# 0# = error "drop{PreludeList}: negative index" + | n# <# 0# = errorNegativeIdx "drop" | otherwise = drop# n# xs where drop# :: Int# -> [a] -> [a] drop# 0# xs = xs - drop# _ [] = [] + drop# _ xs@[] = xs drop# m# (_:xs) = drop# (m# -# 1#) xs splitAt :: Int -> [b] -> ([b], [b]) splitAt (I# n#) xs - | n# <# 0# = error "splitAt{PreludeList}: negative index" + | n# <# 0# = errorNegativeIdx "splitAt" | otherwise = splitAt# n# xs where splitAt# :: Int# -> [a] -> ([a], [a]) splitAt# 0# xs = ([], xs) - splitAt# _ [] = ([], []) + splitAt# _ xs@[] = (xs, xs) splitAt# m# (x:xs) = (x:xs', xs'') where (xs', xs'') = splitAt# (m# -# 1#) xs @@ -212,7 +214,7 @@ splitAt (I# n#) xs #endif /* USE_REPORT_PRELUDE */ span, break :: (a -> Bool) -> [a] -> ([a],[a]) -span p [] = ([],[]) +span p xs@[] = (xs, xs) span p xs@(x:xs') | p x = let (ys,zs) = span p xs' in (x:ys,zs) | otherwise = ([],xs) @@ -221,7 +223,7 @@ span p xs@(x:xs') break p = span (not . p) #else -- HBC version (stolen) -break p [] = ([],[]) +break p xs@[] = (xs, xs) break p xs@(x:xs') | p x = ([],xs) | otherwise = let (ys,zs) = break p xs' in (x:ys,zs) @@ -306,10 +308,10 @@ product l = prod l 1 -- maximum and minimum return the maximum or minimum value from a list, -- which must be non-empty, finite, and of an ordered type. maximum, minimum :: (Ord a) => [a] -> a -maximum [] = error "PreludeList.maximum: empty list" +maximum [] = errorEmptyList "maximum" maximum xs = foldl1 max xs -minimum [] = error "PreludeList.minimum: empty list" +minimum [] = errorEmptyList "minimum" minimum xs = foldl1 min xs concatMap :: (a -> [b]) -> [a] -> [b] @@ -418,3 +420,16 @@ unwords (w:ws) = w ++ ' ' : unwords ws #endif \end{code} + +Common up near identical calls to `error' to reduce the number +constant strings created when compiled: + +\begin{code} +errorEmptyList fun = + error (prel_list_str ++ fun ++ ": empty list") + +errorNegativeIdx fun = + error (prel_list_str ++ fun ++ ": negative index") + +prel_list_str = "PreludeList." +\end{code} -- 1.7.10.4