diff --git a/assoc-listlike.cabal b/assoc-listlike.cabal --- a/assoc-listlike.cabal +++ b/assoc-listlike.cabal @@ -1,16 +1,18 @@ +cabal-version: 3.0 + name: assoc-listlike -version: 0.1.0.0 +version: 0.1.0.1 category: Data synopsis: Association lists (list-like collections of tuples) description: An association list conceptually signifies a mapping, but is represented as a list (of key-value pairs). - . + This package defines an association list as a constraint synonym for a list-like collection of tuples, using the @ListLike@ type class from the @ListLike@ package. - . + > type AssocList l a b = ListLike l (a, b) homepage: https://github.com/typeclasses/assoc-list @@ -19,29 +21,36 @@ author: Chris Martin maintainer: Chris Martin, Julie Moronuki -copyright: 2018 Typeclass Consulting, LLC +copyright: 2018-2021 Mission Valley Software LLC license: MIT license-file: license.txt build-type: Simple -cabal-version: >= 1.10 extra-source-files: README.md + changelog.md source-repository head type: git location: https://github.com/typeclasses/assoc-list -library +common base default-language: Haskell2010 - hs-source-dirs: src - build-depends: - base >=4.7 && <5 - , contravariant - , ListLike + base ^>= 4.9 + || ^>= 4.10 + || ^>= 4.11 + || ^>= 4.12 + || ^>= 4.13 + || ^>= 4.14 + || ^>= 4.15 + , contravariant ^>= 1.5 + , ListLike ^>= 4.6 || ^>= 4.7 +library + import: base + hs-source-dirs: src exposed-modules: Data.AssocList.ListLike.Comparison , Data.AssocList.ListLike.Concept @@ -50,27 +59,13 @@ , Data.AssocList.ListLike.Ord , Data.AssocList.ListLike.Predicate -test-suite doctest - default-language: Haskell2010 - hs-source-dirs: test - type: exitcode-stdio-1.0 - main-is: doctest.hs - ghc-options: -threaded -rtsopts -with-rtsopts=-N - - build-depends: - base >=4.7 && <5 - , doctest - test-suite hedgehog - default-language: Haskell2010 + import: base hs-source-dirs: test type: exitcode-stdio-1.0 - main-is: hedgehog.hs + main-is: test-with-hedgehog.hs ghc-options: -threaded -rtsopts -with-rtsopts=-N build-depends: assoc-listlike - , base >=4.7 && <5 - , contravariant - , doctest - , hedgehog + , hedgehog ^>= 1.0 diff --git a/changelog.md b/changelog.md new file mode 100644 --- /dev/null +++ b/changelog.md @@ -0,0 +1,16 @@ +# Changelog + +## v1.0.0.0 + +Initial version + +## v1.0.0.1 - August 9, 2021 + +Rename the hedgehog test executable to support +case-insensitive file systems + +Remove the doctest test suite + +Tighten previously-vague dependency version bounds + +Cabal-version raised to 3.0 diff --git a/license.txt b/license.txt --- a/license.txt +++ b/license.txt @@ -1,4 +1,4 @@ -Copyright 2018 Typeclass Consulting, LLC +Copyright 2018-2021 Mission Valley Software LLC Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: diff --git a/test/doctest.hs b/test/doctest.hs deleted file mode 100644 --- a/test/doctest.hs +++ /dev/null @@ -1,12 +0,0 @@ -import Test.DocTest - -main :: IO () -main = - doctest - [ "-isrc" - , "src/Data/AssocList/ListLike/Comparison.hs" - , "src/Data/AssocList/ListLike/Eq.hs" - , "src/Data/AssocList/ListLike/Equivalence.hs" - , "src/Data/AssocList/ListLike/Ord.hs" - , "src/Data/AssocList/ListLike/Predicate.hs" - ] diff --git a/test/hedgehog.hs b/test/hedgehog.hs deleted file mode 100644 --- a/test/hedgehog.hs +++ /dev/null @@ -1,556 +0,0 @@ -{-# LANGUAGE TemplateHaskell #-} - -import Data.AssocList.ListLike.Concept -import qualified Data.AssocList.ListLike.Comparison -import qualified Data.AssocList.ListLike.Eq -import qualified Data.AssocList.ListLike.Equivalence -import qualified Data.AssocList.ListLike.Ord -import qualified Data.AssocList.ListLike.Predicate - --- base -import GHC.Stack (HasCallStack) -import Control.Exception (try, Exception) -import Control.Monad (unless) -import Control.Monad.IO.Class (MonadIO (liftIO)) -import Data.Foldable (for_) -import qualified System.Exit as Exit -import qualified System.IO as IO - --- contravariant -import qualified Data.Functor.Contravariant -import Data.Functor.Contravariant - (Comparison (..), Equivalence (..), Predicate (..)) - --- hedgehog -import Hedgehog (Property, forAll, property, - withTests, (===), MonadTest) -import qualified Hedgehog -import qualified Hedgehog.Gen as Gen - -main :: IO () -main = do - for_ [IO.stdout, IO.stderr] $ \h -> do - IO.hSetEncoding h IO.utf8 - IO.hSetBuffering h IO.LineBuffering - success <- Hedgehog.checkParallel $$(Hedgehog.discover) - unless success Exit.exitFailure - -throws - :: ( MonadIO m, MonadTest m - , Eq a, Show a - , Eq e, Exception e - , HasCallStack - ) => a -> e -> m () -throws a e = - do - result <- liftIO (try (return $! a)) - result === Left e - -a, b, c, d, e, f :: Char -a = 'a'; b = 'b'; c = 'c'; d = 'd'; e = 'e'; f = 'f' - - --------------------------------------------------------------------------------- --- Data.AssocList.ListLike.Comparison --------------------------------------------------------------------------------- - -prop_list_comparison_sortKeys :: Property -prop_list_comparison_sortKeys = withTests 1 $ property $ do - - let - sortKeys = Data.AssocList.ListLike.Comparison.sortKeys - def = Data.Functor.Contravariant.defaultComparison - - sortKeys def [(2, b), (3, c), (2, a), (7, d), (2, e), (1, f)] - === [(1, f), (2, b), (2, a), (2, e), (3, c), (7, d)] - - --------------------------------------------------------------------------------- --- Data.AssocList.ListLike.Eq --------------------------------------------------------------------------------- - -prop_list_eq_bang :: Property -prop_list_eq_bang = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - (!) = (Data.AssocList.ListLike.Eq.!) - - l ! 1 === a - l ! 2 === b - l ! 3 === c - throws (l ! 4) MissingAssocListKey - -prop_list_eq_bang_maybe :: Property -prop_list_eq_bang_maybe = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - (!?) = (Data.AssocList.ListLike.Eq.!?) - - l !? 1 === Just a - l !? 2 === Just b - l !? 3 === Just c - l !? 4 === Nothing - -prop_list_eq_lookupFirst :: Property -prop_list_eq_lookupFirst = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - lookupFirst = Data.AssocList.ListLike.Eq.lookupFirst - - lookupFirst 1 l === Just a - lookupFirst 2 l === Just b - lookupFirst 3 l === Just c - lookupFirst 4 l === Nothing - -prop_list_eq_lookupAll :: Property -prop_list_eq_lookupAll = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - lookupAll = Data.AssocList.ListLike.Eq.lookupAll - - lookupAll 1 l === [a] - lookupAll 2 l === [b, d] - lookupAll 3 l === [c] - lookupAll 4 l === [] - -prop_list_eq_removeFirst :: Property -prop_list_eq_removeFirst = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - removeFirst = Data.AssocList.ListLike.Eq.removeFirst - - removeFirst 1 l === [(2, b), (2, d), (3, c)] - removeFirst 2 l === [(1, a), (2, d), (3, c)] - removeFirst 3 l === [(1, a), (2, b), (2, d)] - removeFirst 4 l === [(1, a), (2, b), (2, d), (3, c)] - -prop_list_eq_removeAll :: Property -prop_list_eq_removeAll = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - removeAll = Data.AssocList.ListLike.Eq.removeAll - - removeAll 1 l === [(2, b), (2, d), (3, c)] - removeAll 2 l === [(1, a), (3, c)] - removeAll 3 l === [(1, a), (2, b), (2, d)] - removeAll 4 l === [(1, a), (2, b), (2, d), (3, c)] - -prop_list_eq_partition :: Property -prop_list_eq_partition = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - partition = Data.AssocList.ListLike.Eq.partition - (*) = (,) - - partition 1 l === [a] * [(2, b), (2, d), (3, c)] - partition 2 l === [b, d] * [(1, a), (3, c)] - partition 3 l === [c] * [(1, a), (2, b), (2, d)] - partition 4 l === [] * [(1, a), (2, b), (2, d), (3, c)] - -prop_list_eq_break :: Property -prop_list_eq_break = withTests 1 $ property $ do - - let - l = [(1, a), (4, b), (3, c), (4, d)] - break = Data.AssocList.ListLike.Eq.break - (*) = (,) - - break 1 l === [] * [(1, a), (4, b), (3, c), (4, d)] - break 2 l === [ (1, a), (4, b), (3, c), (4, d)] * [] - break 3 l === [ (1, a), (4, b)] * [(3, c), (4, d)] - break 4 l === [ (1, a)] * [(4, b), (3, c), (4, d)] - -prop_list_eq_breakPartition :: Property -prop_list_eq_breakPartition = withTests 1 $ property $ do - - let - l = [(1, a), (4, b), (3, c), (4, d)] - breakPartition = Data.AssocList.ListLike.Eq.breakPartition - - breakPartition 1 l === ([], [a], [(4, b), (3, c), (4, d)]) - breakPartition 2 l === (l, [], []) - breakPartition 3 l === ([(1, a), (4, b)], [c], [(4, d)]) - breakPartition 4 l === ([(1, a)], [b, d], [(3, c)]) - -prop_list_eq_mapFirst :: Property -prop_list_eq_mapFirst = withTests 1 $ property $ do - - let - l = [(a, 1), (b, 4), (c, 2), (b, 6)] - mapFirst = Data.AssocList.ListLike.Eq.mapFirst - - mapFirst a negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] - mapFirst b negate l === [(a, 1), (b, -4), (c, 2), (b, 6)] - mapFirst c negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] - mapFirst d negate l === [(a, 1), (b, 4), (c, 2), (b, 6)] - -prop_list_eq_mapAll :: Property -prop_list_eq_mapAll = withTests 1 $ property $ do - - let - l = [(a, 1), (b, 4), (c, 2), (b, 6)] - mapAll = Data.AssocList.ListLike.Eq.mapAll - - mapAll a negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] - mapAll b negate l === [(a, 1), (b, -4), (c, 2), (b, -6)] - mapAll c negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] - mapAll d negate l === [(a, 1), (b, 4), (c, 2), (b, 6)] - -prop_list_eq_alterFirst :: Property -prop_list_eq_alterFirst = withTests 1 $ property $ do - - let - l = [(a, 1), (b, 4), (c, 2), (b, 6)] - alterFirst = Data.AssocList.ListLike.Eq.alterFirst - - alterFirst a (fmap negate) l === [(a, -1), (b, 4), (c, 2), (b, 6)] - alterFirst b (fmap negate) l === [(a, 1), (b, -4), (c, 2), (b, 6)] - alterFirst c (fmap negate) l === [(a, 1), (b, 4), (c, -2), (b, 6)] - alterFirst d (fmap negate) l === [(a, 1), (b, 4), (c, 2), (b, 6)] - - alterFirst a (const Nothing) l === [ (b, 4), (c, 2), (b, 6)] - alterFirst b (const Nothing) l === [(a, 1), (c, 2), (b, 6)] - alterFirst c (const Nothing) l === [(a, 1), (b, 4), (b, 6)] - alterFirst d (const Nothing) l === [(a, 1), (b, 4), (c, 2), (b, 6)] - - alterFirst a (const (Just 0)) l === [(a, 0), (b, 4), (c, 2), (b, 6)] - alterFirst b (const (Just 0)) l === [(a, 1), (b, 0), (c, 2), (b, 6)] - alterFirst c (const (Just 0)) l === [(a, 1), (b, 4), (c, 0), (b, 6)] - alterFirst d (const (Just 0)) l === [(a, 1), (b, 4), (c, 2), (b, 6), (d, 0)] - -prop_list_eq_alterAll :: Property -prop_list_eq_alterAll = withTests 1 $ property $ do - - let - l = [(a, 1), (b, 4), (c, 2), (b, 6)] - alterAll = Data.AssocList.ListLike.Eq.alterAll - - alterAll a (fmap negate) l === [(a, -1), (b, 4), (c, 2), (b, 6)] - alterAll b (fmap negate) l === [(a, 1), (b, -4), (b, -6), (c, 2)] - alterAll c (fmap negate) l === [(a, 1), (b, 4), (c, -2), (b, 6)] - alterAll d (fmap negate) l === [(a, 1), (b, 4), (c, 2), (b, 6)] - - alterAll a (const []) l === [ (b, 4), (c, 2), (b, 6)] - alterAll b (const []) l === [(a, 1), (c, 2) ] - alterAll c (const []) l === [(a, 1), (b, 4), (b, 6)] - alterAll d (const []) l === [(a, 1), (b, 4), (c, 2), (b, 6)] - - alterAll a (const [8,9]) l === [(a, 8), (a, 9), (b, 4), (c, 2), (b, 6)] - alterAll b (const [8,9]) l === [(a, 1), (b, 8), (b, 9), (c, 2)] - alterAll c (const [8,9]) l === [(a, 1), (b, 4), (c, 8), (c, 9), (b, 6)] - alterAll d (const [8,9]) l === [(a, 1), (b, 4), (c, 2), (b, 6), (d, 8), (d, 9)] - - --------------------------------------------------------------------------------- --- Data.AssocList.ListLike.Equivalence --------------------------------------------------------------------------------- - -prop_list_equivalence_lookupFirst :: Property -prop_list_equivalence_lookupFirst = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - lookupFirst = Data.AssocList.ListLike.Equivalence.lookupFirst - def = Data.Functor.Contravariant.defaultEquivalence - - lookupFirst def 1 l === Just a - lookupFirst def 2 l === Just b - lookupFirst def 3 l === Just c - lookupFirst def 4 l === Nothing - -prop_list_equivalence_lookupAll :: Property -prop_list_equivalence_lookupAll = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - lookupAll = Data.AssocList.ListLike.Equivalence.lookupAll - def = Data.Functor.Contravariant.defaultEquivalence - - lookupAll def 1 l === [a] - lookupAll def 2 l === [b, d] - lookupAll def 3 l === [c] - lookupAll def 4 l === [] - -prop_list_equivalence_removeFirst :: Property -prop_list_equivalence_removeFirst = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - removeFirst = Data.AssocList.ListLike.Equivalence.removeFirst - def = Data.Functor.Contravariant.defaultEquivalence - - removeFirst def 1 l === [(2, b), (2, d), (3, c)] - removeFirst def 2 l === [(1, a), (2, d), (3, c)] - removeFirst def 3 l === [(1, a), (2, b), (2, d)] - removeFirst def 4 l === [(1, a), (2, b), (2, d), (3, c)] - -prop_list_equivalence_removeAll :: Property -prop_list_equivalence_removeAll = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - removeAll = Data.AssocList.ListLike.Equivalence.removeAll - def = Data.Functor.Contravariant.defaultEquivalence - - removeAll def 1 l === [(2, b), (2, d), (3, c)] - removeAll def 2 l === [(1, a), (3, c)] - removeAll def 3 l === [(1, a), (2, b), (2, d)] - removeAll def 4 l === [(1, a), (2, b), (2, d), (3, c)] - -prop_list_equivalence_partition :: Property -prop_list_equivalence_partition = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - partition = Data.AssocList.ListLike.Equivalence.partition - def = Data.Functor.Contravariant.defaultEquivalence - (*) = (,) - - partition def 1 l === [a] * [(2, b), (2, d), (3, c)] - partition def 2 l === [b, d] * [(1, a), (3, c)] - partition def 3 l === [c] * [(1, a), (2, b), (2, d)] - partition def 4 l === [] * [(1, a), (2, b), (2, d), (3, c)] - -prop_list_equivalence_break :: Property -prop_list_equivalence_break = withTests 1 $ property $ do - - let - l = [(1, a), (4, b), (3, c), (4, d)] - break = Data.AssocList.ListLike.Equivalence.break - def = Data.Functor.Contravariant.defaultEquivalence - (*) = (,) - - break def 1 l === [] * [(1, a), (4, b), (3, c), (4, d)] - break def 2 l === [ (1, a), (4, b), (3, c), (4, d)] * [] - break def 3 l === [ (1, a), (4, b)] * [(3, c), (4, d)] - break def 4 l === [ (1, a)] * [(4, b), (3, c), (4, d)] - -prop_list_equivalence_breakPartition :: Property -prop_list_equivalence_breakPartition = withTests 1 $ property $ do - - let - l = [(1, a), (4, b), (3, c), (4, d)] - breakPartition = Data.AssocList.ListLike.Equivalence.breakPartition - def = Data.Functor.Contravariant.defaultEquivalence - - breakPartition def 1 l === ([], [a], [(4, b), (3, c), (4, d)]) - breakPartition def 2 l === (l, [], []) - breakPartition def 3 l === ([(1, a), (4, b)], [c], [(4, d)]) - breakPartition def 4 l === ([(1, a)], [b, d], [(3, c)]) - -prop_list_equivalence_mapFirst :: Property -prop_list_equivalence_mapFirst = withTests 1 $ property $ do - - let - l = [(a, 1), (b, 4), (c, 2), (b, 6)] - mapFirst = Data.AssocList.ListLike.Equivalence.mapFirst - def = Data.Functor.Contravariant.defaultEquivalence - - mapFirst def a negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] - mapFirst def b negate l === [(a, 1), (b, -4), (c, 2), (b, 6)] - mapFirst def c negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] - mapFirst def d negate l === [(a, 1), (b, 4), (c, 2), (b, 6)] - -prop_list_equivalence_mapAll :: Property -prop_list_equivalence_mapAll = withTests 1 $ property $ do - - let - l = [(a, 1), (b, 4), (c, 2), (b, 6)] - mapAll = Data.AssocList.ListLike.Equivalence.mapAll - def = Data.Functor.Contravariant.defaultEquivalence - - mapAll def a negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] - mapAll def b negate l === [(a, 1), (b, -4), (c, 2), (b, -6)] - mapAll def c negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] - mapAll def d negate l === [(a, 1), (b, 4), (c, 2), (b, 6)] - -prop_list_equivalence_alterFirst :: Property -prop_list_equivalence_alterFirst = withTests 1 $ property $ do - - let - l = [(a, 1), (b, 4), (c, 2), (b, 6)] - alterFirst = Data.AssocList.ListLike.Equivalence.alterFirst - def = Data.Functor.Contravariant.defaultEquivalence - - alterFirst def a (fmap negate) l === [(a, -1), (b, 4), (c, 2), (b, 6)] - alterFirst def b (fmap negate) l === [(a, 1), (b, -4), (c, 2), (b, 6)] - alterFirst def c (fmap negate) l === [(a, 1), (b, 4), (c, -2), (b, 6)] - alterFirst def d (fmap negate) l === [(a, 1), (b, 4), (c, 2), (b, 6)] - - alterFirst def a (const Nothing) l === [ (b, 4), (c, 2), (b, 6)] - alterFirst def b (const Nothing) l === [(a, 1), (c, 2), (b, 6)] - alterFirst def c (const Nothing) l === [(a, 1), (b, 4), (b, 6)] - alterFirst def d (const Nothing) l === [(a, 1), (b, 4), (c, 2), (b, 6)] - - alterFirst def a (const (Just 0)) l === [(a, 0), (b, 4), (c, 2), (b, 6)] - alterFirst def b (const (Just 0)) l === [(a, 1), (b, 0), (c, 2), (b, 6)] - alterFirst def c (const (Just 0)) l === [(a, 1), (b, 4), (c, 0), (b, 6)] - alterFirst def d (const (Just 0)) l === [(a, 1), (b, 4), (c, 2), (b, 6), (d, 0)] - -prop_list_equivalence_alterAll :: Property -prop_list_equivalence_alterAll = withTests 1 $ property $ do - - let - l = [(a, 1), (b, 4), (c, 2), (b, 6)] - alterAll = Data.AssocList.ListLike.Equivalence.alterAll - def = Data.Functor.Contravariant.defaultEquivalence - - alterAll def a (fmap negate) l === [(a, -1), (b, 4), (c, 2), (b, 6)] - alterAll def b (fmap negate) l === [(a, 1), (b, -4), (b, -6), (c, 2)] - alterAll def c (fmap negate) l === [(a, 1), (b, 4), (c, -2), (b, 6)] - alterAll def d (fmap negate) l === [(a, 1), (b, 4), (c, 2), (b, 6)] - - alterAll def a (const []) l === [ (b, 4), (c, 2), (b, 6)] - alterAll def b (const []) l === [(a, 1), (c, 2) ] - alterAll def c (const []) l === [(a, 1), (b, 4), (b, 6)] - alterAll def d (const []) l === [(a, 1), (b, 4), (c, 2), (b, 6)] - - alterAll def a (const [8,9]) l === [(a, 8), (a, 9), (b, 4), (c, 2), (b, 6)] - alterAll def b (const [8,9]) l === [(a, 1), (b, 8), (b, 9), (c, 2)] - alterAll def c (const [8,9]) l === [(a, 1), (b, 4), (c, 8), (c, 9), (b, 6)] - alterAll def d (const [8,9]) l === [(a, 1), (b, 4), (c, 2), (b, 6), (d, 8), (d, 9)] - - --------------------------------------------------------------------------------- --- Data.AssocList.ListLike.Ord --------------------------------------------------------------------------------- - -prop_list_ord_sortKeys :: Property -prop_list_ord_sortKeys = withTests 1 $ property $ do - - let - sortKeys = Data.AssocList.ListLike.Ord.sortKeys - - sortKeys [(2, b), (3, c), (2, a), (7, d), (2, e), (1, f)] - === [(1, f), (2, b), (2, a), (2, e), (3, c), (7, d)] - - --------------------------------------------------------------------------------- --- Data.AssocList.ListLike.Predicate --------------------------------------------------------------------------------- - -prop_list_predicate_lookupFirst :: Property -prop_list_predicate_lookupFirst = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - lookupFirst = Data.AssocList.ListLike.Predicate.lookupFirst - eq x = Predicate (== x) - - lookupFirst (eq 1) l === Just a - lookupFirst (eq 2) l === Just b - lookupFirst (eq 3) l === Just c - lookupFirst (eq 4) l === Nothing - -prop_list_predicate_lookupAll :: Property -prop_list_predicate_lookupAll = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - lookupAll = Data.AssocList.ListLike.Predicate.lookupAll - eq x = Predicate (== x) - - lookupAll (eq 1) l === [a] - lookupAll (eq 2) l === [b, d] - lookupAll (eq 3) l === [c] - lookupAll (eq 4) l === [] - -prop_list_predicate_removeFirst :: Property -prop_list_predicate_removeFirst = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - removeFirst = Data.AssocList.ListLike.Predicate.removeFirst - eq x = Predicate (== x) - - removeFirst (eq 1) l === [(2, b), (2, d), (3, c)] - removeFirst (eq 2) l === [(1, a), (2, d), (3, c)] - removeFirst (eq 3) l === [(1, a), (2, b), (2, d)] - removeFirst (eq 4) l === [(1, a), (2, b), (2, d), (3, c)] - -prop_list_predicate_removeAll :: Property -prop_list_predicate_removeAll = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - removeAll = Data.AssocList.ListLike.Predicate.removeAll - eq x = Predicate (== x) - - removeAll (eq 1) l === [(2, b), (2, d), (3, c)] - removeAll (eq 2) l === [(1, a), (3, c)] - removeAll (eq 3) l === [(1, a), (2, b), (2, d)] - removeAll (eq 4) l === [(1, a), (2, b), (2, d), (3, c)] - -prop_list_predicate_partition :: Property -prop_list_predicate_partition = withTests 1 $ property $ do - - let - l = [(1, a), (2, b), (2, d), (3, c)] - partition = Data.AssocList.ListLike.Predicate.partition - eq x = Predicate (== x) - (*) = (,) - - partition (eq 1) l === [a] * [(2, b), (2, d), (3, c)] - partition (eq 2) l === [b, d] * [(1, a), (3, c)] - partition (eq 3) l === [c] * [(1, a), (2, b), (2, d)] - partition (eq 4) l === [] * [(1, a), (2, b), (2, d), (3, c)] - -prop_list_predicate_break :: Property -prop_list_predicate_break = withTests 1 $ property $ do - - let - l = [(1, a), (4, b), (3, c), (4, d)] - break = Data.AssocList.ListLike.Predicate.break - eq x = Predicate (== x) - (*) = (,) - - break (eq 1) l === [] * [(1, a), (4, b), (3, c), (4, d)] - break (eq 2) l === [ (1, a), (4, b), (3, c), (4, d)] * [] - break (eq 3) l === [ (1, a), (4, b)] * [(3, c), (4, d)] - break (eq 4) l === [ (1, a)] * [(4, b), (3, c), (4, d)] - -prop_list_predicate_breakPartition :: Property -prop_list_predicate_breakPartition = withTests 1 $ property $ do - - let - l = [(1, a), (4, b), (3, c), (4, d)] - breakPartition = Data.AssocList.ListLike.Predicate.breakPartition - eq x = Predicate (== x) - - breakPartition (eq 1) l === ([], [a], [(4, b), (3, c), (4, d)]) - breakPartition (eq 2) l === (l, [], []) - breakPartition (eq 3) l === ([(1, a), (4, b)], [c], [(4, d)]) - breakPartition (eq 4) l === ([(1, a)], [b, d], [(3, c)]) - -prop_list_predicate_mapFirst :: Property -prop_list_predicate_mapFirst = withTests 1 $ property $ do - - let - l = [(a, 1), (b, 4), (c, 2), (b, 6)] - mapFirst = Data.AssocList.ListLike.Predicate.mapFirst - eq x = Predicate (== x) - - mapFirst (eq a) negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] - mapFirst (eq b) negate l === [(a, 1), (b, -4), (c, 2), (b, 6)] - mapFirst (eq c) negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] - mapFirst (eq d) negate l === [(a, 1), (b, 4), (c, 2), (b, 6)] - -prop_list_predicate_mapAll :: Property -prop_list_predicate_mapAll = withTests 1 $ property $ do - - let - l = [(a, 1), (b, 4), (c, 2), (b, 6)] - mapAll = Data.AssocList.ListLike.Predicate.mapAll - eq x = Predicate (== x) - - mapAll (eq a) negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] - mapAll (eq b) negate l === [(a, 1), (b, -4), (c, 2), (b, -6)] - mapAll (eq c) negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] - mapAll (eq d) negate l === [(a, 1), (b, 4), (c, 2), (b, 6)] diff --git a/test/test-with-hedgehog.hs b/test/test-with-hedgehog.hs new file mode 100644 --- /dev/null +++ b/test/test-with-hedgehog.hs @@ -0,0 +1,556 @@ +{-# LANGUAGE TemplateHaskell #-} + +import Data.AssocList.ListLike.Concept +import qualified Data.AssocList.ListLike.Comparison +import qualified Data.AssocList.ListLike.Eq +import qualified Data.AssocList.ListLike.Equivalence +import qualified Data.AssocList.ListLike.Ord +import qualified Data.AssocList.ListLike.Predicate + +-- base +import GHC.Stack (HasCallStack) +import Control.Exception (try, Exception) +import Control.Monad (unless) +import Control.Monad.IO.Class (MonadIO (liftIO)) +import Data.Foldable (for_) +import qualified System.Exit as Exit +import qualified System.IO as IO + +-- contravariant +import qualified Data.Functor.Contravariant +import Data.Functor.Contravariant + (Comparison (..), Equivalence (..), Predicate (..)) + +-- hedgehog +import Hedgehog (Property, forAll, property, + withTests, (===), MonadTest) +import qualified Hedgehog +import qualified Hedgehog.Gen as Gen + +main :: IO () +main = do + for_ [IO.stdout, IO.stderr] $ \h -> do + IO.hSetEncoding h IO.utf8 + IO.hSetBuffering h IO.LineBuffering + success <- Hedgehog.checkParallel $$(Hedgehog.discover) + unless success Exit.exitFailure + +throws + :: ( MonadIO m, MonadTest m + , Eq a, Show a + , Eq e, Exception e + , HasCallStack + ) => a -> e -> m () +throws a e = + do + result <- liftIO (try (return $! a)) + result === Left e + +a, b, c, d, e, f :: Char +a = 'a'; b = 'b'; c = 'c'; d = 'd'; e = 'e'; f = 'f' + + +-------------------------------------------------------------------------------- +-- Data.AssocList.ListLike.Comparison +-------------------------------------------------------------------------------- + +prop_list_comparison_sortKeys :: Property +prop_list_comparison_sortKeys = withTests 1 $ property $ do + + let + sortKeys = Data.AssocList.ListLike.Comparison.sortKeys + def = Data.Functor.Contravariant.defaultComparison + + sortKeys def [(2, b), (3, c), (2, a), (7, d), (2, e), (1, f)] + === [(1, f), (2, b), (2, a), (2, e), (3, c), (7, d)] + + +-------------------------------------------------------------------------------- +-- Data.AssocList.ListLike.Eq +-------------------------------------------------------------------------------- + +prop_list_eq_bang :: Property +prop_list_eq_bang = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + (!) = (Data.AssocList.ListLike.Eq.!) + + l ! 1 === a + l ! 2 === b + l ! 3 === c + throws (l ! 4) MissingAssocListKey + +prop_list_eq_bang_maybe :: Property +prop_list_eq_bang_maybe = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + (!?) = (Data.AssocList.ListLike.Eq.!?) + + l !? 1 === Just a + l !? 2 === Just b + l !? 3 === Just c + l !? 4 === Nothing + +prop_list_eq_lookupFirst :: Property +prop_list_eq_lookupFirst = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + lookupFirst = Data.AssocList.ListLike.Eq.lookupFirst + + lookupFirst 1 l === Just a + lookupFirst 2 l === Just b + lookupFirst 3 l === Just c + lookupFirst 4 l === Nothing + +prop_list_eq_lookupAll :: Property +prop_list_eq_lookupAll = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + lookupAll = Data.AssocList.ListLike.Eq.lookupAll + + lookupAll 1 l === [a] + lookupAll 2 l === [b, d] + lookupAll 3 l === [c] + lookupAll 4 l === [] + +prop_list_eq_removeFirst :: Property +prop_list_eq_removeFirst = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + removeFirst = Data.AssocList.ListLike.Eq.removeFirst + + removeFirst 1 l === [(2, b), (2, d), (3, c)] + removeFirst 2 l === [(1, a), (2, d), (3, c)] + removeFirst 3 l === [(1, a), (2, b), (2, d)] + removeFirst 4 l === [(1, a), (2, b), (2, d), (3, c)] + +prop_list_eq_removeAll :: Property +prop_list_eq_removeAll = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + removeAll = Data.AssocList.ListLike.Eq.removeAll + + removeAll 1 l === [(2, b), (2, d), (3, c)] + removeAll 2 l === [(1, a), (3, c)] + removeAll 3 l === [(1, a), (2, b), (2, d)] + removeAll 4 l === [(1, a), (2, b), (2, d), (3, c)] + +prop_list_eq_partition :: Property +prop_list_eq_partition = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + partition = Data.AssocList.ListLike.Eq.partition + (*) = (,) + + partition 1 l === [a] * [(2, b), (2, d), (3, c)] + partition 2 l === [b, d] * [(1, a), (3, c)] + partition 3 l === [c] * [(1, a), (2, b), (2, d)] + partition 4 l === [] * [(1, a), (2, b), (2, d), (3, c)] + +prop_list_eq_break :: Property +prop_list_eq_break = withTests 1 $ property $ do + + let + l = [(1, a), (4, b), (3, c), (4, d)] + break = Data.AssocList.ListLike.Eq.break + (*) = (,) + + break 1 l === [] * [(1, a), (4, b), (3, c), (4, d)] + break 2 l === [ (1, a), (4, b), (3, c), (4, d)] * [] + break 3 l === [ (1, a), (4, b)] * [(3, c), (4, d)] + break 4 l === [ (1, a)] * [(4, b), (3, c), (4, d)] + +prop_list_eq_breakPartition :: Property +prop_list_eq_breakPartition = withTests 1 $ property $ do + + let + l = [(1, a), (4, b), (3, c), (4, d)] + breakPartition = Data.AssocList.ListLike.Eq.breakPartition + + breakPartition 1 l === ([], [a], [(4, b), (3, c), (4, d)]) + breakPartition 2 l === (l, [], []) + breakPartition 3 l === ([(1, a), (4, b)], [c], [(4, d)]) + breakPartition 4 l === ([(1, a)], [b, d], [(3, c)]) + +prop_list_eq_mapFirst :: Property +prop_list_eq_mapFirst = withTests 1 $ property $ do + + let + l = [(a, 1), (b, 4), (c, 2), (b, 6)] + mapFirst = Data.AssocList.ListLike.Eq.mapFirst + + mapFirst a negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] + mapFirst b negate l === [(a, 1), (b, -4), (c, 2), (b, 6)] + mapFirst c negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] + mapFirst d negate l === [(a, 1), (b, 4), (c, 2), (b, 6)] + +prop_list_eq_mapAll :: Property +prop_list_eq_mapAll = withTests 1 $ property $ do + + let + l = [(a, 1), (b, 4), (c, 2), (b, 6)] + mapAll = Data.AssocList.ListLike.Eq.mapAll + + mapAll a negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] + mapAll b negate l === [(a, 1), (b, -4), (c, 2), (b, -6)] + mapAll c negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] + mapAll d negate l === [(a, 1), (b, 4), (c, 2), (b, 6)] + +prop_list_eq_alterFirst :: Property +prop_list_eq_alterFirst = withTests 1 $ property $ do + + let + l = [(a, 1), (b, 4), (c, 2), (b, 6)] + alterFirst = Data.AssocList.ListLike.Eq.alterFirst + + alterFirst a (fmap negate) l === [(a, -1), (b, 4), (c, 2), (b, 6)] + alterFirst b (fmap negate) l === [(a, 1), (b, -4), (c, 2), (b, 6)] + alterFirst c (fmap negate) l === [(a, 1), (b, 4), (c, -2), (b, 6)] + alterFirst d (fmap negate) l === [(a, 1), (b, 4), (c, 2), (b, 6)] + + alterFirst a (const Nothing) l === [ (b, 4), (c, 2), (b, 6)] + alterFirst b (const Nothing) l === [(a, 1), (c, 2), (b, 6)] + alterFirst c (const Nothing) l === [(a, 1), (b, 4), (b, 6)] + alterFirst d (const Nothing) l === [(a, 1), (b, 4), (c, 2), (b, 6)] + + alterFirst a (const (Just 0)) l === [(a, 0), (b, 4), (c, 2), (b, 6)] + alterFirst b (const (Just 0)) l === [(a, 1), (b, 0), (c, 2), (b, 6)] + alterFirst c (const (Just 0)) l === [(a, 1), (b, 4), (c, 0), (b, 6)] + alterFirst d (const (Just 0)) l === [(a, 1), (b, 4), (c, 2), (b, 6), (d, 0)] + +prop_list_eq_alterAll :: Property +prop_list_eq_alterAll = withTests 1 $ property $ do + + let + l = [(a, 1), (b, 4), (c, 2), (b, 6)] + alterAll = Data.AssocList.ListLike.Eq.alterAll + + alterAll a (fmap negate) l === [(a, -1), (b, 4), (c, 2), (b, 6)] + alterAll b (fmap negate) l === [(a, 1), (b, -4), (b, -6), (c, 2)] + alterAll c (fmap negate) l === [(a, 1), (b, 4), (c, -2), (b, 6)] + alterAll d (fmap negate) l === [(a, 1), (b, 4), (c, 2), (b, 6)] + + alterAll a (const []) l === [ (b, 4), (c, 2), (b, 6)] + alterAll b (const []) l === [(a, 1), (c, 2) ] + alterAll c (const []) l === [(a, 1), (b, 4), (b, 6)] + alterAll d (const []) l === [(a, 1), (b, 4), (c, 2), (b, 6)] + + alterAll a (const [8,9]) l === [(a, 8), (a, 9), (b, 4), (c, 2), (b, 6)] + alterAll b (const [8,9]) l === [(a, 1), (b, 8), (b, 9), (c, 2)] + alterAll c (const [8,9]) l === [(a, 1), (b, 4), (c, 8), (c, 9), (b, 6)] + alterAll d (const [8,9]) l === [(a, 1), (b, 4), (c, 2), (b, 6), (d, 8), (d, 9)] + + +-------------------------------------------------------------------------------- +-- Data.AssocList.ListLike.Equivalence +-------------------------------------------------------------------------------- + +prop_list_equivalence_lookupFirst :: Property +prop_list_equivalence_lookupFirst = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + lookupFirst = Data.AssocList.ListLike.Equivalence.lookupFirst + def = Data.Functor.Contravariant.defaultEquivalence + + lookupFirst def 1 l === Just a + lookupFirst def 2 l === Just b + lookupFirst def 3 l === Just c + lookupFirst def 4 l === Nothing + +prop_list_equivalence_lookupAll :: Property +prop_list_equivalence_lookupAll = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + lookupAll = Data.AssocList.ListLike.Equivalence.lookupAll + def = Data.Functor.Contravariant.defaultEquivalence + + lookupAll def 1 l === [a] + lookupAll def 2 l === [b, d] + lookupAll def 3 l === [c] + lookupAll def 4 l === [] + +prop_list_equivalence_removeFirst :: Property +prop_list_equivalence_removeFirst = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + removeFirst = Data.AssocList.ListLike.Equivalence.removeFirst + def = Data.Functor.Contravariant.defaultEquivalence + + removeFirst def 1 l === [(2, b), (2, d), (3, c)] + removeFirst def 2 l === [(1, a), (2, d), (3, c)] + removeFirst def 3 l === [(1, a), (2, b), (2, d)] + removeFirst def 4 l === [(1, a), (2, b), (2, d), (3, c)] + +prop_list_equivalence_removeAll :: Property +prop_list_equivalence_removeAll = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + removeAll = Data.AssocList.ListLike.Equivalence.removeAll + def = Data.Functor.Contravariant.defaultEquivalence + + removeAll def 1 l === [(2, b), (2, d), (3, c)] + removeAll def 2 l === [(1, a), (3, c)] + removeAll def 3 l === [(1, a), (2, b), (2, d)] + removeAll def 4 l === [(1, a), (2, b), (2, d), (3, c)] + +prop_list_equivalence_partition :: Property +prop_list_equivalence_partition = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + partition = Data.AssocList.ListLike.Equivalence.partition + def = Data.Functor.Contravariant.defaultEquivalence + (*) = (,) + + partition def 1 l === [a] * [(2, b), (2, d), (3, c)] + partition def 2 l === [b, d] * [(1, a), (3, c)] + partition def 3 l === [c] * [(1, a), (2, b), (2, d)] + partition def 4 l === [] * [(1, a), (2, b), (2, d), (3, c)] + +prop_list_equivalence_break :: Property +prop_list_equivalence_break = withTests 1 $ property $ do + + let + l = [(1, a), (4, b), (3, c), (4, d)] + break = Data.AssocList.ListLike.Equivalence.break + def = Data.Functor.Contravariant.defaultEquivalence + (*) = (,) + + break def 1 l === [] * [(1, a), (4, b), (3, c), (4, d)] + break def 2 l === [ (1, a), (4, b), (3, c), (4, d)] * [] + break def 3 l === [ (1, a), (4, b)] * [(3, c), (4, d)] + break def 4 l === [ (1, a)] * [(4, b), (3, c), (4, d)] + +prop_list_equivalence_breakPartition :: Property +prop_list_equivalence_breakPartition = withTests 1 $ property $ do + + let + l = [(1, a), (4, b), (3, c), (4, d)] + breakPartition = Data.AssocList.ListLike.Equivalence.breakPartition + def = Data.Functor.Contravariant.defaultEquivalence + + breakPartition def 1 l === ([], [a], [(4, b), (3, c), (4, d)]) + breakPartition def 2 l === (l, [], []) + breakPartition def 3 l === ([(1, a), (4, b)], [c], [(4, d)]) + breakPartition def 4 l === ([(1, a)], [b, d], [(3, c)]) + +prop_list_equivalence_mapFirst :: Property +prop_list_equivalence_mapFirst = withTests 1 $ property $ do + + let + l = [(a, 1), (b, 4), (c, 2), (b, 6)] + mapFirst = Data.AssocList.ListLike.Equivalence.mapFirst + def = Data.Functor.Contravariant.defaultEquivalence + + mapFirst def a negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] + mapFirst def b negate l === [(a, 1), (b, -4), (c, 2), (b, 6)] + mapFirst def c negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] + mapFirst def d negate l === [(a, 1), (b, 4), (c, 2), (b, 6)] + +prop_list_equivalence_mapAll :: Property +prop_list_equivalence_mapAll = withTests 1 $ property $ do + + let + l = [(a, 1), (b, 4), (c, 2), (b, 6)] + mapAll = Data.AssocList.ListLike.Equivalence.mapAll + def = Data.Functor.Contravariant.defaultEquivalence + + mapAll def a negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] + mapAll def b negate l === [(a, 1), (b, -4), (c, 2), (b, -6)] + mapAll def c negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] + mapAll def d negate l === [(a, 1), (b, 4), (c, 2), (b, 6)] + +prop_list_equivalence_alterFirst :: Property +prop_list_equivalence_alterFirst = withTests 1 $ property $ do + + let + l = [(a, 1), (b, 4), (c, 2), (b, 6)] + alterFirst = Data.AssocList.ListLike.Equivalence.alterFirst + def = Data.Functor.Contravariant.defaultEquivalence + + alterFirst def a (fmap negate) l === [(a, -1), (b, 4), (c, 2), (b, 6)] + alterFirst def b (fmap negate) l === [(a, 1), (b, -4), (c, 2), (b, 6)] + alterFirst def c (fmap negate) l === [(a, 1), (b, 4), (c, -2), (b, 6)] + alterFirst def d (fmap negate) l === [(a, 1), (b, 4), (c, 2), (b, 6)] + + alterFirst def a (const Nothing) l === [ (b, 4), (c, 2), (b, 6)] + alterFirst def b (const Nothing) l === [(a, 1), (c, 2), (b, 6)] + alterFirst def c (const Nothing) l === [(a, 1), (b, 4), (b, 6)] + alterFirst def d (const Nothing) l === [(a, 1), (b, 4), (c, 2), (b, 6)] + + alterFirst def a (const (Just 0)) l === [(a, 0), (b, 4), (c, 2), (b, 6)] + alterFirst def b (const (Just 0)) l === [(a, 1), (b, 0), (c, 2), (b, 6)] + alterFirst def c (const (Just 0)) l === [(a, 1), (b, 4), (c, 0), (b, 6)] + alterFirst def d (const (Just 0)) l === [(a, 1), (b, 4), (c, 2), (b, 6), (d, 0)] + +prop_list_equivalence_alterAll :: Property +prop_list_equivalence_alterAll = withTests 1 $ property $ do + + let + l = [(a, 1), (b, 4), (c, 2), (b, 6)] + alterAll = Data.AssocList.ListLike.Equivalence.alterAll + def = Data.Functor.Contravariant.defaultEquivalence + + alterAll def a (fmap negate) l === [(a, -1), (b, 4), (c, 2), (b, 6)] + alterAll def b (fmap negate) l === [(a, 1), (b, -4), (b, -6), (c, 2)] + alterAll def c (fmap negate) l === [(a, 1), (b, 4), (c, -2), (b, 6)] + alterAll def d (fmap negate) l === [(a, 1), (b, 4), (c, 2), (b, 6)] + + alterAll def a (const []) l === [ (b, 4), (c, 2), (b, 6)] + alterAll def b (const []) l === [(a, 1), (c, 2) ] + alterAll def c (const []) l === [(a, 1), (b, 4), (b, 6)] + alterAll def d (const []) l === [(a, 1), (b, 4), (c, 2), (b, 6)] + + alterAll def a (const [8,9]) l === [(a, 8), (a, 9), (b, 4), (c, 2), (b, 6)] + alterAll def b (const [8,9]) l === [(a, 1), (b, 8), (b, 9), (c, 2)] + alterAll def c (const [8,9]) l === [(a, 1), (b, 4), (c, 8), (c, 9), (b, 6)] + alterAll def d (const [8,9]) l === [(a, 1), (b, 4), (c, 2), (b, 6), (d, 8), (d, 9)] + + +-------------------------------------------------------------------------------- +-- Data.AssocList.ListLike.Ord +-------------------------------------------------------------------------------- + +prop_list_ord_sortKeys :: Property +prop_list_ord_sortKeys = withTests 1 $ property $ do + + let + sortKeys = Data.AssocList.ListLike.Ord.sortKeys + + sortKeys [(2, b), (3, c), (2, a), (7, d), (2, e), (1, f)] + === [(1, f), (2, b), (2, a), (2, e), (3, c), (7, d)] + + +-------------------------------------------------------------------------------- +-- Data.AssocList.ListLike.Predicate +-------------------------------------------------------------------------------- + +prop_list_predicate_lookupFirst :: Property +prop_list_predicate_lookupFirst = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + lookupFirst = Data.AssocList.ListLike.Predicate.lookupFirst + eq x = Predicate (== x) + + lookupFirst (eq 1) l === Just a + lookupFirst (eq 2) l === Just b + lookupFirst (eq 3) l === Just c + lookupFirst (eq 4) l === Nothing + +prop_list_predicate_lookupAll :: Property +prop_list_predicate_lookupAll = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + lookupAll = Data.AssocList.ListLike.Predicate.lookupAll + eq x = Predicate (== x) + + lookupAll (eq 1) l === [a] + lookupAll (eq 2) l === [b, d] + lookupAll (eq 3) l === [c] + lookupAll (eq 4) l === [] + +prop_list_predicate_removeFirst :: Property +prop_list_predicate_removeFirst = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + removeFirst = Data.AssocList.ListLike.Predicate.removeFirst + eq x = Predicate (== x) + + removeFirst (eq 1) l === [(2, b), (2, d), (3, c)] + removeFirst (eq 2) l === [(1, a), (2, d), (3, c)] + removeFirst (eq 3) l === [(1, a), (2, b), (2, d)] + removeFirst (eq 4) l === [(1, a), (2, b), (2, d), (3, c)] + +prop_list_predicate_removeAll :: Property +prop_list_predicate_removeAll = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + removeAll = Data.AssocList.ListLike.Predicate.removeAll + eq x = Predicate (== x) + + removeAll (eq 1) l === [(2, b), (2, d), (3, c)] + removeAll (eq 2) l === [(1, a), (3, c)] + removeAll (eq 3) l === [(1, a), (2, b), (2, d)] + removeAll (eq 4) l === [(1, a), (2, b), (2, d), (3, c)] + +prop_list_predicate_partition :: Property +prop_list_predicate_partition = withTests 1 $ property $ do + + let + l = [(1, a), (2, b), (2, d), (3, c)] + partition = Data.AssocList.ListLike.Predicate.partition + eq x = Predicate (== x) + (*) = (,) + + partition (eq 1) l === [a] * [(2, b), (2, d), (3, c)] + partition (eq 2) l === [b, d] * [(1, a), (3, c)] + partition (eq 3) l === [c] * [(1, a), (2, b), (2, d)] + partition (eq 4) l === [] * [(1, a), (2, b), (2, d), (3, c)] + +prop_list_predicate_break :: Property +prop_list_predicate_break = withTests 1 $ property $ do + + let + l = [(1, a), (4, b), (3, c), (4, d)] + break = Data.AssocList.ListLike.Predicate.break + eq x = Predicate (== x) + (*) = (,) + + break (eq 1) l === [] * [(1, a), (4, b), (3, c), (4, d)] + break (eq 2) l === [ (1, a), (4, b), (3, c), (4, d)] * [] + break (eq 3) l === [ (1, a), (4, b)] * [(3, c), (4, d)] + break (eq 4) l === [ (1, a)] * [(4, b), (3, c), (4, d)] + +prop_list_predicate_breakPartition :: Property +prop_list_predicate_breakPartition = withTests 1 $ property $ do + + let + l = [(1, a), (4, b), (3, c), (4, d)] + breakPartition = Data.AssocList.ListLike.Predicate.breakPartition + eq x = Predicate (== x) + + breakPartition (eq 1) l === ([], [a], [(4, b), (3, c), (4, d)]) + breakPartition (eq 2) l === (l, [], []) + breakPartition (eq 3) l === ([(1, a), (4, b)], [c], [(4, d)]) + breakPartition (eq 4) l === ([(1, a)], [b, d], [(3, c)]) + +prop_list_predicate_mapFirst :: Property +prop_list_predicate_mapFirst = withTests 1 $ property $ do + + let + l = [(a, 1), (b, 4), (c, 2), (b, 6)] + mapFirst = Data.AssocList.ListLike.Predicate.mapFirst + eq x = Predicate (== x) + + mapFirst (eq a) negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] + mapFirst (eq b) negate l === [(a, 1), (b, -4), (c, 2), (b, 6)] + mapFirst (eq c) negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] + mapFirst (eq d) negate l === [(a, 1), (b, 4), (c, 2), (b, 6)] + +prop_list_predicate_mapAll :: Property +prop_list_predicate_mapAll = withTests 1 $ property $ do + + let + l = [(a, 1), (b, 4), (c, 2), (b, 6)] + mapAll = Data.AssocList.ListLike.Predicate.mapAll + eq x = Predicate (== x) + + mapAll (eq a) negate l === [(a, -1), (b, 4), (c, 2), (b, 6)] + mapAll (eq b) negate l === [(a, 1), (b, -4), (c, 2), (b, -6)] + mapAll (eq c) negate l === [(a, 1), (b, 4), (c, -2), (b, 6)] + mapAll (eq d) negate l === [(a, 1), (b, 4), (c, 2), (b, 6)]