diff --git a/src/Data/Ix/Enum.hs b/src/Data/Ix/Enum.hs new file mode 100644 --- /dev/null +++ b/src/Data/Ix/Enum.hs @@ -0,0 +1,39 @@ +{- | +Implementations of 'Ix' methods in terms of 'Enum' methods. + +For a type @T@ of class 'Enum' you can easily define an 'Ix' instance +by copying the following code into your module: + +>import qualified Data.Ix.Enum as IxEnum +> +>instance Ix T where +> range = IxEnum.range +> index = IxEnum.index +> inRange = IxEnum.inRange +> rangeSize = IxEnum.rangeSize +> unsafeIndex = IxEnum.unsafeIndex +> unsafeRangeSize = IxEnum.unsafeRangeSize + +-} +module Data.Ix.Enum where + +{-# INLINE range #-} +{-# INLINE index #-} +{-# INLINE unsafeIndex #-} +{-# INLINE inRange #-} +{-# INLINE rangeSize #-} +{-# INLINE unsafeRangeSize #-} + +range :: Enum a => (a, a) -> [a] +index :: Enum a => (a, a) -> a -> Int +unsafeIndex :: Enum a => (a, a) -> a -> Int +inRange :: Enum a => (a, a) -> a -> Bool +rangeSize :: Enum a => (a, a) -> Int +unsafeRangeSize :: Enum a => (a, a) -> Int + +range (l,r) = map toEnum $ range (fromEnum l, fromEnum r) +index (l,r) i = index (fromEnum l, fromEnum r) (fromEnum i) +unsafeIndex (l,r) i = unsafeIndex (fromEnum l, fromEnum r) (fromEnum i) +inRange (l,r) i = inRange (fromEnum l, fromEnum r) (fromEnum i) +rangeSize (l,r) = rangeSize (fromEnum l, fromEnum r) +unsafeRangeSize (l,r) = unsafeRangeSize (fromEnum l, fromEnum r) diff --git a/src/Data/List/HT/Private.hs b/src/Data/List/HT/Private.hs --- a/src/Data/List/HT/Private.hs +++ b/src/Data/List/HT/Private.hs @@ -278,6 +278,9 @@ @zip xs (map (flip List.delete xs) xs)@, but the implementation of 'removeEach' does not need the 'Eq' instance and thus can also be used for lists of functions. + +See also the proposal + -} removeEach :: [a] -> [(a, [a])] removeEach = diff --git a/src/Test.hs b/src/Test.hs deleted file mode 100644 --- a/src/Test.hs +++ /dev/null @@ -1,21 +0,0 @@ -module Main where - -import qualified Test.Data.List as ListHT -import qualified Test.Data.ListMatch as ListMatch -import qualified Test.Data.Maybe as MaybeHT -import qualified Test.Data.Function as FunctionHT - - -prefix :: String -> [(String, IO ())] -> [(String, IO ())] -prefix msg = - map (\(str,test) -> (msg ++ "." ++ str, test)) - -main :: IO () -main = - mapM_ (\(msg,io) -> putStr (msg++": ") >> io) $ - concat $ - prefix "List" ListHT.tests : - prefix "ListMatch" ListMatch.tests : - prefix "Maybe" MaybeHT.tests : - prefix "Function" FunctionHT.tests : - [] diff --git a/src/Test/Data/Function.hs b/src/Test/Data/Function.hs deleted file mode 100644 --- a/src/Test/Data/Function.hs +++ /dev/null @@ -1,18 +0,0 @@ -module Test.Data.Function where - -import qualified Data.Function.HT.Private as FuncHT - -import Test.QuickCheck (Property, quickCheck, (==>), ) - - -powerAssociative :: Eq a => - (a -> a -> a) -> a -> a -> Integer -> Property -powerAssociative op a0 a n = - n>0 ==> - FuncHT.powerAssociative op a0 a n == FuncHT.powerAssociative1 op a0 a n - - -tests :: [(String, IO ())] -tests = - ("powerAssociative", quickCheck (powerAssociative (+) :: Integer -> Integer -> Integer -> Property)) : - [] diff --git a/src/Test/Data/List.hs b/src/Test/Data/List.hs deleted file mode 100644 --- a/src/Test/Data/List.hs +++ /dev/null @@ -1,81 +0,0 @@ -module Test.Data.List where - -import qualified Data.List.HT.Private as ListHT -import qualified Data.List as List -import Control.Monad (liftM2, ) - -import Test.Utility (equalLists, equalInfLists, ) -import Test.QuickCheck (Testable, Property, quickCheck, (==>), ) - -import Prelude hiding (iterate, ) - - - -sieve :: Eq a => Int -> [a] -> Property -sieve n x = - n>0 ==> - equalLists [ListHT.sieve n x, - ListHT.sieve' n x, - ListHT.sieve'' n x, - ListHT.sieve''' n x] - - -sliceHorizontal :: Eq a => Int -> [a] -> Bool -sliceHorizontal n0 x = - let n = 1 + mod n0 1000 - in ListHT.sliceHorizontal n x == ListHT.sliceHorizontal' n x - - -sliceVertical :: Eq a => Int -> [a] -> Property -sliceVertical n x = - n>0 ==> - ListHT.sliceVertical n x == ListHT.sliceVertical' n x - -slice :: Eq a => Int -> [a] -> a -> Bool -slice n0 as a = - let x = a:as - n = 1 + mod n0 (length x) - in -- problems: ListHT.sliceHorizontal 4 [] == [[],[],[],[]] - ListHT.sliceHorizontal n x == List.transpose (ListHT.sliceVertical n x) && - ListHT.sliceVertical n x == List.transpose (ListHT.sliceHorizontal n x) - - - - -shear :: Eq a => [[a]] -> Bool -shear xs = - ListHT.shearTranspose xs == map reverse (ListHT.shear xs) - - - -outerProduct :: (Eq a, Eq b) => [a] -> [b] -> Bool -outerProduct xs ys = - concat (ListHT.outerProduct (,) xs ys) == liftM2 (,) xs ys - - - -iterate :: Eq a => (a -> a -> a) -> a -> Bool -iterate op a = - let xs = List.iterate (op a) a - ys = ListHT.iterateAssociative op a - zs = ListHT.iterateLeaky op a - in equalInfLists 1000 [xs, ys, zs] - - - -simple :: - (Testable test) => - (Int -> [Integer] -> test) -> IO () -simple = quickCheck - - -tests :: [(String, IO ())] -tests = - ("sieve", simple sieve) : - ("sliceHorizontal", simple sliceHorizontal) : - ("sliceVertical", simple sliceVertical) : - ("slice", simple slice) : - ("shear", quickCheck (shear :: [[Integer]] -> Bool)) : - ("outerProduct", quickCheck (outerProduct :: [Integer] -> [Int] -> Bool)) : - ("iterate", quickCheck (iterate (+) :: Integer -> Bool)) : - [] diff --git a/src/Test/Data/ListMatch.hs b/src/Test/Data/ListMatch.hs deleted file mode 100644 --- a/src/Test/Data/ListMatch.hs +++ /dev/null @@ -1,66 +0,0 @@ -module Test.Data.ListMatch where - -import qualified Data.List.Match.Private as Match -import qualified Data.List as List - -import Test.Utility (equalLists, ) -import Test.QuickCheck (Testable, quickCheck, ) - -import Prelude hiding (iterate, take, drop, splitAt, ) - - - -laxTail :: (Eq a) => [a] -> Bool -laxTail xs = - Match.laxTail xs == Match.laxTail0 xs - -take :: (Eq a) => [b] -> [a] -> Bool -take xs ys = - Match.take xs ys == List.take (length xs) ys - -drop :: (Eq a) => [b] -> [a] -> Bool -drop xs ys = - Match.drop xs ys == List.drop (length xs) ys - -dropAlt :: (Eq a) => [b] -> [a] -> Bool -dropAlt xs ys = - equalLists $ - Match.drop xs ys : - Match.drop0 xs ys : - Match.drop1 xs ys : - Match.drop2 xs ys : - Match.dropRec xs ys : - [] - -takeDrop :: (Eq a) => [b] -> [a] -> Bool -takeDrop xs ys = - Match.take xs ys ++ Match.drop xs ys == ys - -splitAt :: (Eq a) => [b] -> [a] -> Bool -splitAt xs ys = - (Match.take xs ys, Match.drop xs ys) == Match.splitAt xs ys - - -compareLength :: [a] -> [b] -> Bool -compareLength xs ys = - Match.compareLength xs ys == Match.compareLength0 xs ys && - Match.compareLength xs ys == Match.compareLength1 xs ys - - -test1 :: Testable test => ([Int] -> test) -> IO () -test1 = quickCheck - -test2 :: Testable test => ([Int] -> [Integer] -> test) -> IO () -test2 = quickCheck - - -tests :: [(String, IO ())] -tests = - ("laxTail", test1 laxTail) : - ("take", test2 take) : - ("drop", test2 drop) : - ("dropAlt", test2 dropAlt) : - ("takeDrop", test2 takeDrop) : - ("splitAt", test2 splitAt) : - ("compareLength", test2 compareLength) : - [] diff --git a/src/Test/Data/Maybe.hs b/src/Test/Data/Maybe.hs deleted file mode 100644 --- a/src/Test/Data/Maybe.hs +++ /dev/null @@ -1,17 +0,0 @@ -module Test.Data.Maybe where - -import Control.Monad (guard, ) -import Data.Maybe.HT (toMaybe, ) - -import Test.QuickCheck (quickCheck, ) - - -toMaybeGuard :: Eq a => Bool -> Maybe a -> Bool -toMaybeGuard b x = - (guard b >> x) == (toMaybe b =<< x) - - -tests :: [(String, IO ())] -tests = - ("toMaybeGuard", quickCheck (\b x -> toMaybeGuard b (x::Maybe Int))) : - [] diff --git a/src/Test/Utility.hs b/src/Test/Utility.hs deleted file mode 100644 --- a/src/Test/Utility.hs +++ /dev/null @@ -1,16 +0,0 @@ --- cf. Test.NumericPrelude.Utility -module Test.Utility where - -import Data.List.HT (mapAdjacent, ) -import qualified Data.List as List - - --- compare the lists simultaneously -equalLists :: Eq a => [[a]] -> Bool -equalLists xs = - let equalElems ys = - and (mapAdjacent (==) ys) && length xs == length ys - in all equalElems (List.transpose xs) - -equalInfLists :: Eq a => Int -> [[a]] -> Bool -equalInfLists n xs = equalLists (map (take n) xs) diff --git a/utility-ht.cabal b/utility-ht.cabal --- a/utility-ht.cabal +++ b/utility-ht.cabal @@ -1,5 +1,5 @@ Name: utility-ht -Version: 0.0.6 +Version: 0.0.7 License: BSD3 License-File: LICENSE Author: Henning Thielemann @@ -20,7 +20,7 @@ . Alternative packages: @Useful@, @MissingH@ Tested-With: GHC==6.8.2, GHC==6.10.4, GHC==6.12.3, GHC==7.0.2 -Cabal-Version: >=1.6 +Cabal-Version: >=1.10 Build-Type: Simple Source-Repository head @@ -30,22 +30,20 @@ Source-Repository this type: darcs location: http://code.haskell.org/~thielema/utility/ - tag: 0.0.6 - -Flag buildTests - description: Build test executables - default: False + tag: 0.0.7 Library Build-Depends: - base >=3 && <5 + base >=2 && <5 + Default-Language: Haskell98 GHC-Options: -Wall Hs-Source-Dirs: src Exposed-Modules: Data.Bool.HT Data.Eq.HT Data.Function.HT + Data.Ix.Enum Data.List.HT Data.List.Key Data.List.Match @@ -68,11 +66,13 @@ Data.Record.HT.Private -Executable test - If flag(buildTests) - Build-Depends: QuickCheck >=1.1 && <3 - Else - Buildable: False +Test-Suite test + Type: exitcode-stdio-1.0 + Build-Depends: + QuickCheck >=1.1 && <3, + base >=3 && <5 + Default-Language: Haskell98 + Main-Is: Test.hs GHC-Options: -Wall Hs-source-dirs: src Other-Modules: @@ -81,4 +81,3 @@ Test.Data.Maybe Test.Data.Function Test.Utility - Main-Is: Test.hs