COrdering (empty) → 2.1
raw patch · 6 files changed
+245/−0 lines, 6 filesdep +basesetup-changed
Dependencies added: base
Files
- AUTHORS +1/−0
- CHANGELOG +4/−0
- COrdering.cabal +46/−0
- Data/COrdering.hs +160/−0
- LICENSE +31/−0
- Setup.hs +3/−0
+ AUTHORS view
@@ -0,0 +1,1 @@+(c) Adrian HEY
+ CHANGELOG view
@@ -0,0 +1,4 @@+2.1 +--- +* Initial Hackage/Cabal release. + Version set to 2.1 to distinguish from the 2.0 (non-cabal) release on my home page.
+ COrdering.cabal view
@@ -0,0 +1,46 @@+Name: COrdering+Version: 2.1+Cabal-Version: >= 1.2+Build-Type: Simple+License: BSD3+License-File: LICENSE+Copyright: (c) Adrian Hey 2004-2008+Author: Adrian Hey+Maintainer: http://homepages.nildram.co.uk/~ahey/em.png+Stability: Stable+Homepage: http://www.haskell.org/haskellwiki/COrdering+Package-Url:+Synopsis: An algebraic data type similar to Prelude Ordering.+Description: Typically this is used as the return type of a combining comparison, which combines two+ values if they are deemed equal in some sense. Currently combining comparisons are used+ extensively by the AVL tree package (AvlTree).+Category: Data+Tested-With: GHC == 6.8.2, GHC == 6.8.1+Data-Files:+Extra-Source-Files: AUTHORS, CHANGELOG+Extra-Tmp-Files:+Author: Adrian Hey++Library+ Buildable: True+ Build-Depends: base+ Exposed-Modules: Data.COrdering+ Other-Modules:+ Extensions: CPP+ Hs-Source-Dirs: .+ Build-Tools:+ Ghc-Options: -O -Wall -split-objs+ Ghc-Prof-Options:+ Ghc-Shared-Options:+ Hugs-Options:+ Nhc98-Options:+ Includes:+ Install-Includes:+ Include-Dirs:+ C-Sources:+ Extra-Libraries:+ Extra-Lib-Dirs:+ CC-Options:+ LD-Options:+ Pkgconfig-Depends:+
+ Data/COrdering.hs view
@@ -0,0 +1,160 @@+-----------------------------------------------------------------------------+-- |+-- Module : Data.COrdering+-- Copyright : (c) Adrian Hey 2004-2008+-- License : BSD3+--+-- Maintainer : http://homepages.nildram.co.uk/~ahey/em.png+-- Stability : stable+-- Portability : portable+--+-- This module defines a useful variant of the "Prelude" `Ordering` data type.+--+-- Typically this data type is used as the result of a \"combining comparison\"+-- which combines values that are deemed to be equal (somehow). Note that the+-- functions defined here adhere to the same ordering convention as the overloaded+-- 'compare' (from the 'Ord' class). That is..+--+-- @+-- a \`compare\` b -> LT (or Lt) implies a < b+-- a \`compare\` b -> GT (or Gt) implies a > b+-- @+--+-- The combinators exported from this module have a \"CC\" suffix if they+-- return a combining comparison (most of them) and a \"C\" suffix if they return+-- an ordinary comparison. All the combinators defined here are INLINEd, in the hope+-- that the compiler can avoid the overhead of using HOFs for frequently+-- used comparisons (dunno if this does any good though :-)+-----------------------------------------------------------------------------+module Data.COrdering+ ( -- * Types+ COrdering(..),++ -- * Useful combinators++ -- ** Misc.+ unitCC,unitByCC,+ fstCC,fstByCC,+ sndCC,sndByCC,+ flipC,flipCC,++ -- ** For combining \"equal\" values with a user supplied function.+ withCC,withCC',withByCC,withByCC',++ ) where++import Data.Typeable++-- | Result of a combining comparison.+data COrdering a = Lt | Eq a | Gt deriving (Eq,Ord,Read,Show)++-- A name for the COrdering type constructor, fully qualified+cOrderingTyConName :: String+cOrderingTyConName = "Data.COrdering.COrdering"++-- A Typeable1 instance+instance Typeable1 COrdering where+ typeOf1 _ = mkTyConApp (mkTyCon cOrderingTyConName) []++#ifndef __GLASGOW_HASKELL__+-- A Typeable instance (not needed by ghc, but Haddock fails to document this instance)+instance Typeable e => Typeable (COrdering e) where+ typeOf = typeOfDefault+#endif++-- | A combining comparison for an instance of 'Ord' which returns unit () where appropriate.+{-# INLINE unitCC #-}+unitCC :: Ord a => (a -> a -> COrdering ())+unitCC a b = case compare a b of LT -> Lt+ EQ -> Eq ()+ GT -> Gt++-- | Create a combining comparison from an ordinary comparison by returning unit () where appropriate.+{-# INLINE unitByCC #-}+unitByCC :: (a -> b -> Ordering) -> (a -> b -> COrdering ())+unitByCC cmp a b = case cmp a b of LT -> Lt+ EQ -> Eq ()+ GT -> Gt++-- | A combining comparison for an instance of 'Ord' which keeps the first argument+-- if they are deemed equal. The second argument is discarded in this case.+{-# INLINE fstCC #-}+fstCC :: Ord a => (a -> a -> COrdering a)+fstCC a a' = case compare a a' of LT -> Lt+ EQ -> Eq a+ GT -> Gt++-- | Create a combining comparison from an ordinary comparison by keeping the first argument+-- if they are deemed equal. The second argument is discarded in this case.+{-# INLINE fstByCC #-}+fstByCC :: (a -> b -> Ordering) -> (a -> b -> COrdering a)+fstByCC cmp a b = case cmp a b of LT -> Lt+ EQ -> Eq a+ GT -> Gt++-- | A combining comparison for an instance of 'Ord' which keeps the second argument+-- if they are deemed equal. The first argument is discarded in this case.+{-# INLINE sndCC #-}+sndCC :: Ord a => (a -> a -> COrdering a)+sndCC a a' = case compare a a' of LT -> Lt+ EQ -> Eq a'+ GT -> Gt++-- | Create a combining comparison from an ordinary comparison by keeping the second argument+-- if they are deemed equal. The first argument is discarded in this case.+{-# INLINE sndByCC #-}+sndByCC :: (a -> b -> Ordering) -> (a -> b -> COrdering b)+sndByCC cmp a b = case cmp a b of LT -> Lt+ EQ -> Eq b+ GT -> Gt++-- | Create a combining comparison using the supplied combining function, which is applied if+-- 'compare' returns 'EQ'. See 'withCC'' for a stricter version of this function.+{-# INLINE withCC #-}+withCC :: Ord a => (a -> a -> b) -> (a -> a -> COrdering b)+withCC f a a' = case compare a a' of LT -> Lt+ EQ -> Eq (f a a')+ GT -> Gt++-- | Same as 'withCC', except the combining function is applied strictly.+{-# INLINE withCC' #-}+withCC' :: Ord a => (a -> a -> b) -> (a -> a -> COrdering b)+withCC' f a a' = case compare a a' of LT -> Lt+ EQ -> let b = f a a' in b `seq` Eq b+ GT -> Gt++-- | Create a combining comparison using the supplied comparison and combining function,+-- which is applied if the comparison returns 'EQ'. See 'withByCC'' for a stricter version+-- of this function.+{-# INLINE withByCC #-}+withByCC :: (a -> b -> Ordering) -> (a -> b -> c) -> (a -> b -> COrdering c)+withByCC cmp f a b = case cmp a b of LT -> Lt+ EQ -> Eq (f a b)+ GT -> Gt++-- | Same as 'withByCC', except the combining function is applied strictly.+{-# INLINE withByCC' #-}+withByCC' :: (a -> b -> Ordering) -> (a -> b -> c) -> (a -> b -> COrdering c)+withByCC' cmp f a b = case cmp a b of LT -> Lt+ EQ -> let c = f a b in c `seq` Eq c+ GT -> Gt++-- | Converts a comparison to one which takes arguments in flipped order, but+-- preserves the ordering that would be given by the \"unflipped\" version (disregarding type issues).+-- So it's not the same as using the prelude 'flip' (which would reverse the ordering too).+{-# INLINE flipC #-}+flipC :: (a -> b -> Ordering) -> (b -> a -> Ordering)+flipC cmp b a = case cmp a b of LT -> GT+ EQ -> EQ+ GT -> LT++-- | Converts a combining comparison to one which takes arguments in flipped order, but+-- preserves the ordering that would be given by the \"unflipped\" version (disregarding type issues).+-- So it's not the same as using the prelude 'flip' (which would reverse the ordering too).+{-# INLINE flipCC #-}+flipCC :: (a -> b -> COrdering c) -> (b -> a -> COrdering c)+flipCC cmp b a = case cmp a b of Lt -> Gt+ e@(Eq _) -> e+ Gt -> Lt++
+ LICENSE view
@@ -0,0 +1,31 @@+See the AUTHORS file for a list of copyright holders.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are+met:++ * Redistributions of source code must retain the above copyright+ notice, this list of conditions and the following disclaimer.++ * Redistributions in binary form must reproduce the above+ copyright notice, this list of conditions and the following+ disclaimer in the documentation and/or other materials provided+ with the distribution.++ * Neither the name of the copyright holders nor the names of+ other contributors may be used to endorse or promote products+ derived from this software without specific prior written+ permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.+
+ Setup.hs view
@@ -0,0 +1,3 @@+#!/usr/bin/runhaskell+import Distribution.Simple+main = defaultMain