packages feed

bitwise-enum 1.0.1.2 → 1.0.2.0

raw patch · 3 files changed

+18/−13 lines, 3 filesdep +hashabledep ~aesonPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: hashable

Dependency ranges changed: aeson

API changes (from Hackage documentation)

- Data.Enum.Set.Base: instance (GHC.Bits.FiniteBits w, GHC.Num.Num w, GHC.Enum.Enum a) => GHC.Exts.IsList (Data.Enum.Set.Base.EnumSet w a)
+ Data.Enum.Set.Base: instance (GHC.Bits.FiniteBits w, GHC.Num.Num w, GHC.Enum.Enum a) => GHC.IsList.IsList (Data.Enum.Set.Base.EnumSet w a)
+ Data.Enum.Set.Base: instance forall word k (a :: k). Data.Hashable.Class.Hashable word => Data.Hashable.Class.Hashable (Data.Enum.Set.Base.EnumSet word a)
- Data.Enum.Memo: memoize :: forall k v. (Bounded k, Enum k) => (k -> v) -> k -> v
+ Data.Enum.Memo: memoize :: (Bounded k, Enum k) => (k -> v) -> k -> v
- Data.Enum.Memo: memoize2 :: forall k1 k2 v. (Bounded k1, Enum k1, Bounded k2, Enum k2) => (k1 -> k2 -> v) -> k1 -> k2 -> v
+ Data.Enum.Memo: memoize2 :: (Bounded k1, Enum k1, Bounded k2, Enum k2) => (k1 -> k2 -> v) -> k1 -> k2 -> v
- Data.Enum.Memo: memoize3 :: forall k1 k2 k3 v. (Bounded k1, Enum k1, Bounded k2, Enum k2, Bounded k3, Enum k3) => (k1 -> k2 -> k3 -> v) -> k1 -> k2 -> k3 -> v
+ Data.Enum.Memo: memoize3 :: (Bounded k1, Enum k1, Bounded k2, Enum k2, Bounded k3, Enum k3) => (k1 -> k2 -> k3 -> v) -> k1 -> k2 -> k3 -> v
- Data.Enum.Memo: memoize4 :: forall k1 k2 k3 k4 v. (Bounded k1, Enum k1, Bounded k2, Enum k2, Bounded k3, Enum k3, Bounded k4, Enum k4) => (k1 -> k2 -> k3 -> k4 -> v) -> k1 -> k2 -> k3 -> k4 -> v
+ Data.Enum.Memo: memoize4 :: (Bounded k1, Enum k1, Bounded k2, Enum k2, Bounded k3, Enum k3, Bounded k4, Enum k4) => (k1 -> k2 -> k3 -> k4 -> v) -> k1 -> k2 -> k3 -> k4 -> v
- Data.Enum.Memo: memoize5 :: forall k1 k2 k3 k4 k5 v. (Bounded k1, Enum k1, Bounded k2, Enum k2, Bounded k3, Enum k3, Bounded k4, Enum k4, Bounded k5, Enum k5) => (k1 -> k2 -> k3 -> k4 -> k5 -> v) -> k1 -> k2 -> k3 -> k4 -> k5 -> v
+ Data.Enum.Memo: memoize5 :: (Bounded k1, Enum k1, Bounded k2, Enum k2, Bounded k3, Enum k3, Bounded k4, Enum k4, Bounded k5, Enum k5) => (k1 -> k2 -> k3 -> k4 -> k5 -> v) -> k1 -> k2 -> k3 -> k4 -> k5 -> v
- Data.Enum.Set: (\\) :: forall a. AsEnumSet a => EnumSet a -> EnumSet a -> EnumSet a
+ Data.Enum.Set: (\\) :: AsEnumSet a => EnumSet a -> EnumSet a -> EnumSet a
- Data.Enum.Set: all :: forall a. AsEnumSet a => (a -> Bool) -> EnumSet a -> Bool
+ Data.Enum.Set: all :: AsEnumSet a => (a -> Bool) -> EnumSet a -> Bool
- Data.Enum.Set: any :: forall a. AsEnumSet a => (a -> Bool) -> EnumSet a -> Bool
+ Data.Enum.Set: any :: AsEnumSet a => (a -> Bool) -> EnumSet a -> Bool
- Data.Enum.Set: class (Enum a, FiniteBits (EnumSetRep a), Num (EnumSetRep a)) => AsEnumSet a where {
+ Data.Enum.Set: class (Enum a, FiniteBits EnumSetRep a, Num EnumSetRep a) => AsEnumSet a where {
- Data.Enum.Set: delete :: forall a. AsEnumSet a => a -> EnumSet a -> EnumSet a
+ Data.Enum.Set: delete :: AsEnumSet a => a -> EnumSet a -> EnumSet a
- Data.Enum.Set: deleteMax :: forall a. AsEnumSet a => EnumSet a -> EnumSet a
+ Data.Enum.Set: deleteMax :: AsEnumSet a => EnumSet a -> EnumSet a
- Data.Enum.Set: deleteMin :: forall a. AsEnumSet a => EnumSet a -> EnumSet a
+ Data.Enum.Set: deleteMin :: AsEnumSet a => EnumSet a -> EnumSet a
- Data.Enum.Set: difference :: forall a. AsEnumSet a => EnumSet a -> EnumSet a -> EnumSet a
+ Data.Enum.Set: difference :: AsEnumSet a => EnumSet a -> EnumSet a -> EnumSet a
- Data.Enum.Set: empty :: forall a. AsEnumSet a => EnumSet a
+ Data.Enum.Set: empty :: AsEnumSet a => EnumSet a
- Data.Enum.Set: filter :: forall a. AsEnumSet a => (a -> Bool) -> EnumSet a -> EnumSet a
+ Data.Enum.Set: filter :: AsEnumSet a => (a -> Bool) -> EnumSet a -> EnumSet a
- Data.Enum.Set: foldMap :: forall m a. (Monoid m, AsEnumSet a) => (a -> m) -> EnumSet a -> m
+ Data.Enum.Set: foldMap :: (Monoid m, AsEnumSet a) => (a -> m) -> EnumSet a -> m
- Data.Enum.Set: foldl :: forall a b. AsEnumSet a => (b -> a -> b) -> b -> EnumSet a -> b
+ Data.Enum.Set: foldl :: AsEnumSet a => (b -> a -> b) -> b -> EnumSet a -> b
- Data.Enum.Set: foldl' :: forall a b. AsEnumSet a => (b -> a -> b) -> b -> EnumSet a -> b
+ Data.Enum.Set: foldl' :: AsEnumSet a => (b -> a -> b) -> b -> EnumSet a -> b
- Data.Enum.Set: foldl1 :: forall a. AsEnumSet a => (a -> a -> a) -> EnumSet a -> a
+ Data.Enum.Set: foldl1 :: AsEnumSet a => (a -> a -> a) -> EnumSet a -> a
- Data.Enum.Set: foldl1' :: forall a. AsEnumSet a => (a -> a -> a) -> EnumSet a -> a
+ Data.Enum.Set: foldl1' :: AsEnumSet a => (a -> a -> a) -> EnumSet a -> a
- Data.Enum.Set: foldr :: forall a b. AsEnumSet a => (a -> b -> b) -> b -> EnumSet a -> b
+ Data.Enum.Set: foldr :: AsEnumSet a => (a -> b -> b) -> b -> EnumSet a -> b
- Data.Enum.Set: foldr' :: forall a b. AsEnumSet a => (a -> b -> b) -> b -> EnumSet a -> b
+ Data.Enum.Set: foldr' :: AsEnumSet a => (a -> b -> b) -> b -> EnumSet a -> b
- Data.Enum.Set: foldr1 :: forall a. AsEnumSet a => (a -> a -> a) -> EnumSet a -> a
+ Data.Enum.Set: foldr1 :: AsEnumSet a => (a -> a -> a) -> EnumSet a -> a
- Data.Enum.Set: foldr1' :: forall a. AsEnumSet a => (a -> a -> a) -> EnumSet a -> a
+ Data.Enum.Set: foldr1' :: AsEnumSet a => (a -> a -> a) -> EnumSet a -> a
- Data.Enum.Set: fromFoldable :: forall f a. (Foldable f, AsEnumSet a) => f a -> EnumSet a
+ Data.Enum.Set: fromFoldable :: (Foldable f, AsEnumSet a) => f a -> EnumSet a
- Data.Enum.Set: fromRaw :: forall a. AsEnumSet a => EnumSetRep a -> EnumSet a
+ Data.Enum.Set: fromRaw :: AsEnumSet a => EnumSetRep a -> EnumSet a
- Data.Enum.Set: insert :: forall a. AsEnumSet a => a -> EnumSet a -> EnumSet a
+ Data.Enum.Set: insert :: AsEnumSet a => a -> EnumSet a -> EnumSet a
- Data.Enum.Set: intersection :: forall a. AsEnumSet a => EnumSet a -> EnumSet a -> EnumSet a
+ Data.Enum.Set: intersection :: AsEnumSet a => EnumSet a -> EnumSet a -> EnumSet a
- Data.Enum.Set: isSubsetOf :: forall a. AsEnumSet a => EnumSet a -> EnumSet a -> Bool
+ Data.Enum.Set: isSubsetOf :: AsEnumSet a => EnumSet a -> EnumSet a -> Bool
- Data.Enum.Set: map :: forall a b. (AsEnumSet a, AsEnumSet b) => (a -> b) -> EnumSet a -> EnumSet b
+ Data.Enum.Set: map :: (AsEnumSet a, AsEnumSet b) => (a -> b) -> EnumSet a -> EnumSet b
- Data.Enum.Set: maxView :: forall a. AsEnumSet a => EnumSet a -> Maybe (a, EnumSet a)
+ Data.Enum.Set: maxView :: AsEnumSet a => EnumSet a -> Maybe (a, EnumSet a)
- Data.Enum.Set: maximum :: forall a. AsEnumSet a => EnumSet a -> a
+ Data.Enum.Set: maximum :: AsEnumSet a => EnumSet a -> a
- Data.Enum.Set: member :: forall a. AsEnumSet a => a -> EnumSet a -> Bool
+ Data.Enum.Set: member :: AsEnumSet a => a -> EnumSet a -> Bool
- Data.Enum.Set: minView :: forall a. AsEnumSet a => EnumSet a -> Maybe (a, EnumSet a)
+ Data.Enum.Set: minView :: AsEnumSet a => EnumSet a -> Maybe (a, EnumSet a)
- Data.Enum.Set: minimum :: forall a. AsEnumSet a => EnumSet a -> a
+ Data.Enum.Set: minimum :: AsEnumSet a => EnumSet a -> a
- Data.Enum.Set: notMember :: forall a. AsEnumSet a => a -> EnumSet a -> Bool
+ Data.Enum.Set: notMember :: AsEnumSet a => a -> EnumSet a -> Bool
- Data.Enum.Set: null :: forall a. AsEnumSet a => EnumSet a -> Bool
+ Data.Enum.Set: null :: AsEnumSet a => EnumSet a -> Bool
- Data.Enum.Set: partition :: forall a. AsEnumSet a => (a -> Bool) -> EnumSet a -> (EnumSet a, EnumSet a)
+ Data.Enum.Set: partition :: AsEnumSet a => (a -> Bool) -> EnumSet a -> (EnumSet a, EnumSet a)
- Data.Enum.Set: singleton :: forall a. AsEnumSet a => a -> EnumSet a
+ Data.Enum.Set: singleton :: AsEnumSet a => a -> EnumSet a
- Data.Enum.Set: size :: forall a. AsEnumSet a => EnumSet a -> Int
+ Data.Enum.Set: size :: AsEnumSet a => EnumSet a -> Int
- Data.Enum.Set: symmetricDifference :: forall a. AsEnumSet a => EnumSet a -> EnumSet a -> EnumSet a
+ Data.Enum.Set: symmetricDifference :: AsEnumSet a => EnumSet a -> EnumSet a -> EnumSet a
- Data.Enum.Set: toList :: forall a. AsEnumSet a => EnumSet a -> [a]
+ Data.Enum.Set: toList :: AsEnumSet a => EnumSet a -> [a]
- Data.Enum.Set: toRaw :: forall a. AsEnumSet a => EnumSet a -> EnumSetRep a
+ Data.Enum.Set: toRaw :: AsEnumSet a => EnumSet a -> EnumSetRep a
- Data.Enum.Set: traverse :: forall f a. (Applicative f, AsEnumSet a) => (a -> f a) -> EnumSet a -> f (EnumSet a)
+ Data.Enum.Set: traverse :: (Applicative f, AsEnumSet a) => (a -> f a) -> EnumSet a -> f (EnumSet a)
- Data.Enum.Set: type EnumSet a = EnumSet (EnumSetRep a) a
+ Data.Enum.Set: type EnumSet a = EnumSet EnumSetRep a a
- Data.Enum.Set: union :: forall a. AsEnumSet a => EnumSet a -> EnumSet a -> EnumSet a
+ Data.Enum.Set: union :: AsEnumSet a => EnumSet a -> EnumSet a -> EnumSet a
- Data.Enum.Set.Base: (\\) :: forall w a. Bits w => EnumSet w a -> EnumSet w a -> EnumSet w a
+ Data.Enum.Set.Base: (\\) :: forall {k} w (a :: k). Bits w => EnumSet w a -> EnumSet w a -> EnumSet w a
- Data.Enum.Set.Base: all :: forall w a. (FiniteBits w, Num w, Enum a) => (a -> Bool) -> EnumSet w a -> Bool
+ Data.Enum.Set.Base: all :: (FiniteBits w, Num w, Enum a) => (a -> Bool) -> EnumSet w a -> Bool
- Data.Enum.Set.Base: any :: forall w a. (FiniteBits w, Num w, Enum a) => (a -> Bool) -> EnumSet w a -> Bool
+ Data.Enum.Set.Base: any :: (FiniteBits w, Num w, Enum a) => (a -> Bool) -> EnumSet w a -> Bool
- Data.Enum.Set.Base: data EnumSet word a
+ Data.Enum.Set.Base: data EnumSet word (a :: k)
- Data.Enum.Set.Base: delete :: forall w a. (Bits w, Enum a) => a -> EnumSet w a -> EnumSet w a
+ Data.Enum.Set.Base: delete :: (Bits w, Enum a) => a -> EnumSet w a -> EnumSet w a
- Data.Enum.Set.Base: deleteMax :: forall w a. (FiniteBits w, Num w) => EnumSet w a -> EnumSet w a
+ Data.Enum.Set.Base: deleteMax :: forall {k} w (a :: k). (FiniteBits w, Num w) => EnumSet w a -> EnumSet w a
- Data.Enum.Set.Base: deleteMin :: forall w a. (FiniteBits w, Num w) => EnumSet w a -> EnumSet w a
+ Data.Enum.Set.Base: deleteMin :: forall {k} w (a :: k). (FiniteBits w, Num w) => EnumSet w a -> EnumSet w a
- Data.Enum.Set.Base: difference :: forall w a. Bits w => EnumSet w a -> EnumSet w a -> EnumSet w a
+ Data.Enum.Set.Base: difference :: forall {k} w (a :: k). Bits w => EnumSet w a -> EnumSet w a -> EnumSet w a
- Data.Enum.Set.Base: empty :: forall w a. Bits w => EnumSet w a
+ Data.Enum.Set.Base: empty :: forall {k} w (a :: k). Bits w => EnumSet w a
- Data.Enum.Set.Base: filter :: forall w a. (FiniteBits w, Num w, Enum a) => (a -> Bool) -> EnumSet w a -> EnumSet w a
+ Data.Enum.Set.Base: filter :: (FiniteBits w, Num w, Enum a) => (a -> Bool) -> EnumSet w a -> EnumSet w a
- Data.Enum.Set.Base: foldMap :: forall m w a. (Monoid m, FiniteBits w, Num w, Enum a) => (a -> m) -> EnumSet w a -> m
+ Data.Enum.Set.Base: foldMap :: (Monoid m, FiniteBits w, Num w, Enum a) => (a -> m) -> EnumSet w a -> m
- Data.Enum.Set.Base: foldl :: forall w a b. (FiniteBits w, Num w, Enum a) => (b -> a -> b) -> b -> EnumSet w a -> b
+ Data.Enum.Set.Base: foldl :: (FiniteBits w, Num w, Enum a) => (b -> a -> b) -> b -> EnumSet w a -> b
- Data.Enum.Set.Base: foldl' :: forall w a b. (FiniteBits w, Num w, Enum a) => (b -> a -> b) -> b -> EnumSet w a -> b
+ Data.Enum.Set.Base: foldl' :: (FiniteBits w, Num w, Enum a) => (b -> a -> b) -> b -> EnumSet w a -> b
- Data.Enum.Set.Base: foldl1 :: forall w a. (FiniteBits w, Num w, Enum a) => (a -> a -> a) -> EnumSet w a -> a
+ Data.Enum.Set.Base: foldl1 :: (FiniteBits w, Num w, Enum a) => (a -> a -> a) -> EnumSet w a -> a
- Data.Enum.Set.Base: foldl1' :: forall w a. (FiniteBits w, Num w, Enum a) => (a -> a -> a) -> EnumSet w a -> a
+ Data.Enum.Set.Base: foldl1' :: (FiniteBits w, Num w, Enum a) => (a -> a -> a) -> EnumSet w a -> a
- Data.Enum.Set.Base: foldr :: forall w a b. (FiniteBits w, Num w, Enum a) => (a -> b -> b) -> b -> EnumSet w a -> b
+ Data.Enum.Set.Base: foldr :: (FiniteBits w, Num w, Enum a) => (a -> b -> b) -> b -> EnumSet w a -> b
- Data.Enum.Set.Base: foldr' :: forall w a b. (FiniteBits w, Num w, Enum a) => (a -> b -> b) -> b -> EnumSet w a -> b
+ Data.Enum.Set.Base: foldr' :: (FiniteBits w, Num w, Enum a) => (a -> b -> b) -> b -> EnumSet w a -> b
- Data.Enum.Set.Base: foldr1 :: forall w a. (FiniteBits w, Num w, Enum a) => (a -> a -> a) -> EnumSet w a -> a
+ Data.Enum.Set.Base: foldr1 :: (FiniteBits w, Num w, Enum a) => (a -> a -> a) -> EnumSet w a -> a
- Data.Enum.Set.Base: foldr1' :: forall w a. (FiniteBits w, Num w, Enum a) => (a -> a -> a) -> EnumSet w a -> a
+ Data.Enum.Set.Base: foldr1' :: (FiniteBits w, Num w, Enum a) => (a -> a -> a) -> EnumSet w a -> a
- Data.Enum.Set.Base: fromFoldable :: forall f w a. (Foldable f, Bits w, Enum a) => f a -> EnumSet w a
+ Data.Enum.Set.Base: fromFoldable :: (Foldable f, Bits w, Enum a) => f a -> EnumSet w a
- Data.Enum.Set.Base: fromRaw :: forall w a. w -> EnumSet w a
+ Data.Enum.Set.Base: fromRaw :: forall {k} w (a :: k). w -> EnumSet w a
- Data.Enum.Set.Base: insert :: forall w a. (Bits w, Enum a) => a -> EnumSet w a -> EnumSet w a
+ Data.Enum.Set.Base: insert :: (Bits w, Enum a) => a -> EnumSet w a -> EnumSet w a
- Data.Enum.Set.Base: intersection :: forall w a. Bits w => EnumSet w a -> EnumSet w a -> EnumSet w a
+ Data.Enum.Set.Base: intersection :: forall {k} w (a :: k). Bits w => EnumSet w a -> EnumSet w a -> EnumSet w a
- Data.Enum.Set.Base: isSubsetOf :: forall w a. Bits w => EnumSet w a -> EnumSet w a -> Bool
+ Data.Enum.Set.Base: isSubsetOf :: forall {k} w (a :: k). Bits w => EnumSet w a -> EnumSet w a -> Bool
- Data.Enum.Set.Base: map :: forall w a b. (FiniteBits w, Num w, Enum a, Enum b) => (a -> b) -> EnumSet w a -> EnumSet w b
+ Data.Enum.Set.Base: map :: (FiniteBits w, Num w, Enum a, Enum b) => (a -> b) -> EnumSet w a -> EnumSet w b
- Data.Enum.Set.Base: map' :: forall v w a b. (FiniteBits v, FiniteBits w, Num v, Num w, Enum a, Enum b) => (a -> b) -> EnumSet v a -> EnumSet w b
+ Data.Enum.Set.Base: map' :: (FiniteBits v, FiniteBits w, Num v, Num w, Enum a, Enum b) => (a -> b) -> EnumSet v a -> EnumSet w b
- Data.Enum.Set.Base: maxView :: forall w a. (FiniteBits w, Num w, Enum a) => EnumSet w a -> Maybe (a, EnumSet w a)
+ Data.Enum.Set.Base: maxView :: (FiniteBits w, Num w, Enum a) => EnumSet w a -> Maybe (a, EnumSet w a)
- Data.Enum.Set.Base: maximum :: forall w a. (FiniteBits w, Num w, Enum a) => EnumSet w a -> a
+ Data.Enum.Set.Base: maximum :: (FiniteBits w, Num w, Enum a) => EnumSet w a -> a
- Data.Enum.Set.Base: member :: forall w a. (Bits w, Enum a) => a -> EnumSet w a -> Bool
+ Data.Enum.Set.Base: member :: (Bits w, Enum a) => a -> EnumSet w a -> Bool
- Data.Enum.Set.Base: minView :: forall w a. (FiniteBits w, Num w, Enum a) => EnumSet w a -> Maybe (a, EnumSet w a)
+ Data.Enum.Set.Base: minView :: (FiniteBits w, Num w, Enum a) => EnumSet w a -> Maybe (a, EnumSet w a)
- Data.Enum.Set.Base: minimum :: forall w a. (FiniteBits w, Num w, Enum a) => EnumSet w a -> a
+ Data.Enum.Set.Base: minimum :: (FiniteBits w, Num w, Enum a) => EnumSet w a -> a
- Data.Enum.Set.Base: notMember :: forall w a. (Bits w, Enum a) => a -> EnumSet w a -> Bool
+ Data.Enum.Set.Base: notMember :: (Bits w, Enum a) => a -> EnumSet w a -> Bool
- Data.Enum.Set.Base: null :: forall w a. Bits w => EnumSet w a -> Bool
+ Data.Enum.Set.Base: null :: forall {k} w (a :: k). Bits w => EnumSet w a -> Bool
- Data.Enum.Set.Base: partition :: forall w a. (FiniteBits w, Num w, Enum a) => (a -> Bool) -> EnumSet w a -> (EnumSet w a, EnumSet w a)
+ Data.Enum.Set.Base: partition :: (FiniteBits w, Num w, Enum a) => (a -> Bool) -> EnumSet w a -> (EnumSet w a, EnumSet w a)
- Data.Enum.Set.Base: singleton :: forall w a. (Bits w, Enum a) => a -> EnumSet w a
+ Data.Enum.Set.Base: singleton :: (Bits w, Enum a) => a -> EnumSet w a
- Data.Enum.Set.Base: size :: forall w a. (Bits w, Num w) => EnumSet w a -> Int
+ Data.Enum.Set.Base: size :: forall {k} w (a :: k). (Bits w, Num w) => EnumSet w a -> Int
- Data.Enum.Set.Base: symmetricDifference :: forall w a. Bits w => EnumSet w a -> EnumSet w a -> EnumSet w a
+ Data.Enum.Set.Base: symmetricDifference :: forall {k} w (a :: k). Bits w => EnumSet w a -> EnumSet w a -> EnumSet w a
- Data.Enum.Set.Base: toList :: forall w a. (FiniteBits w, Num w, Enum a) => EnumSet w a -> [a]
+ Data.Enum.Set.Base: toList :: (FiniteBits w, Num w, Enum a) => EnumSet w a -> [a]
- Data.Enum.Set.Base: toRaw :: forall w a. EnumSet w a -> w
+ Data.Enum.Set.Base: toRaw :: forall {k} w (a :: k). EnumSet w a -> w
- Data.Enum.Set.Base: traverse :: forall f w a. (Applicative f, FiniteBits w, Num w, Enum a) => (a -> f a) -> EnumSet w a -> f (EnumSet w a)
+ Data.Enum.Set.Base: traverse :: (Applicative f, FiniteBits w, Num w, Enum a) => (a -> f a) -> EnumSet w a -> f (EnumSet w a)
- Data.Enum.Set.Base: union :: forall w a. Bits w => EnumSet w a -> EnumSet w a -> EnumSet w a
+ Data.Enum.Set.Base: union :: forall {k} w (a :: k). Bits w => EnumSet w a -> EnumSet w a -> EnumSet w a

Files

Data/Enum/Set/Base.hs view
@@ -125,14 +125,15 @@ import qualified GHC.Exts
 import qualified Data.Foldable as F
 
-import Prelude hiding (Foldable(..), all, any, filter, map, traverse)
+import Prelude hiding (Applicative(..), Foldable(..), all, any, filter, map, traverse)
 import Data.Foldable (Foldable)
 
-import Control.Applicative (liftA2)
+import Control.Applicative (Applicative(..))
 import Control.DeepSeq (NFData)
 import Data.Aeson (ToJSON(..))
 import Data.Bits
 import Data.Data (Data)
+import Data.Hashable (Hashable)
 import Data.Vector.Unboxed (Vector, MVector, Unbox)
 import Foreign.Storable (Storable)
 import GHC.Exts (IsList(Item), build)
@@ -154,7 +155,7 @@ -- | A set of values @a@ with representation @word@,
 -- implemented as bitwise operations.
 newtype EnumSet word a = EnumSet word
-    deriving (Eq, Ord, Data, Storable, NFData, P.Prim, Unbox)
+    deriving (Eq, Ord, Data, Hashable, Storable, NFData, P.Prim, Unbox)
 
 newtype instance MVector s (EnumSet word a) = MV_EnumSet (P.MVector s (EnumSet word a))
 newtype instance Vector    (EnumSet word a) = V_EnumSet  (P.Vector    (EnumSet word a))
bitwise-enum.cabal view
@@ -1,11 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.35.2.+-- This file has been generated from package.yaml by hpack version 0.39.1. -- -- see: https://github.com/sol/hpack  name:           bitwise-enum-version:        1.0.1.2+version:        1.0.2.0 synopsis:       Bitwise operations on bounded enumerations description:    Bitwise operations on bounded enumerations.                 .@@ -21,7 +21,8 @@ license-file:   LICENSE build-type:     Simple tested-with:-    GHC ==8.6.1+    GHC ==9.4.8+ || ==8.6.1  || ==8.6.5  || ==8.8.4  || ==8.10.7@@ -46,10 +47,11 @@       ./   ghc-options: -Wall -Wcompat -Widentities -Wincomplete-uni-patterns -Wincomplete-record-updates -ferror-spans -funbox-small-strict-fields -O2   build-depends:-      aeson >=0.11 && <2.3+      aeson >=0.11 && <2.4     , array >=0.5.1 && <0.6     , base >=4.12 && <5-    , deepseq >=1.1 && <1.6+    , deepseq >=1.1 && <1.7+    , hashable >=1.4 && <1.6     , mono-traversable >=1.0.12 && <1.1     , vector >=0.11 && <0.14   default-language: Haskell2010@@ -64,11 +66,12 @@   ghc-options: -Wall -Wcompat -Widentities -Wincomplete-uni-patterns -Wincomplete-record-updates -ferror-spans -funbox-small-strict-fields   build-depends:       QuickCheck >=2.13.2-    , aeson >=0.11 && <2.3+    , aeson >=0.11 && <2.4     , array >=0.5.1 && <0.6     , base     , bitwise-enum-    , deepseq >=1.1 && <1.6+    , deepseq >=1.1 && <1.7+    , hashable >=1.4 && <1.6     , mono-traversable >=1.0.12 && <1.1     , test-framework >=0.8.2.0     , test-framework-quickcheck2 >=0.3.0.5@@ -84,12 +87,13 @@       benchmarks   ghc-options: -Wall -Wcompat -Widentities -Wincomplete-uni-patterns -Wincomplete-record-updates -ferror-spans -funbox-small-strict-fields -rtsopts -threaded -with-rtsopts=-N -O2   build-depends:-      aeson >=0.11 && <2.3+      aeson >=0.11 && <2.4     , array >=0.5.1 && <0.6     , base     , bitwise-enum-    , deepseq >=1.1 && <1.6+    , deepseq >=1.1 && <1.7     , gauge >=0.2.5+    , hashable >=1.4 && <1.6     , mono-traversable >=1.0.12 && <1.1     , vector >=0.11 && <0.14     , wide-word >=0.1.0.9
tests/set-properties.hs view
@@ -6,7 +6,7 @@ import Prelude
 
 import Control.Applicative ((<|>))
-import Data.Foldable (foldl', foldr')
+import Data.Foldable (Foldable(..))
 import Data.List ((\\), nub, sort)
 import Data.Bits
 import Test.Framework