utility-ht 0.0.6 → 0.0.7

raw patch · 9 files changed

+55/−233 lines, 9 filesdep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• src/Data/Ix/Enum.hs +39/−0
• src/Data/List/HT/Private.hs +3/−0
• src/Test.hs +0/−21
• src/Test/Data/Function.hs +0/−18
• src/Test/Data/List.hs +0/−81
• src/Test/Data/ListMatch.hs +0/−66
• src/Test/Data/Maybe.hs +0/−17
• src/Test/Utility.hs +0/−16
• utility-ht.cabal +13/−14

@@ -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)

@@ -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+ <http://www.haskell.org/pipermail/libraries/2008-February/009270.html> -} removeEach :: [a] -> [(a, [a])] removeEach =

@@ -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 :-      []

@@ -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)) :-   []

@@ -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)) :-   []

@@ -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) :-   []

@@ -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))) :-   []

@@ -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)

@@ -1,5 +1,5 @@ Name:             utility-ht-Version:          0.0.6+Version:          0.0.7 License:          BSD3 License-File:     LICENSE Author:           Henning Thielemann <haskell@henning-thielemann.de>@@ -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