-----------------------------------------------------------------------------
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
-- 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, sort )
-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.
-}
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
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
-- | 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