packages feed

Unique 0.4.5 → 0.4.6

raw patch · 7 files changed

+243/−51 lines, 7 filesdep +QuickCheckdep +Uniquedep +hspecdep ~basePVP ok

version bump matches the API change (PVP)

Dependencies added: QuickCheck, Unique, hspec

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

Data/List/Unique.hs view
@@ -148,10 +148,15 @@ --  isUnique :: Eq a => a -> [a] -> Maybe Bool-isUnique x = checkNumber . countElem x-    where checkNumber 0 = Nothing-          checkNumber 1 = Just True-          checkNumber _ = Just False+isUnique a = go Nothing a+    where go s _ [] = s+          go s@Nothing x (z:zs)+            | x == z = go (Just True) x zs+            | otherwise = go s x zs+          go s@(Just True) x (z:zs)+            | x == z = Just False+            | otherwise = go s x zs+          go s@(Just False) _ _ = s  -- | 'isRepeated' is a reverse function to 'isUnique' --
Unique.cabal view
@@ -1,72 +1,50 @@--- Initial Unique.cabal generated by cabal init.  For further--- documentation, see http://haskell.org/cabal/users-guide/---- The name of the package. name:                Unique --- The package version.  See the Haskell package versioning policy (PVP)--- for standards guiding when and how versions should be incremented.--- http://www.haskell.org/haskellwiki/Package_versioning_policy--- PVP summary:      +-+------- breaking API changes---                   | | +----- non-breaking API additions---                   | | | +--- code changes with no API change-version:             0.4.5---- A short (one-line) description of the package.-synopsis:           It provides the functionality like unix "uniq" utility---- A longer description of the package.-description:      Library provides the functions to find unique and duplicate elements in the list+version:             0.4.6 --- The license under which the package is released.+synopsis:            It provides the functionality like unix "uniq" utility+description:         Library provides the functions to find unique and duplicate elements in the list license:             BSD3---- The file containing the license text. license-file:        LICENSE---- The package author(s). author:              Volodymyr Yaschenko---- An email address to which users can send suggestions, bug reports, and--- patches. maintainer:          ualinuxcn@gmail.com- category:            Data- build-type:          Simple---- Extra files to be distributed with the package, such as examples or a--- README.--- extra-source-files:---- Constraint on the version of Cabal needed to build this package. cabal-version:       >=1.10  source-repository head-   type:        darcs-   location:    http://hub.darcs.net/kapral/Unique/+   type:             darcs+   location:         http://hub.darcs.net/kapral/Unique/  library-  -- Modules exported by the library.   exposed-modules:      Data.List.Unique,                         Data.List.UniqueStrict,                         Data.List.UniqueUnsorted -  -- Modules included in this library but not exported.-  -- other-modules:--  -- LANGUAGE extensions used by modules in this package.-  -- other-extensions:--  -- Other library packages from which modules are imported.   build-depends:         base >=4.0 && < 5                        , extra                        , containers                        , hashable                        , unordered-containers-  -- Directories containing source files.-  -- hs-source-dirs:+  default-language:    Haskell2010+  ghc-options:         -Wall -O2 -  -- Base language which the package is written in.++Test-Suite HspecTest+  type:                exitcode-stdio-1.0+  hs-source-dirs:      tests+  main-is:             Main.hs+  other-modules:       Complex+                     , IsUnique+                     , RepeatedBy+                     , SortUniq++  build-depends:       base >=4.8 && <4.9+                     , hspec+                     , containers+                     , QuickCheck+                     , Unique+   default-language:    Haskell2010-  ghc-options:         -Wall+  ghc-options:        -Wall -O2+
+ tests/Complex.hs view
@@ -0,0 +1,26 @@+module Complex where++import Test.Hspec+import Test.QuickCheck++import Data.List.Unique+import Data.List (sort)+++triplet :: (a -> b) -> (a, a, a) -> (b, b, b)+triplet f (x, y, z) = (f x, f y, f z)++complexTests :: SpecWith ()+complexTests =+  describe "Data.List.Unique.complex" $ do+  +  it "complex: should return ([],[],[]) with empty list" $ do+    complex ( [] :: [Int] ) `shouldBe` ([],[],[])++  it "complex: simple test" $ do+    complex "This is the test line" `shouldBe` ("This teln","is hte","Tln")++  it "complex: returns the same result as `sortUniq`, `repeated`, `unique` but not sorted" $+    property $+    \ xs -> triplet sort ( complex (xs :: String) )+            == (sortUniq xs, repeated xs, unique xs)
+ tests/IsUnique.hs view
@@ -0,0 +1,74 @@+module IsUnique where++import Test.Hspec+import Test.QuickCheck+import Control.Exception (evaluate)+import Data.Maybe (isJust, isNothing)++import Data.List.Unique++isUniqueTests :: SpecWith ()+isUniqueTests =+  describe "Data.List.Unique.isUnique" $ do+  it "isUnique should return Nothing with empty list" $ do+    isUnique (1 :: Int) [] +    `shouldBe`+      Nothing++  it "isUnique should return Nothing with empty list (quickCheck)" $+    property $+    \x -> isNothing $ isUnique (x :: Char) []++  it "isUnique, returns (Just True) when element is unique" $ do+    isUnique 'a' "foo bar"  `shouldBe` Just True++  it "isUnique , returns (Just False) when list has duplicate of element" $ do+    isUnique 'o' "foo bar" `shouldBe` Just False++  it "isUnique is a lazy function, 'undefined test'" $ do+    isUnique 'g' ['g','a','g', undefined ]+    `shouldBe`+      Just False++  it "isUnique is a lazy function, 'undefined test'. Generates exeption" $ do+    evaluate (isUnique 't' ['t', 'd', undefined] )+    `shouldThrow`+      errorCall "Prelude.undefined"++  it "isRepeated is a lazy function too, 'undefined test'" $ do+    isRepeated 'g' ['g','a','g', undefined ]+    `shouldBe`+      Just True++  it "isRepeated is reverse function to isUnique" $ do+    property $+      \ x xs+      -> isUnique (x :: Int) xs == fmap not (isRepeated x xs)++  it "isUnique should return (Just ANY) when element is exist in the list" $+    property $+    \ ( NonEmpty ls@(x:xs) )+    -> not (null xs)+       ==>  isJust (isUnique (x :: Char) ls)++  context "isUnique should return (Just False) when at least two elements are exist in the list" $+    it "- It checks laziness as well" $+      property $+        \ ( NonEmpty ls@(x:xs) )+        -> not (null xs)+           ==>  isJust $ isUnique (x :: Char) (ls ++ [x, undefined])++  it "isUnique should return Nothing when element is absent in the list" $+    property $+    \ x xs+    -> notElem x xs+       ==> isNothing (isUnique (x :: Char) xs)+      +  it "isUnique and isRepeated should return Nothing when element is absent in the list" $+    property $+    \ x xs+    -> notElem x xs+       ==> isNothing (isUnique (x :: Char) xs)+       &&  isNothing (isRepeated x xs)++
+ tests/Main.hs view
@@ -0,0 +1,8 @@+import IsUnique+import SortUniq+import RepeatedBy+import Complex+import Test.Hspec++main :: IO ()+main = mapM_ hspec [isUniqueTests, sortUniqTests, repeatedByTests, complexTests]
+ tests/RepeatedBy.hs view
@@ -0,0 +1,57 @@+module RepeatedBy where++import Test.Hspec+import Test.QuickCheck++import Data.List.Unique+import Data.List (sort, group)+++repeatedByTests :: SpecWith ()+repeatedByTests =+  describe "Data.List.Unique.repeatedBy,repeated,unique" $ do+  +  it "repeatedBy: should return [] with empty list" $ do+    repeatedBy (>100) ( [] :: [Int] ) `shouldBe` []++  it "repeatedBy: simple test" $ do+    repeatedBy (>2) "This is the test line" `shouldBe` " eist"++  it "repeatedBy: returns [] when predicate (=< negative) " $+    property $+    \x xs -> x < 0+             ==> null ( repeatedBy (<= x) (xs :: String) )++  it "repeatedBy: removes the duplicated elements like `sortUniq` function when predicate (>= negative)" $+     property $+     \ x xs -> x < 0+               ==> repeatedBy (>= x) (xs :: String) == sortUniq xs++  it "repeatedBy: returns [] when preficate (== 0)" $+     property $+     \ xs -> null ( repeatedBy (== 0) (xs :: [Int]) )++  it "repeatedBy: returns sorted result" $+     property $+     \x xs ->  x > 0+              ==> repeatedBy (> x) (xs :: String) == sort (repeatedBy (> x) xs)++  it "repeatedBy: resulted elements should occur only once" $+    property $+    \ x xs -> x > 0+              ==> all (==1) . map length . group $ repeatedBy (> x) ( xs :: String )++  it "unique: simple test" $ do+    unique  "foo bar" `shouldBe` " abfr"++  it "repeated: simple test" $ do+    repeated  "foo bar" `shouldBe` "o"++  it "unique: multiple execution should return the same result" $+    property $+    \ xs -> unique (xs :: String) == unique (unique xs)++  it "repeated && unique: should return different result on the same non empty list" $+    property $+    \ xs -> not (null xs)+            ==> repeated (xs :: String) /= unique xs
+ tests/SortUniq.hs view
@@ -0,0 +1,44 @@+module SortUniq where++import Test.Hspec+import Test.QuickCheck++import Data.List.Unique+import Data.List (sort, group)+import Data.Set (fromList, toList)+++sortUniqTests :: SpecWith ()+sortUniqTests =+  describe "Data.List.Unique.sortUniq" $ do+  +  it "sortUniq: should return [] with empty list" $ do+    sortUniq ( [] :: [Int] ) `shouldBe` []++  it "sortUniq: simple test" $ do+    sortUniq "foo bar" `shouldBe` " abfor"++  it "sortUniq: multiple execution should return the same result" $+    property $+    \ xs -> sortUniq (sortUniq ( xs :: String) ) == sortUniq xs++  it "sortUniq: the result has to be sorted" $+    property $+    \ xs -> sortUniq ( xs :: [Int] ) == sort (sortUniq xs)++  it "sortUniq: elements should occur only once" $+    property $+    \ ( NonEmpty ls@(x:_) ) -> isUnique (x :: Float) (sortUniq ls) == Just True++  it "sortUniq: elements should occur only once #2" $+    property $+    \ xs -> all (==1) . map length . group $ sortUniq ( xs :: [Integer] )++  it "sortUniq: check if it's correct by slow analog function" $+    property $+    \ xs -> ( map head . group . sort $ (xs :: String) )+            == sortUniq xs++  it "sortUniq: check if it's correct by the Faster analog function :)" $+    property $+    \ xs -> sortUniq ( xs :: String ) == toList (fromList xs)