From 10e529099e84e0270da4228132e27f0adae638b5 Mon Sep 17 00:00:00 2001 From: Ian Lynagh Date: Wed, 20 Aug 2008 23:19:37 +0000 Subject: [PATCH] Fix more warnings --- Control/Arrow.hs | 4 ++-- Control/Monad/Fix.hs | 1 + Control/Monad/Instances.hs | 1 + Data/Function.hs | 2 +- GHC/Exts.hs | 2 +- GHC/PArr.hs | 24 ++++++++++++------------ 6 files changed, 18 insertions(+), 16 deletions(-) diff --git a/Control/Arrow.hs b/Control/Arrow.hs index 174e695..ed9fa73 100644 --- a/Control/Arrow.hs +++ b/Control/Arrow.hs @@ -164,7 +164,7 @@ class Arrow a => ArrowZero a where zeroArrow :: a b c instance MonadPlus m => ArrowZero (Kleisli m) where - zeroArrow = Kleisli (\x -> mzero) + zeroArrow = Kleisli (\_ -> mzero) class ArrowZero a => ArrowPlus a where (<+>) :: a b c -> a b c -> a b c @@ -255,7 +255,7 @@ instance Monad m => ArrowApply (Kleisli m) where newtype ArrowApply a => ArrowMonad a b = ArrowMonad (a () b) instance ArrowApply a => Monad (ArrowMonad a) where - return x = ArrowMonad (arr (\z -> x)) + return x = ArrowMonad (arr (\_ -> x)) ArrowMonad m >>= f = ArrowMonad (m >>> arr (\x -> let ArrowMonad h = f x in (h, ())) >>> app) diff --git a/Control/Monad/Fix.hs b/Control/Monad/Fix.hs index d058220..c1b4fe1 100644 --- a/Control/Monad/Fix.hs +++ b/Control/Monad/Fix.hs @@ -63,6 +63,7 @@ class (Monad m) => MonadFix m where instance MonadFix Maybe where mfix f = let a = f (unJust a) in a where unJust (Just x) = x + unJust Nothing = error "mfix Maybe: Nothing" -- List: instance MonadFix [] where diff --git a/Control/Monad/Instances.hs b/Control/Monad/Instances.hs index 63c943f..ae7ef65 100644 --- a/Control/Monad/Instances.hs +++ b/Control/Monad/Instances.hs @@ -1,4 +1,5 @@ {-# OPTIONS_NHC98 --prelude #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} ----------------------------------------------------------------------------- -- | -- Module : Control.Monad.Instances diff --git a/Data/Function.hs b/Data/Function.hs index bc851a0..64ebfd0 100644 --- a/Data/Function.hs +++ b/Data/Function.hs @@ -80,4 +80,4 @@ fix f = let x = f x in x -- flip on (g . f) on :: (b -> b -> c) -> (a -> b) -> a -> a -> c -(*) `on` f = \x y -> f x * f y +(.*.) `on` f = \x y -> f x .*. f y diff --git a/GHC/Exts.hs b/GHC/Exts.hs index bc36771..9bdf128 100644 --- a/GHC/Exts.hs +++ b/GHC/Exts.hs @@ -92,7 +92,7 @@ groupWith :: Ord b => (a -> b) -> [a] -> [[a]] groupWith f xs = build (\c n -> groupByFB c n (\x y -> f x == f y) (sortWith f xs)) groupByFB :: ([a] -> lst -> lst) -> lst -> (a -> a -> Bool) -> [a] -> lst -groupByFB c n eq xs = groupByFBCore xs +groupByFB c n eq xs0 = groupByFBCore xs0 where groupByFBCore [] = n groupByFBCore (x:xs) = c (x:ys) (groupByFBCore zs) where (ys, zs) = span (eq x) xs diff --git a/GHC/PArr.hs b/GHC/PArr.hs index 726c687..ce93fbd 100644 --- a/GHC/PArr.hs +++ b/GHC/PArr.hs @@ -215,14 +215,14 @@ foldlP :: (a -> b -> a) -> a -> [:b:] -> a foldlP f z = snd . loop (foldEFL (flip f)) z foldl1P :: (a -> a -> a) -> [:a:] -> a -foldl1P f [::] = error "Prelude.foldl1P: empty array" +foldl1P _ [::] = error "Prelude.foldl1P: empty array" foldl1P f a = snd $ loopFromTo 1 (lengthP a - 1) (foldEFL f) (a!:0) a scanlP :: (a -> b -> a) -> a -> [:b:] -> [:a:] scanlP f z = fst . loop (scanEFL (flip f)) z scanl1P :: (a -> a -> a) -> [:a:] -> [:a:] -scanl1P f [::] = error "Prelude.scanl1P: empty array" +scanl1P _ [::] = error "Prelude.scanl1P: empty array" scanl1P f a = fst $ loopFromTo 1 (lengthP a - 1) (scanEFL f) (a!:0) a foldrP :: (a -> b -> b) -> b -> [:a:] -> b @@ -353,9 +353,9 @@ unzipP :: [:(a, b):] -> ([:a:], [:b:]) unzipP a = (fst $ loop (mapEFL fst) noAL a, fst $ loop (mapEFL snd) noAL a) -- FIXME: these two functions should be optimised using a tupled custom loop unzip3P :: [:(a, b, c):] -> ([:a:], [:b:], [:c:]) -unzip3P a = (fst $ loop (mapEFL fst3) noAL a, - fst $ loop (mapEFL snd3) noAL a, - fst $ loop (mapEFL trd3) noAL a) +unzip3P x = (fst $ loop (mapEFL fst3) noAL x, + fst $ loop (mapEFL snd3) noAL x, + fst $ loop (mapEFL trd3) noAL x) where fst3 (a, _, _) = a snd3 (_, b, _) = b @@ -420,13 +420,13 @@ instance Read a => Read [:a:] where -- properly fuse the following definitions. enumFromToP :: Enum a => a -> a -> [:a:] -enumFromToP x y = mapP toEnum (eftInt (fromEnum x) (fromEnum y)) +enumFromToP x0 y0 = mapP toEnum (eftInt (fromEnum x0) (fromEnum y0)) where eftInt x y = scanlP (+) x $ replicateP (y - x + 1) 1 enumFromThenToP :: Enum a => a -> a -> a -> [:a:] -enumFromThenToP x y z = - mapP toEnum (efttInt (fromEnum x) (fromEnum y) (fromEnum z)) +enumFromThenToP x0 y0 z0 = + mapP toEnum (efttInt (fromEnum x0) (fromEnum y0) (fromEnum z0)) where efttInt x y z = scanlP (+) x $ replicateP (abs (z - x) `div` abs delta + 1) delta @@ -623,8 +623,8 @@ loopFromTo :: Int -- from index loopFromTo from to mf start arr = runST (do marr <- newArray (to - from + 1) noElem (n', acc) <- trans from to marr arr mf start - arr <- mkPArr n' marr - return (arr, acc)) + arr' <- mkPArr n' marr + return (arr', acc)) where noElem = error "GHC.PArr.loopFromTo: I do not exist!" -- unlike standard Haskell arrays, this value represents an @@ -681,13 +681,13 @@ noAL = () -- mapEFL :: (e -> e') -> (e -> () -> (Maybe e', ())) {-# INLINE mapEFL #-} -mapEFL f = \e a -> (Just $ f e, ()) +mapEFL f = \e _ -> (Just $ f e, ()) -- `loop' mutator that filter elements according to a predicate -- filterEFL :: (e -> Bool) -> (e -> () -> (Maybe e, ())) {-# INLINE filterEFL #-} -filterEFL p = \e a -> if p e then (Just e, ()) else (Nothing, ()) +filterEFL p = \e _ -> if p e then (Just e, ()) else (Nothing, ()) -- `loop' mutator for array folding -- -- 1.7.10.4