Work around simplifier problem in 6.12
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Fri, 19 Feb 2010 08:39:20 +0000 (08:39 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Fri, 19 Feb 2010 08:39:20 +0000 (08:39 +0000)
See [HACKS:Eq and Ord instances]

Data/Vector.hs
Data/Vector/Fusion/Stream.hs
Data/Vector/Primitive.hs
Data/Vector/Storable.hs
Data/Vector/Unboxed.hs
HACKS

index bf0a573..87c8e2c 100644 (file)
@@ -120,6 +120,7 @@ module Data.Vector (
 import qualified Data.Vector.Generic as G
 import           Data.Vector.Mutable  ( MVector(..) )
 import           Data.Primitive.Array
+import qualified Data.Vector.Fusion.Stream as Stream
 
 import Control.Monad ( liftM )
 
@@ -162,13 +163,30 @@ instance G.Vector Vector a where
   {-# INLINE basicUnsafeIndexM #-}
   basicUnsafeIndexM (Vector i _ arr) j = indexArrayM arr (i+j)
 
+-- See [HACKS:Eq and Ord instances]
 instance Eq a => Eq (Vector a) where
   {-# INLINE (==) #-}
-  (==) = G.eq
+  xs == ys = Stream.eq (G.stream xs) (G.stream ys)
 
+  {-# INLINE (/=) #-}
+  xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys))
+
+-- See [HACKS:Eq and Ord instances]
 instance Ord a => Ord (Vector a) where
   {-# INLINE compare #-}
-  compare = G.cmp
+  compare xs ys = Stream.cmp (G.stream xs) (G.stream ys)
+
+  {-# INLINE (<) #-}
+  xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT
+
+  {-# INLINE (<=) #-}
+  xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT
+
+  {-# INLINE (>) #-}
+  xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT
+
+  {-# INLINE (>=) #-}
+  xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT
 
 -- Length
 -- ------
index 112a8d7..f45baa6 100644 (file)
@@ -70,7 +70,9 @@ module Data.Vector.Fusion.Stream (
   toList, fromList, liftStream,
 
   -- * Monadic combinators
-  mapM_, foldM, fold1M, foldM', fold1M'
+  mapM_, foldM, fold1M, foldM', fold1M',
+
+  eq, cmp
 ) where
 
 import Data.Vector.Fusion.Stream.Size
index 6b47d2f..f0741f9 100644 (file)
@@ -80,6 +80,7 @@ module Data.Vector.Primitive (
 
 import qualified Data.Vector.Generic           as G
 import           Data.Vector.Primitive.Mutable ( MVector(..) )
+import qualified Data.Vector.Fusion.Stream as Stream
 import           Data.Primitive.ByteArray
 import           Data.Primitive ( Prim )
 
@@ -127,13 +128,30 @@ instance Prim a => G.Vector Vector a where
   {-# INLINE elemseq #-}
   elemseq _ = seq
 
+-- See [HACKS:Eq and Ord instances]
 instance (Prim a, Eq a) => Eq (Vector a) where
   {-# INLINE (==) #-}
-  (==) = G.eq
+  xs == ys = Stream.eq (G.stream xs) (G.stream ys)
 
+  {-# INLINE (/=) #-}
+  xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys))
+
+-- See [HACKS:Eq and Ord instances]
 instance (Prim a, Ord a) => Ord (Vector a) where
   {-# INLINE compare #-}
-  compare = G.cmp
+  compare xs ys = Stream.cmp (G.stream xs) (G.stream ys)
+
+  {-# INLINE (<) #-}
+  xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT
+
+  {-# INLINE (<=) #-}
+  xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT
+
+  {-# INLINE (>) #-}
+  xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT
+
+  {-# INLINE (>=) #-}
+  xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT
 
 -- Length
 -- ------
index 1430e04..c2d9d89 100644 (file)
@@ -84,6 +84,7 @@ module Data.Vector.Storable (
 import qualified Data.Vector.Generic          as G
 import           Data.Vector.Storable.Mutable ( MVector(..) )
 import Data.Vector.Storable.Internal
+import qualified Data.Vector.Fusion.Stream as Stream
 
 import Foreign.Storable
 import Foreign.ForeignPtr
@@ -140,9 +141,30 @@ instance Storable a => G.Vector Vector a where
   {-# INLINE elemseq #-}
   elemseq _ = seq
 
+-- See [HACKS:Eq and Ord instances]
 instance (Storable a, Eq a) => Eq (Vector a) where
   {-# INLINE (==) #-}
-  (==) = G.eq
+  xs == ys = Stream.eq (G.stream xs) (G.stream ys)
+
+  {-# INLINE (/=) #-}
+  xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys))
+
+-- See [HACKS:Eq and Ord instances]
+instance (Storable a, Ord a) => Ord (Vector a) where
+  {-# INLINE compare #-}
+  compare xs ys = Stream.cmp (G.stream xs) (G.stream ys)
+
+  {-# INLINE (<) #-}
+  xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT
+
+  {-# INLINE (<=) #-}
+  xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT
+
+  {-# INLINE (>) #-}
+  xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT
+
+  {-# INLINE (>=) #-}
+  xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT
 
 {-
 eq_memcmp :: forall a. Storable a => Vector a -> Vector a -> Bool
@@ -165,9 +187,6 @@ foreign import ccall unsafe "string.h memcmp" memcmp
  #-}
 -}
 
-instance (Storable a, Ord a) => Ord (Vector a) where
-  {-# INLINE compare #-}
-  compare = G.cmp
 
 -- Length
 -- ------
index 884be78..9e89f42 100644 (file)
@@ -100,13 +100,30 @@ import qualified Prelude
 
 #include "vector.h"
 
+-- See [HACKS:Eq and Ord instances]
 instance (Unbox a, Eq a) => Eq (Vector a) where
   {-# INLINE (==) #-}
-  (==) = G.eq
+  xs == ys = Stream.eq (G.stream xs) (G.stream ys)
 
+  {-# INLINE (/=) #-}
+  xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys))
+
+-- See [HACKS:Eq and Ord instances]
 instance (Unbox a, Ord a) => Ord (Vector a) where
   {-# INLINE compare #-}
-  compare = G.cmp
+  compare xs ys = Stream.cmp (G.stream xs) (G.stream ys)
+
+  {-# INLINE (<) #-}
+  xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT
+
+  {-# INLINE (<=) #-}
+  xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT
+
+  {-# INLINE (>) #-}
+  xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT
+
+  {-# INLINE (>=) #-}
+  xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT
 
 instance (Show a, Unbox a) => Show (Vector a) where
     show = (Prelude.++ " :: Data.Vector.Unboxed.Vector") . ("fromList " Prelude.++) . show . toList
diff --git a/HACKS b/HACKS
index a2b3c6c..0b8dced 100644 (file)
--- a/HACKS
+++ b/HACKS
@@ -37,5 +37,6 @@ instance (..., Ord a) => Ord (Vector a) where
   {-# INLINE (>=) #-}
   xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT
 
-Ugly, but it works.
+Ugly, but it works. This also requires the package (but not necessarily the
+clients!) to be compiled with -fno-method-sharing.