add GHC.HetMet.{hetmet_kappa,hetmet_kappa_app}

[ghc-base.git] / Data / Version.hs

diff --git a/Data/Version.hs b/Data/Version.hs
index c52d21c..7d7d329 100644 (file)
--- a/Data/Version.hs
+++ b/Data/Version.hs
@@ -1,3 +1,5 @@
+{-# LANGUAGE CPP, DeriveDataTypeable #-}
+
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Version
@@ -24,10 +26,10 @@
 -----------------------------------------------------------------------------
 
 module Data.Version (
-       -- * The @Version@ type
-       Version(..),
-       -- * A concrete representation of @Version@
-       showVersion, parseVersion,
+        -- * The @Version@ type
+        Version(..),
+        -- * A concrete representation of @Version@
+        showVersion, parseVersion,
   ) where
 
 import Prelude -- necessary to get dependencies right
@@ -37,23 +39,21 @@ import Prelude -- necessary to get dependencies right
 -- of GHC.  In which case, we might need to pick up ReadP from 
 -- Distribution.Compat.ReadP, because the version in 
 -- Text.ParserCombinators.ReadP doesn't have all the combinators we need.
-#if __GLASGOW_HASKELL__ >= 603 || __HUGS__ || __NHC__
+#if __GLASGOW_HASKELL__ || __HUGS__ || __NHC__
 import Text.ParserCombinators.ReadP
 #else
 import Distribution.Compat.ReadP
 #endif
 
 #if !__GLASGOW_HASKELL__
-import Data.Typeable   ( Typeable, TyCon, mkTyCon, mkTyConApp )
-#elif __GLASGOW_HASKELL__ < 602
-import Data.Dynamic    ( Typeable(..), TyCon, mkTyCon, mkAppTy )
+import Data.Typeable    ( Typeable, TyCon, mkTyCon, mkTyConApp )
 #else
-import Data.Typeable   ( Typeable )
+import Data.Typeable    ( Typeable )
 #endif
 
-import Data.List       ( intersperse )
-import Control.Monad   ( liftM )
-import Data.Char       ( isDigit, isAlphaNum )
+import Data.List        ( intersperse, sort )
+import Control.Monad    ( liftM )
+import Data.Char        ( isDigit, isAlphaNum )
 
 {- |
 A 'Version' represents the version of a software entity.  
@@ -80,29 +80,29 @@ representation may be more appropriate.
 -}
 data Version = 
   Version { versionBranch :: [Int],
-               -- ^ The numeric branch for this version.  This reflects the
-               -- fact that most software versions are tree-structured; there
-               -- is a main trunk which is tagged with versions at various
-               -- points (1,2,3...), and the first branch off the trunk after
-               -- version 3 is 3.1, the second branch off the trunk after
-               -- version 3 is 3.2, and so on.  The tree can be branched
-               -- arbitrarily, just by adding more digits.
-               -- 
-               -- We represent the branch as a list of 'Int', so
-               -- version 3.2.1 becomes [3,2,1].  Lexicographic ordering
-               -- (i.e. the default instance of 'Ord' for @[Int]@) gives
-               -- the natural ordering of branches.
-
-          versionTags :: [String]  -- really a bag
-               -- ^ A version can be tagged with an arbitrary list of strings.
-               -- The interpretation of the list of tags is entirely dependent
-               -- on the entity that this version applies to.
-       }
+                -- ^ The numeric branch for this version.  This reflects the
+                -- fact that most software versions are tree-structured; there
+                -- is a main trunk which is tagged with versions at various
+                -- points (1,2,3...), and the first branch off the trunk after
+                -- version 3 is 3.1, the second branch off the trunk after
+                -- version 3 is 3.2, and so on.  The tree can be branched
+                -- arbitrarily, just by adding more digits.
+                -- 
+                -- We represent the branch as a list of 'Int', so
+                -- version 3.2.1 becomes [3,2,1].  Lexicographic ordering
+                -- (i.e. the default instance of 'Ord' for @[Int]@) gives
+                -- the natural ordering of branches.
+
+           versionTags :: [String]  -- really a bag
+                -- ^ A version can be tagged with an arbitrary list of strings.
+                -- The interpretation of the list of tags is entirely dependent
+                -- on the entity that this version applies to.
+        }
   deriving (Read,Show
-#if __GLASGOW_HASKELL__ >= 602
-       ,Typeable
+#if __GLASGOW_HASKELL__
+        ,Typeable
 #endif
-       )
+        )
 
 #if !__GLASGOW_HASKELL__
 versionTc :: TyCon
@@ -110,18 +110,12 @@ versionTc = mkTyCon "Version"
 
 instance Typeable Version where
   typeOf _ = mkTyConApp versionTc []
-#elif __GLASGOW_HASKELL__ < 602
-versionTc :: TyCon
-versionTc = mkTyCon "Version"
-
-instance Typeable Version where
-  typeOf _ = mkAppTy versionTc []
 #endif
 
 instance Eq Version where
   v1 == v2  =  versionBranch v1 == versionBranch v2 
-               && all (`elem` (versionTags v2)) (versionTags v1)
-               -- tags may be in any order
+                && sort (versionTags v1) == sort (versionTags v2)
+                -- tags may be in any order
 
 instance Ord Version where
   v1 `compare` v2 = versionBranch v1 `compare` versionBranch v2
@@ -140,7 +134,7 @@ showVersion (Version branch tags)
 
 -- | A parser for versions in the format produced by 'showVersion'.
 --
-#if __GLASGOW_HASKELL__ >= 603 || __HUGS__
+#if __GLASGOW_HASKELL__ || __HUGS__
 parseVersion :: ReadP Version
 #elif __NHC__
 parseVersion :: ReadPN r Version