tlex-core 0.2.1.0 → 0.3.0.0

raw patch · 9 files changed

+25/−198 lines, 9 filesdep +enummapset-thPVP ok

version bump matches the API change (PVP)

Dependencies added: enummapset-th

API changes (from Hackage documentation)

Files

• src/Language/Lexer/Tlex/Data/EnumMap.hs +0/−103
• src/Language/Lexer/Tlex/Data/EnumSet.hs +0/−73
• src/Language/Lexer/Tlex/Data/SymEnumSet.hs +1/−1
• src/Language/Lexer/Tlex/Machine/DFA.hs +1/−1
• src/Language/Lexer/Tlex/Machine/Pattern.hs +1/−1
• src/Language/Lexer/Tlex/Pipeline/MinDfa.hs +1/−1
• src/Language/Lexer/Tlex/Pipeline/Nfa2Dfa.hs +11/−7
• src/Language/Lexer/Tlex/Pipeline/Pattern2Nfa.hs +2/−2
• tlex-core.cabal +8/−9

@@ -1,103 +0,0 @@-module Language.Lexer.Tlex.Data.EnumMap (-    EnumMap,-    empty,-    insert,-    assocs,-    keys,-    toAscList,-    toDescList,-    lookup,-    member,-    insertOrUpdate,-    fromList,-    foldlWithKey',-    update,-    delete,-    singleton,-    unionWith,-    intersectionWith,-    mapWithKey,-    mergeWithKey,-) where--import           Prelude            hiding (lookup)--import qualified Data.Coerce        as Coerce-import qualified Data.IntMap.Strict as IntMap---newtype EnumMap k a = EnumMap-    { unEnumMap :: IntMap.IntMap a-    }-    deriving (Eq, Show, Functor)--empty :: Enum k => EnumMap k a-empty = EnumMap IntMap.empty--singleton :: Enum k => k -> a -> EnumMap k a-singleton k x = EnumMap do IntMap.singleton (fromEnum k) x--insert :: Enum k => k -> a -> EnumMap k a -> EnumMap k a-insert k x (EnumMap m) = EnumMap do IntMap.insert (fromEnum k) x m--assocs :: Enum k => EnumMap k a -> [(k, a)]-assocs (EnumMap m) = [ (toEnum i, x) | (i, x) <- IntMap.assocs m ]--keys :: Enum k => EnumMap k a -> [k]-keys (EnumMap m) = [ toEnum k | k <- IntMap.keys m ]--toAscList :: Enum k => EnumMap k a -> [(k, a)]-toAscList (EnumMap m) = [ (toEnum i, x) | (i, x) <- IntMap.toAscList m ]--toDescList :: Enum k => EnumMap k a -> [(k, a)]-toDescList (EnumMap m) = [ (toEnum i, x) | (i, x) <- IntMap.toDescList m ]--lookup :: Enum k => k -> EnumMap k a -> Maybe a-lookup k (EnumMap m) = IntMap.lookup (fromEnum k) m--member :: Enum k => k -> EnumMap k a -> Bool-member k (EnumMap m) = IntMap.member (fromEnum k) m--insertOrUpdate :: Enum k => k -> a -> (a -> a) -> EnumMap k a -> EnumMap k a-insertOrUpdate k ~dx ~uf (EnumMap m) =-    let ik = fromEnum k-    in EnumMap case IntMap.lookup ik m of-        Nothing -> IntMap.insert ik dx m-        Just x  -> IntMap.insert ik (uf x) m--fromList :: Enum k => [(k, a)] -> EnumMap k a-fromList xs = EnumMap do IntMap.fromList [ (fromEnum i, x) | (i, x) <- xs ]--delete :: Enum k => k -> EnumMap k a -> EnumMap k a-delete k (EnumMap m) = EnumMap do IntMap.delete (fromEnum k) m--foldlWithKey' :: Enum k => (b -> k -> a -> b) -> b -> EnumMap k a -> b-foldlWithKey' f acc0 (EnumMap m) = IntMap.foldlWithKey' (\acc i x -> f acc (toEnum i) x) acc0 m--update :: Enum k => (a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a-update f k (EnumMap m) = EnumMap do IntMap.update f (fromEnum k) m--unionWith :: Enum k => (a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a-unionWith f (EnumMap m1) (EnumMap m2) = EnumMap do IntMap.unionWith f m1 m2--intersectionWith :: Enum k => (a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a-intersectionWith f (EnumMap m1) (EnumMap m2) = EnumMap do IntMap.intersectionWith f m1 m2--mapWithKey :: Enum k => (k -> a -> b) -> EnumMap k a -> EnumMap k b-mapWithKey f (EnumMap m) = EnumMap do-    IntMap.mapWithKey-        do \i x -> f (toEnum i) x-        do m--mergeWithKey :: Enum k-    => (k -> a -> b -> Maybe c)-    -> (EnumMap k a -> EnumMap k c)-    -> (EnumMap k b -> EnumMap k c)-    -> EnumMap k a -> EnumMap k b -> EnumMap k c-mergeWithKey f g1 g2 (EnumMap m1) (EnumMap m2) = EnumMap do-    IntMap.mergeWithKey-        do \i x y -> f (toEnum i) x y-        do \m -> Coerce.coerce g1 m-        do \m -> Coerce.coerce g2 m-        do m1-        do m2

@@ -1,73 +0,0 @@-module Language.Lexer.Tlex.Data.EnumSet (-    EnumSet,-    empty,-    singleton,-    insert,-    member,-    union,-    intersection,-    difference,-    partition,-    fromList,-    toList,-    toIntSet,-) where--import           Language.Lexer.Tlex.Prelude hiding (empty, toList)--import qualified Data.Hashable               as Hashable-import qualified Data.IntSet                 as IntSet---newtype EnumSet a = EnumSet IntSet.IntSet-    deriving (Eq, Show)--instance Hashable.Hashable (EnumSet a) where-    hashWithSalt s (EnumSet x) = Hashable.hashWithSalt s do IntSet.toAscList x--instance Enum a => Semigroup (EnumSet a) where-    (<>) = union--instance Enum a => Monoid (EnumSet a) where-    mempty = empty--empty :: Enum a => EnumSet a-empty = EnumSet IntSet.empty--singleton :: Enum a => a -> EnumSet a-singleton x = EnumSet do IntSet.singleton do fromEnum x--insert :: Enum a => a -> EnumSet a -> EnumSet a-insert x (EnumSet s) = EnumSet-    do IntSet.insert-        do fromEnum x-        do s--member :: Enum a => a -> EnumSet a -> Bool-member x (EnumSet s) = IntSet.member-    do fromEnum x-    do s--union :: Enum a => EnumSet a -> EnumSet a -> EnumSet a-union (EnumSet s1) (EnumSet s2) = EnumSet do IntSet.union s1 s2--intersection :: Enum a => EnumSet a -> EnumSet a -> EnumSet a-intersection (EnumSet s1) (EnumSet s2) = EnumSet do IntSet.intersection s1 s2--difference :: Enum a => EnumSet a -> EnumSet a -> EnumSet a-difference (EnumSet s1) (EnumSet s2) = EnumSet do IntSet.difference s1 s2--partition :: Enum a => (a -> Bool) -> EnumSet a -> (EnumSet a, EnumSet a)-partition p (EnumSet s) = coerce-    do IntSet.partition-        do \i -> p do toEnum i-        s--fromList :: Enum a => [a] -> EnumSet a-fromList xs = EnumSet do IntSet.fromList [ fromEnum x | x <- xs ]--toList :: Enum a => EnumSet a -> [a]-toList (EnumSet xs) = [ toEnum x | x <- IntSet.toList xs ]--toIntSet :: Enum a => EnumSet a -> IntSet.IntSet-toIntSet (EnumSet m) = m

@@ -14,7 +14,7 @@  import           Prelude -import qualified Language.Lexer.Tlex.Data.EnumSet as EnumSet+import qualified Data.EnumSet as EnumSet   data SymEnumSet a = SymEnumSet

@@ -12,9 +12,9 @@  import           Language.Lexer.Tlex.Prelude +import qualified Data.EnumMap.Strict                 as EnumMap import qualified Data.IntMap                         as IntMap import qualified Data.List                           as List-import qualified Language.Lexer.Tlex.Data.EnumMap    as EnumMap import qualified Language.Lexer.Tlex.Machine.Pattern as Pattern import qualified Language.Lexer.Tlex.Machine.State   as MState 

@@ -13,8 +13,8 @@  import           Language.Lexer.Tlex.Prelude +import qualified Data.EnumSet                        as EnumSet import qualified Data.Hashable                       as Hashable-import qualified Language.Lexer.Tlex.Data.EnumSet    as EnumSet import qualified Language.Lexer.Tlex.Data.SymEnumSet as SymEnumSet  

@@ -4,10 +4,10 @@  import           Language.Lexer.Tlex.Prelude +import qualified Data.EnumMap.Strict                 as EnumMap import qualified Data.HashMap.Strict                 as HashMap import qualified Data.HashSet                        as HashSet import qualified Data.IntMap.Strict                  as IntMap-import qualified Language.Lexer.Tlex.Data.EnumMap    as EnumMap import qualified Language.Lexer.Tlex.Machine.DFA     as DFA import qualified Language.Lexer.Tlex.Machine.Pattern as Pattern import qualified Language.Lexer.Tlex.Machine.State   as MState

@@ -4,10 +4,10 @@  import           Language.Lexer.Tlex.Prelude +import qualified Data.EnumMap.Strict                 as EnumMap import qualified Data.HashMap.Strict                 as HashMap import qualified Data.IntMap.Strict                  as IntMap import qualified Data.IntSet                         as IntSet-import qualified Language.Lexer.Tlex.Data.EnumMap    as EnumMap import qualified Language.Lexer.Tlex.Machine.DFA     as DFA import qualified Language.Lexer.Tlex.Machine.NFA     as NFA import qualified Language.Lexer.Tlex.Machine.Pattern as Pattern@@ -132,9 +132,11 @@                 True ->                     let ~newTrans = insertNfaSn nfaSn otherTrans0                         trans1 = IntSet.foldl'-                            do \trans c -> EnumMap.insertOrUpdate c-                                do newTrans-                                do \ss -> insertNfaSn nfaSn ss+                            do \trans c -> EnumMap.alter+                                do \case+                                    Nothing -> Just newTrans+                                    Just ss -> Just do insertNfaSn nfaSn ss+                                do c                                 do trans                             do trans0                             do cs@@ -143,9 +145,11 @@                     let (diffTrans1, trans1) = IntSet.foldl'                                                 do \(diffTrans, trans) c ->                                                     ( EnumMap.delete c diffTrans-                                                    , EnumMap.insertOrUpdate c-                                                        MState.emptySet-                                                        id+                                                    , EnumMap.alter+                                                        do \case+                                                            Nothing -> Just MState.emptySet+                                                            Just ss -> Just ss+                                                        c                                                         trans                                                     )                                                 do (trans0, trans0)

@@ -4,7 +4,7 @@  import           Language.Lexer.Tlex.Prelude -import qualified Language.Lexer.Tlex.Data.EnumSet    as EnumSet+import qualified Data.EnumSet                        as EnumSet import qualified Language.Lexer.Tlex.Data.SymEnumSet as SymEnumSet import qualified Language.Lexer.Tlex.Machine.NFA     as NFA import qualified Language.Lexer.Tlex.Machine.Pattern as Pattern@@ -23,7 +23,7 @@                 let (isStraight, es) = SymEnumSet.toEnumSet s                 NFA.NFAStateTrans                     { NFA.nstTransIsStraight = isStraight-                    , NFA.nstTransRange = EnumSet.toIntSet es+                    , NFA.nstTransRange = EnumSet.unEnumSet es                     , NFA.nstTransNextState = e                     }         p1 Pattern.:^: p2 -> do

@@ -2,7 +2,7 @@ build-type:          Custom  name:                tlex-core-version:             0.2.1.0+version:             0.3.0.0 license:             Apache-2.0 OR MPL-2.0 license-file:        LICENSE copyright:           (c) 2021 Mizunashi Mana@@ -89,14 +89,15 @@             -dcore-lint      build-depends:-        base                 >= 4.12.0 && < 4.15,+        base                 >= 4.12.0  && < 4.15,          -- project depends-        array                >= 0.5.3 && < 0.6,-        containers           >= 0.6.0 && < 0.7,-        hashable             >= 1.3.0 && < 1.4,-        transformers         >= 0.5.6 && < 0.6,-        unordered-containers >= 0.2.13 && < 0.3,+        array                >= 0.5.3   && < 0.6,+        containers           >= 0.6.0   && < 0.7,+        hashable             >= 1.3.0   && < 1.4,+        transformers         >= 0.5.6   && < 0.6,+        unordered-containers >= 0.2.13  && < 0.3,+        enummapset-th        >= 0.6.0   && < 0.7,      autogen-modules:         Paths_tlex_core@@ -123,8 +124,6 @@         Language.Lexer.Tlex.Pipeline.Pattern2Nfa         Language.Lexer.Tlex.Pipeline.Nfa2Dfa         Language.Lexer.Tlex.Pipeline.MinDfa-        Language.Lexer.Tlex.Data.EnumSet-        Language.Lexer.Tlex.Data.EnumMap         Language.Lexer.Tlex.Data.SymEnumSet         Language.Lexer.Tlex.Data.Bag