diff --git a/Setup.hs b/Setup.hs deleted file mode 100644 --- a/Setup.hs +++ /dev/null @@ -1,2 +0,0 @@ -import Distribution.Simple -main = defaultMain diff --git a/cereal-unordered-containers.cabal b/cereal-unordered-containers.cabal --- a/cereal-unordered-containers.cabal +++ b/cereal-unordered-containers.cabal @@ -1,44 +1,69 @@ -name: - cereal-unordered-containers -version: - 0.1 -synopsis: - Integration of "cereal" and "unordered-containers" -homepage: - https://github.com/metrix-ai/cereal-unordered-containers +cabal-version: 3.0 +name: cereal-unordered-containers +version: 0.1.0.1 +synopsis: Integration of "cereal" and "unordered-containers" +homepage: https://github.com/metrix-ai/cereal-unordered-containers bug-reports: https://github.com/metrix-ai/cereal-unordered-containers/issues -author: - Nikita Volkov -maintainer: - Metrix.AI Ninjas -copyright: - (c) 2018, Metrix.AI -license: - MIT -license-file: - LICENSE -build-type: - Simple -cabal-version: - >=1.10 +author: Nikita Volkov +maintainer: Metrix.AI Tech Team +copyright: (c) 2018, Metrix.AI +license: MIT +license-file: LICENSE + library - hs-source-dirs: - library + hs-source-dirs: library default-extensions: - Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples - default-language: - Haskell2010 + NoImplicitPrelude + NoMonomorphismRestriction + Arrows + BangPatterns + ConstraintKinds + DataKinds + DefaultSignatures + DeriveDataTypeable + DeriveFoldable + DeriveFunctor + DeriveGeneric + DeriveTraversable + EmptyDataDecls + FlexibleContexts + FlexibleInstances + FunctionalDependencies + GADTs + GeneralizedNewtypeDeriving + LambdaCase + LiberalTypeSynonyms + MagicHash + MultiParamTypeClasses + MultiWayIf + OverloadedStrings + ParallelListComp + PatternGuards + QuasiQuotes + RankNTypes + RecordWildCards + ScopedTypeVariables + StandaloneDeriving + TemplateHaskell + TupleSections + TypeFamilies + TypeOperators + UnboxedTuples + + default-language: Haskell2010 exposed-modules: - Cereal.UnorderedContainers.Serialize - Cereal.UnorderedContainers.Put Cereal.UnorderedContainers.Get + Cereal.UnorderedContainers.Put + Cereal.UnorderedContainers.Serialize + other-modules: - Cereal.UnorderedContainers.Prelude Cereal.UnorderedContainers.Extras.StrictHashMap + Cereal.UnorderedContainers.Prelude + build-depends: - base <5, - cereal >=0.5.5 && <0.6, - hashable >=1.2 && <2, - unordered-containers >=0.2 && <0.3 + , base >=4 && <5 + , cereal >=0.5.5 && <0.6 + , hashable >=1.2 && <2 + , unordered-containers >=0.2 && <0.3 diff --git a/library/Cereal/UnorderedContainers/Extras/StrictHashMap.hs b/library/Cereal/UnorderedContainers/Extras/StrictHashMap.hs --- a/library/Cereal/UnorderedContainers/Extras/StrictHashMap.hs +++ b/library/Cereal/UnorderedContainers/Extras/StrictHashMap.hs @@ -1,17 +1,17 @@ +{-# OPTIONS_GHC -Wno-redundant-constraints #-} + module Cereal.UnorderedContainers.Extras.StrictHashMap -( - module Data.HashMap.Strict, - traverse_, - replicateM, -) + ( module Data.HashMap.Strict, + traverse_, + replicateM, + ) where -import Cereal.UnorderedContainers.Prelude hiding (traverse_, replicateM, insert, empty) +import Cereal.UnorderedContainers.Prelude hiding (empty, insert, replicateM, traverse_) import Data.HashMap.Strict - {-# INLINE traverse_ #-} -traverse_ :: Applicative m => (k -> v -> m ()) -> HashMap k v -> m () +traverse_ :: (Applicative m) => (k -> v -> m ()) -> HashMap k v -> m () traverse_ m = foldrWithKey step init where @@ -20,10 +20,11 @@ {-# INLINE replicateM #-} replicateM :: (Monad m, Eq k, Hashable k) => Int -> m (k, v) -> m (HashMap k v) -replicateM amount m = let - iterate index !state = if index < amount - then do - (k, v) <- m - iterate (succ index) (insert k v state) - else return state - in iterate 0 empty +replicateM amount m = + let iterate index !state = + if index < amount + then do + (k, v) <- m + iterate (succ index) (insert k v state) + else return state + in iterate 0 empty diff --git a/library/Cereal/UnorderedContainers/Get.hs b/library/Cereal/UnorderedContainers/Get.hs --- a/library/Cereal/UnorderedContainers/Get.hs +++ b/library/Cereal/UnorderedContainers/Get.hs @@ -1,11 +1,12 @@ -module Cereal.UnorderedContainers.Get -where +{-# OPTIONS_GHC -Wno-redundant-constraints #-} -import Cereal.UnorderedContainers.Prelude -import qualified Cereal.UnorderedContainers.Extras.StrictHashMap as StrictHashMap +module Cereal.UnorderedContainers.Get where +import qualified Cereal.UnorderedContainers.Extras.StrictHashMap as StrictHashMap +import Cereal.UnorderedContainers.Prelude strictHashMap :: (Eq key, Hashable key) => Get Int -> Get key -> Get value -> Get (StrictHashMap.HashMap key value) -strictHashMap int key value = size >>= associations where - size = int - associations size = StrictHashMap.replicateM size ((,) <$> key <*> value) +strictHashMap int key value = size >>= associations + where + size = int + associations size = StrictHashMap.replicateM size ((,) <$> key <*> value) diff --git a/library/Cereal/UnorderedContainers/Prelude.hs b/library/Cereal/UnorderedContainers/Prelude.hs --- a/library/Cereal/UnorderedContainers/Prelude.hs +++ b/library/Cereal/UnorderedContainers/Prelude.hs @@ -1,20 +1,16 @@ module Cereal.UnorderedContainers.Prelude -( - module Exports, -) + ( module Exports, + ) where - --- base -------------------------- import Control.Applicative as Exports import Control.Arrow as Exports import Control.Category as Exports import Control.Concurrent as Exports import Control.Exception as Exports -import Control.Monad as Exports hiding (mapM_, sequence_, forM_, msum, mapM, sequence, forM) -import Control.Monad.IO.Class as Exports +import Control.Monad as Exports hiding (forM, forM_, mapM, mapM_, msum, sequence, sequence_) import Control.Monad.Fix as Exports hiding (fix) +import Control.Monad.IO.Class as Exports import Control.Monad.ST as Exports import Data.Bits as Exports import Data.Bool as Exports @@ -27,19 +23,21 @@ import Data.Fixed as Exports import Data.Foldable as Exports import Data.Function as Exports hiding (id, (.)) -import Data.Functor as Exports +import Data.Functor as Exports hiding (unzip) import Data.Functor.Identity as Exports -import Data.Int as Exports +import Data.Hashable as Exports (Hashable) import Data.IORef as Exports +import Data.Int as Exports import Data.Ix as Exports -import Data.List as Exports hiding (sortOn, isSubsequenceOf, uncons, concat, foldr, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, find, maximumBy, minimumBy, mapAccumL, mapAccumR, foldl') +import Data.List as Exports hiding (all, and, any, concat, concatMap, elem, find, foldl, foldl', foldl1, foldr, foldr1, isSubsequenceOf, mapAccumL, mapAccumR, maximum, maximumBy, minimum, minimumBy, notElem, or, product, sortOn, sum, uncons) import Data.Maybe as Exports -import Data.Monoid as Exports hiding (Last(..), First(..), (<>)) +import Data.Monoid as Exports hiding (First (..), Last (..), (<>)) import Data.Ord as Exports import Data.Proxy as Exports import Data.Ratio as Exports -import Data.Semigroup as Exports import Data.STRef as Exports +import Data.Semigroup as Exports +import Data.Serialize as Exports import Data.String as Exports import Data.Traversable as Exports import Data.Tuple as Exports @@ -50,13 +48,12 @@ import Foreign.ForeignPtr as Exports import Foreign.Ptr as Exports import Foreign.StablePtr as Exports -import Foreign.Storable as Exports hiding (sizeOf, alignment) -import GHC.Conc as Exports hiding (withMVar, threadWaitWriteSTM, threadWaitWrite, threadWaitReadSTM, threadWaitRead) -import GHC.Exts as Exports (lazy, inline, sortWith, groupWith) +import Foreign.Storable as Exports hiding (alignment, sizeOf) +import GHC.Conc as Exports hiding (threadWaitRead, threadWaitReadSTM, threadWaitWrite, threadWaitWriteSTM, withMVar) +import GHC.Exts as Exports (groupWith, inline, lazy, sortWith) import GHC.Generics as Exports (Generic) import GHC.IO.Exception as Exports import Numeric as Exports -import Prelude as Exports hiding (concat, foldr, mapM_, sequence_, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, mapM, sequence, id, (.)) import System.Environment as Exports import System.Exit as Exports import System.IO as Exports @@ -65,16 +62,7 @@ import System.Mem as Exports import System.Mem.StableName as Exports import System.Timeout as Exports -import Text.ParserCombinators.ReadP as Exports (ReadP, ReadS, readP_to_S, readS_to_P) -import Text.ParserCombinators.ReadPrec as Exports (ReadPrec, readPrec_to_P, readP_to_Prec, readPrec_to_S, readS_to_Prec) -import Text.Printf as Exports (printf, hPrintf) -import Text.Read as Exports (Read(..), readMaybe, readEither) +import Text.Printf as Exports (hPrintf, printf) +import Text.Read as Exports (Read (..), readEither, readMaybe) import Unsafe.Coerce as Exports - --- cereal -------------------------- -import Data.Serialize as Exports - --- hashable -------------------------- -import Data.Hashable as Exports (Hashable) +import Prelude as Exports hiding (all, and, any, concat, concatMap, elem, foldl, foldl1, foldr, foldr1, id, mapM, mapM_, maximum, minimum, notElem, or, product, sequence, sequence_, sum, (.)) diff --git a/library/Cereal/UnorderedContainers/Put.hs b/library/Cereal/UnorderedContainers/Put.hs --- a/library/Cereal/UnorderedContainers/Put.hs +++ b/library/Cereal/UnorderedContainers/Put.hs @@ -1,12 +1,11 @@ -module Cereal.UnorderedContainers.Put -where +module Cereal.UnorderedContainers.Put where -import Cereal.UnorderedContainers.Prelude import qualified Cereal.UnorderedContainers.Extras.StrictHashMap as StrictHashMap - +import Cereal.UnorderedContainers.Prelude strictHashMap :: Putter Int -> Putter key -> Putter value -> Putter (StrictHashMap.HashMap key value) -strictHashMap int key value x = size *> associations where - size = int (StrictHashMap.size x) - associations = StrictHashMap.traverse_ association x - association keyValue valueValue = key keyValue *> value valueValue +strictHashMap int key value x = size *> associations + where + size = int (StrictHashMap.size x) + associations = StrictHashMap.traverse_ association x + association keyValue valueValue = key keyValue *> value valueValue diff --git a/library/Cereal/UnorderedContainers/Serialize.hs b/library/Cereal/UnorderedContainers/Serialize.hs --- a/library/Cereal/UnorderedContainers/Serialize.hs +++ b/library/Cereal/UnorderedContainers/Serialize.hs @@ -1,14 +1,13 @@ -{-| -Orphan instances of "Serialize". --} -module Cereal.UnorderedContainers.Serialize -where +{-# OPTIONS_GHC -Wno-orphans #-} +-- | +-- Orphan instances of "Serialize". +module Cereal.UnorderedContainers.Serialize where + +import qualified Cereal.UnorderedContainers.Extras.StrictHashMap as StrictHashMap +import qualified Cereal.UnorderedContainers.Get as Get import Cereal.UnorderedContainers.Prelude import qualified Cereal.UnorderedContainers.Put as Put -import qualified Cereal.UnorderedContainers.Get as Get -import qualified Cereal.UnorderedContainers.Extras.StrictHashMap as StrictHashMap - instance (Eq key, Hashable key, Serialize key, Serialize value) => Serialize (StrictHashMap.HashMap key value) where put = Put.strictHashMap put put put