packages feed

regex-tdfa 1.2.1 → 1.2.2

raw patch · 11 files changed

+232/−105 lines, 11 filesdep ~basenew-uploaderPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base

API changes (from Hackage documentation)

- Data.IntMap.CharMap2: instance Eq a => Eq (CharMap a)
- Data.IntMap.CharMap2: instance Functor CharMap
- Data.IntMap.CharMap2: instance Monoid (CharMap a)
- Data.IntMap.CharMap2: instance Ord a => Ord (CharMap a)
- Data.IntMap.CharMap2: instance Read a => Read (CharMap a)
- Data.IntMap.CharMap2: instance Show a => Show (CharMap a)
- Data.IntMap.CharMap2: unCharMap :: CharMap a -> IntMap a
- Data.IntMap.EnumMap2: instance Eq a => Eq (EnumMap k a)
- Data.IntMap.EnumMap2: instance Ord a => Ord (EnumMap k a)
- Data.IntMap.EnumMap2: instance Ord k => Foldable (EnumMap k)
- Data.IntMap.EnumMap2: instance Ord k => Functor (EnumMap k)
- Data.IntMap.EnumMap2: instance Ord k => Monoid (EnumMap k a)
- Data.IntMap.EnumMap2: instance Read a => Read (EnumMap k a)
- Data.IntMap.EnumMap2: instance Show a => Show (EnumMap k a)
- Data.IntMap.EnumMap2: unEnumMap :: EnumMap k a -> IntMap a
- Data.IntSet.EnumSet2: instance Eq (EnumSet e)
- Data.IntSet.EnumSet2: instance Monoid (EnumSet e)
- Data.IntSet.EnumSet2: instance Ord (EnumSet e)
- Data.IntSet.EnumSet2: instance Read (EnumSet e)
- Data.IntSet.EnumSet2: instance Show (EnumSet e)
- Data.IntSet.EnumSet2: unEnumSet :: EnumSet e -> IntSet
- Text.Regex.TDFA.ByteString: instance RegexContext Regex ByteString ByteString
- Text.Regex.TDFA.ByteString: instance RegexLike Regex ByteString
- Text.Regex.TDFA.ByteString: instance RegexMaker Regex CompOption ExecOption ByteString
- Text.Regex.TDFA.ByteString.Lazy: instance RegexContext Regex ByteString ByteString
- Text.Regex.TDFA.ByteString.Lazy: instance RegexLike Regex ByteString
- Text.Regex.TDFA.ByteString.Lazy: instance RegexMaker Regex CompOption ExecOption ByteString
- Text.Regex.TDFA.Common: basePos :: Orbits -> Position
- Text.Regex.TDFA.Common: captureGroups :: ExecOption -> Bool
- Text.Regex.TDFA.Common: caseSensitive :: CompOption -> Bool
- Text.Regex.TDFA.Common: d_dt :: DFA -> DT
- Text.Regex.TDFA.Common: d_id :: DFA -> SetIndex
- Text.Regex.TDFA.Common: dopaIndex :: DoPa -> Int
- Text.Regex.TDFA.Common: dt_a :: DT -> DT
- Text.Regex.TDFA.Common: dt_b :: DT -> DT
- Text.Regex.TDFA.Common: dt_dopas :: DT -> EnumSet DoPa
- Text.Regex.TDFA.Common: dt_other :: DT -> Transition
- Text.Regex.TDFA.Common: dt_test :: DT -> WhichTest
- Text.Regex.TDFA.Common: dt_trans :: DT -> CharMap Transition
- Text.Regex.TDFA.Common: dt_win :: DT -> IntMap Instructions
- Text.Regex.TDFA.Common: flagTag :: GroupInfo -> Tag
- Text.Regex.TDFA.Common: getOrbits :: Orbits -> !(Seq Position)
- Text.Regex.TDFA.Common: inOrbit :: Orbits -> !Bool
- Text.Regex.TDFA.Common: instance Enum DoPa
- Text.Regex.TDFA.Common: instance Enum WhichTest
- Text.Regex.TDFA.Common: instance Eq Action
- Text.Regex.TDFA.Common: instance Eq DoPa
- Text.Regex.TDFA.Common: instance Eq OP
- Text.Regex.TDFA.Common: instance Eq QT
- Text.Regex.TDFA.Common: instance Eq TagTask
- Text.Regex.TDFA.Common: instance Eq TagUpdate
- Text.Regex.TDFA.Common: instance Eq WhichTest
- Text.Regex.TDFA.Common: instance Ord DoPa
- Text.Regex.TDFA.Common: instance Ord WhichTest
- Text.Regex.TDFA.Common: instance Read CompOption
- Text.Regex.TDFA.Common: instance Read ExecOption
- Text.Regex.TDFA.Common: instance RegexOptions Regex CompOption ExecOption
- Text.Regex.TDFA.Common: instance Show Action
- Text.Regex.TDFA.Common: instance Show CompOption
- Text.Regex.TDFA.Common: instance Show DFA
- Text.Regex.TDFA.Common: instance Show DT
- Text.Regex.TDFA.Common: instance Show DoPa
- Text.Regex.TDFA.Common: instance Show ExecOption
- Text.Regex.TDFA.Common: instance Show GroupInfo
- Text.Regex.TDFA.Common: instance Show Instructions
- Text.Regex.TDFA.Common: instance Show OP
- Text.Regex.TDFA.Common: instance Show Orbits
- Text.Regex.TDFA.Common: instance Show QNFA
- Text.Regex.TDFA.Common: instance Show QT
- Text.Regex.TDFA.Common: instance Show TagTask
- Text.Regex.TDFA.Common: instance Show TagUpdate
- Text.Regex.TDFA.Common: instance Show WhichTest
- Text.Regex.TDFA.Common: instance Show WinEmpty
- Text.Regex.TDFA.Common: lastStarGreedy :: CompOption -> Bool
- Text.Regex.TDFA.Common: multiline :: CompOption -> Bool
- Text.Regex.TDFA.Common: newOrbits :: Instructions -> !(Maybe (Position -> OrbitTransformer))
- Text.Regex.TDFA.Common: newPos :: Instructions -> ![(Tag, Action)]
- Text.Regex.TDFA.Common: newSyntax :: CompOption -> Bool
- Text.Regex.TDFA.Common: ordinal :: Orbits -> (Maybe Int)
- Text.Regex.TDFA.Common: parentIndex :: GroupInfo -> GroupIndex
- Text.Regex.TDFA.Common: q_id :: QNFA -> Index
- Text.Regex.TDFA.Common: q_qt :: QNFA -> QT
- Text.Regex.TDFA.Common: qt_a :: QT -> QT
- Text.Regex.TDFA.Common: qt_b :: QT -> QT
- Text.Regex.TDFA.Common: qt_dopas :: QT -> EnumSet DoPa
- Text.Regex.TDFA.Common: qt_other :: QT -> QTrans
- Text.Regex.TDFA.Common: qt_test :: QT -> WhichTest
- Text.Regex.TDFA.Common: qt_trans :: QT -> CharMap QTrans
- Text.Regex.TDFA.Common: qt_win :: QT -> WinTags
- Text.Regex.TDFA.Common: regex_b_index :: Regex -> (Index, Index)
- Text.Regex.TDFA.Common: regex_b_tags :: Regex -> (Tag, Tag)
- Text.Regex.TDFA.Common: regex_compOptions :: Regex -> CompOption
- Text.Regex.TDFA.Common: regex_dfa :: Regex -> DFA
- Text.Regex.TDFA.Common: regex_execOptions :: Regex -> ExecOption
- Text.Regex.TDFA.Common: regex_groups :: Regex -> Array GroupIndex [GroupInfo]
- Text.Regex.TDFA.Common: regex_init :: Regex -> Index
- Text.Regex.TDFA.Common: regex_isFrontAnchored :: Regex -> Bool
- Text.Regex.TDFA.Common: regex_tags :: Regex -> Array Tag OP
- Text.Regex.TDFA.Common: regex_trie :: Regex -> TrieSet DFA
- Text.Regex.TDFA.Common: rightAssoc :: CompOption -> Bool
- Text.Regex.TDFA.Common: startTag :: GroupInfo -> Tag
- Text.Regex.TDFA.Common: stopTag :: GroupInfo -> Tag
- Text.Regex.TDFA.Common: thisIndex :: GroupInfo -> GroupIndex
- Text.Regex.TDFA.Common: trans_how :: Transition -> DTrans
- Text.Regex.TDFA.Common: trans_many :: Transition -> DFA
- Text.Regex.TDFA.Common: trans_single :: Transition -> DFA
- Text.Regex.TDFA.CorePattern: childGroups :: Q -> Bool
- Text.Regex.TDFA.CorePattern: firstNull :: P -> Bool
- Text.Regex.TDFA.CorePattern: getOrbit :: P -> Maybe Tag
- Text.Regex.TDFA.CorePattern: getTests :: SetTestInfo -> EnumMap WhichTest (EnumSet DoPa)
- Text.Regex.TDFA.CorePattern: instance Eq P
- Text.Regex.TDFA.CorePattern: instance Eq Q
- Text.Regex.TDFA.CorePattern: instance Eq SetTestInfo
- Text.Regex.TDFA.CorePattern: instance Eq Wanted
- Text.Regex.TDFA.CorePattern: instance Monoid SetTestInfo
- Text.Regex.TDFA.CorePattern: instance Show HandleTag
- Text.Regex.TDFA.CorePattern: instance Show P
- Text.Regex.TDFA.CorePattern: instance Show Q
- Text.Regex.TDFA.CorePattern: instance Show SetTestInfo
- Text.Regex.TDFA.CorePattern: instance Show Wanted
- Text.Regex.TDFA.CorePattern: nullQ :: Q -> NullView
- Text.Regex.TDFA.CorePattern: postSet :: Q -> [Tag]
- Text.Regex.TDFA.CorePattern: postTag :: Q -> Maybe Tag
- Text.Regex.TDFA.CorePattern: preReset :: Q -> [Tag]
- Text.Regex.TDFA.CorePattern: preTag :: Q -> Maybe Tag
- Text.Regex.TDFA.CorePattern: resetOrbits :: P -> [Tag]
- Text.Regex.TDFA.CorePattern: tagged :: Q -> Bool
- Text.Regex.TDFA.CorePattern: takes :: Q -> (Position, Maybe Position)
- Text.Regex.TDFA.CorePattern: unQ :: Q -> P
- Text.Regex.TDFA.CorePattern: unStar :: P -> Q
- Text.Regex.TDFA.CorePattern: wants :: Q -> Wanted
- Text.Regex.TDFA.IntArrTrieSet: next :: TrieSet v -> Array Int (TrieSet v)
- Text.Regex.TDFA.IntArrTrieSet: value :: TrieSet v -> v
- Text.Regex.TDFA.NewDFA.Engine_NC: instance Show WScratch
- Text.Regex.TDFA.NewDFA.Uncons: instance Uncons (Seq Char)
- Text.Regex.TDFA.NewDFA.Uncons: instance Uncons ByteString
- Text.Regex.TDFA.NewDFA.Uncons: instance Uncons [Char]
- Text.Regex.TDFA.Pattern: dopaIndex :: DoPa -> Int
- Text.Regex.TDFA.Pattern: getDoPa :: Pattern -> DoPa
- Text.Regex.TDFA.Pattern: getPatternChar :: Pattern -> Char
- Text.Regex.TDFA.Pattern: getPatternSet :: Pattern -> PatternSet
- Text.Regex.TDFA.Pattern: instance Eq Pattern
- Text.Regex.TDFA.Pattern: instance Eq PatternSet
- Text.Regex.TDFA.Pattern: instance Eq PatternSetCharacterClass
- Text.Regex.TDFA.Pattern: instance Eq PatternSetCollatingElement
- Text.Regex.TDFA.Pattern: instance Eq PatternSetEquivalenceClass
- Text.Regex.TDFA.Pattern: instance Ord PatternSetCharacterClass
- Text.Regex.TDFA.Pattern: instance Ord PatternSetCollatingElement
- Text.Regex.TDFA.Pattern: instance Ord PatternSetEquivalenceClass
- Text.Regex.TDFA.Pattern: instance Show Pattern
- Text.Regex.TDFA.Pattern: instance Show PatternSet
- Text.Regex.TDFA.Pattern: instance Show PatternSetCharacterClass
- Text.Regex.TDFA.Pattern: instance Show PatternSetCollatingElement
- Text.Regex.TDFA.Pattern: instance Show PatternSetEquivalenceClass
- Text.Regex.TDFA.Pattern: unSCC :: PatternSetCharacterClass -> String
- Text.Regex.TDFA.Pattern: unSCE :: PatternSetCollatingElement -> String
- Text.Regex.TDFA.Pattern: unSEC :: PatternSetEquivalenceClass -> String
- Text.Regex.TDFA.Sequence: instance RegexContext Regex (Seq Char) (Seq Char)
- Text.Regex.TDFA.Sequence: instance RegexLike Regex (Seq Char)
- Text.Regex.TDFA.Sequence: instance RegexMaker Regex CompOption ExecOption (Seq Char)
- Text.Regex.TDFA.String: instance RegexContext Regex String String
- Text.Regex.TDFA.String: instance RegexLike Regex String
- Text.Regex.TDFA.String: instance RegexMaker Regex CompOption ExecOption String
- Text.Regex.TDFA.TDFA: d_dt :: DFA -> DT
- Text.Regex.TDFA.TDFA: d_id :: DFA -> SetIndex
- Text.Regex.TDFA.TDFA: dt_a :: DT -> DT
- Text.Regex.TDFA.TDFA: dt_b :: DT -> DT
- Text.Regex.TDFA.TDFA: dt_dopas :: DT -> EnumSet DoPa
- Text.Regex.TDFA.TDFA: dt_other :: DT -> Transition
- Text.Regex.TDFA.TDFA: dt_test :: DT -> WhichTest
- Text.Regex.TDFA.TDFA: dt_trans :: DT -> CharMap Transition
- Text.Regex.TDFA.TDFA: dt_win :: DT -> IntMap Instructions
- Text.Regex.TDFA.TDFA: instance Show AlterOrbit
- Text.Regex.TDFA.TNFA: q_id :: QNFA -> Index
- Text.Regex.TDFA.TNFA: q_qt :: QNFA -> QT
- Text.Regex.TDFA.TNFA: qt_a :: QT -> QT
- Text.Regex.TDFA.TNFA: qt_b :: QT -> QT
- Text.Regex.TDFA.TNFA: qt_dopas :: QT -> EnumSet DoPa
- Text.Regex.TDFA.TNFA: qt_other :: QT -> QTrans
- Text.Regex.TDFA.TNFA: qt_test :: QT -> WhichTest
- Text.Regex.TDFA.TNFA: qt_trans :: QT -> CharMap QTrans
- Text.Regex.TDFA.TNFA: qt_win :: QT -> WinTags
+ Data.IntMap.CharMap2: [unCharMap] :: CharMap a -> IntMap a
+ Data.IntMap.CharMap2: instance GHC.Base.Functor Data.IntMap.CharMap2.CharMap
+ Data.IntMap.CharMap2: instance GHC.Base.Monoid (Data.IntMap.CharMap2.CharMap a)
+ Data.IntMap.CharMap2: instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.IntMap.CharMap2.CharMap a)
+ Data.IntMap.CharMap2: instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.IntMap.CharMap2.CharMap a)
+ Data.IntMap.CharMap2: instance GHC.Read.Read a => GHC.Read.Read (Data.IntMap.CharMap2.CharMap a)
+ Data.IntMap.CharMap2: instance GHC.Show.Show a => GHC.Show.Show (Data.IntMap.CharMap2.CharMap a)
+ Data.IntMap.EnumMap2: [unEnumMap] :: EnumMap k a -> IntMap a
+ Data.IntMap.EnumMap2: instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.IntMap.EnumMap2.EnumMap k a)
+ Data.IntMap.EnumMap2: instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.IntMap.EnumMap2.EnumMap k a)
+ Data.IntMap.EnumMap2: instance GHC.Classes.Ord k => Data.Foldable.Foldable (Data.IntMap.EnumMap2.EnumMap k)
+ Data.IntMap.EnumMap2: instance GHC.Classes.Ord k => GHC.Base.Functor (Data.IntMap.EnumMap2.EnumMap k)
+ Data.IntMap.EnumMap2: instance GHC.Classes.Ord k => GHC.Base.Monoid (Data.IntMap.EnumMap2.EnumMap k a)
+ Data.IntMap.EnumMap2: instance GHC.Read.Read a => GHC.Read.Read (Data.IntMap.EnumMap2.EnumMap k a)
+ Data.IntMap.EnumMap2: instance GHC.Show.Show a => GHC.Show.Show (Data.IntMap.EnumMap2.EnumMap k a)
+ Data.IntSet.EnumSet2: [unEnumSet] :: EnumSet e -> IntSet
+ Data.IntSet.EnumSet2: instance GHC.Base.Monoid (Data.IntSet.EnumSet2.EnumSet e)
+ Data.IntSet.EnumSet2: instance GHC.Classes.Eq (Data.IntSet.EnumSet2.EnumSet e)
+ Data.IntSet.EnumSet2: instance GHC.Classes.Ord (Data.IntSet.EnumSet2.EnumSet e)
+ Data.IntSet.EnumSet2: instance GHC.Read.Read (Data.IntSet.EnumSet2.EnumSet e)
+ Data.IntSet.EnumSet2: instance GHC.Show.Show (Data.IntSet.EnumSet2.EnumSet e)
+ Text.Regex.TDFA.ByteString: instance Text.Regex.Base.RegexLike.RegexContext Text.Regex.TDFA.Common.Regex Data.ByteString.Internal.ByteString Data.ByteString.Internal.ByteString
+ Text.Regex.TDFA.ByteString: instance Text.Regex.Base.RegexLike.RegexLike Text.Regex.TDFA.Common.Regex Data.ByteString.Internal.ByteString
+ Text.Regex.TDFA.ByteString: instance Text.Regex.Base.RegexLike.RegexMaker Text.Regex.TDFA.Common.Regex Text.Regex.TDFA.Common.CompOption Text.Regex.TDFA.Common.ExecOption Data.ByteString.Internal.ByteString
+ Text.Regex.TDFA.ByteString.Lazy: instance Text.Regex.Base.RegexLike.RegexContext Text.Regex.TDFA.Common.Regex Data.ByteString.Lazy.Internal.ByteString Data.ByteString.Lazy.Internal.ByteString
+ Text.Regex.TDFA.ByteString.Lazy: instance Text.Regex.Base.RegexLike.RegexLike Text.Regex.TDFA.Common.Regex Data.ByteString.Lazy.Internal.ByteString
+ Text.Regex.TDFA.ByteString.Lazy: instance Text.Regex.Base.RegexLike.RegexMaker Text.Regex.TDFA.Common.Regex Text.Regex.TDFA.Common.CompOption Text.Regex.TDFA.Common.ExecOption Data.ByteString.Lazy.Internal.ByteString
+ Text.Regex.TDFA.Common: [basePos] :: Orbits -> Position
+ Text.Regex.TDFA.Common: [captureGroups] :: ExecOption -> Bool
+ Text.Regex.TDFA.Common: [caseSensitive] :: CompOption -> Bool
+ Text.Regex.TDFA.Common: [d_dt] :: DFA -> DT
+ Text.Regex.TDFA.Common: [d_id] :: DFA -> SetIndex
+ Text.Regex.TDFA.Common: [dopaIndex] :: DoPa -> Int
+ Text.Regex.TDFA.Common: [dt_a, dt_b] :: DT -> DT
+ Text.Regex.TDFA.Common: [dt_dopas] :: DT -> EnumSet DoPa
+ Text.Regex.TDFA.Common: [dt_other] :: DT -> Transition
+ Text.Regex.TDFA.Common: [dt_test] :: DT -> WhichTest
+ Text.Regex.TDFA.Common: [dt_trans] :: DT -> CharMap Transition
+ Text.Regex.TDFA.Common: [dt_win] :: DT -> IntMap Instructions
+ Text.Regex.TDFA.Common: [getOrbits] :: Orbits -> !(Seq Position)
+ Text.Regex.TDFA.Common: [inOrbit] :: Orbits -> !Bool
+ Text.Regex.TDFA.Common: [lastStarGreedy] :: CompOption -> Bool
+ Text.Regex.TDFA.Common: [multiline] :: CompOption -> Bool
+ Text.Regex.TDFA.Common: [newOrbits] :: Instructions -> !(Maybe (Position -> OrbitTransformer))
+ Text.Regex.TDFA.Common: [newPos] :: Instructions -> ![(Tag, Action)]
+ Text.Regex.TDFA.Common: [newSyntax] :: CompOption -> Bool
+ Text.Regex.TDFA.Common: [ordinal] :: Orbits -> (Maybe Int)
+ Text.Regex.TDFA.Common: [q_id] :: QNFA -> Index
+ Text.Regex.TDFA.Common: [q_qt] :: QNFA -> QT
+ Text.Regex.TDFA.Common: [qt_a, qt_b] :: QT -> QT
+ Text.Regex.TDFA.Common: [qt_dopas] :: QT -> EnumSet DoPa
+ Text.Regex.TDFA.Common: [qt_other] :: QT -> QTrans
+ Text.Regex.TDFA.Common: [qt_test] :: QT -> WhichTest
+ Text.Regex.TDFA.Common: [qt_trans] :: QT -> CharMap QTrans
+ Text.Regex.TDFA.Common: [qt_win] :: QT -> WinTags
+ Text.Regex.TDFA.Common: [regex_b_index] :: Regex -> (Index, Index)
+ Text.Regex.TDFA.Common: [regex_b_tags] :: Regex -> (Tag, Tag)
+ Text.Regex.TDFA.Common: [regex_compOptions] :: Regex -> CompOption
+ Text.Regex.TDFA.Common: [regex_dfa] :: Regex -> DFA
+ Text.Regex.TDFA.Common: [regex_execOptions] :: Regex -> ExecOption
+ Text.Regex.TDFA.Common: [regex_groups] :: Regex -> Array GroupIndex [GroupInfo]
+ Text.Regex.TDFA.Common: [regex_init] :: Regex -> Index
+ Text.Regex.TDFA.Common: [regex_isFrontAnchored] :: Regex -> Bool
+ Text.Regex.TDFA.Common: [regex_tags] :: Regex -> Array Tag OP
+ Text.Regex.TDFA.Common: [regex_trie] :: Regex -> TrieSet DFA
+ Text.Regex.TDFA.Common: [rightAssoc] :: CompOption -> Bool
+ Text.Regex.TDFA.Common: [startTag, stopTag, flagTag] :: GroupInfo -> Tag
+ Text.Regex.TDFA.Common: [thisIndex, parentIndex] :: GroupInfo -> GroupIndex
+ Text.Regex.TDFA.Common: [trans_how] :: Transition -> DTrans
+ Text.Regex.TDFA.Common: [trans_many] :: Transition -> DFA
+ Text.Regex.TDFA.Common: [trans_single] :: Transition -> DFA
+ Text.Regex.TDFA.Common: instance GHC.Classes.Eq Text.Regex.TDFA.Common.Action
+ Text.Regex.TDFA.Common: instance GHC.Classes.Eq Text.Regex.TDFA.Common.DoPa
+ Text.Regex.TDFA.Common: instance GHC.Classes.Eq Text.Regex.TDFA.Common.OP
+ Text.Regex.TDFA.Common: instance GHC.Classes.Eq Text.Regex.TDFA.Common.QT
+ Text.Regex.TDFA.Common: instance GHC.Classes.Eq Text.Regex.TDFA.Common.TagTask
+ Text.Regex.TDFA.Common: instance GHC.Classes.Eq Text.Regex.TDFA.Common.TagUpdate
+ Text.Regex.TDFA.Common: instance GHC.Classes.Eq Text.Regex.TDFA.Common.WhichTest
+ Text.Regex.TDFA.Common: instance GHC.Classes.Ord Text.Regex.TDFA.Common.DoPa
+ Text.Regex.TDFA.Common: instance GHC.Classes.Ord Text.Regex.TDFA.Common.WhichTest
+ Text.Regex.TDFA.Common: instance GHC.Enum.Enum Text.Regex.TDFA.Common.DoPa
+ Text.Regex.TDFA.Common: instance GHC.Enum.Enum Text.Regex.TDFA.Common.WhichTest
+ Text.Regex.TDFA.Common: instance GHC.Read.Read Text.Regex.TDFA.Common.CompOption
+ Text.Regex.TDFA.Common: instance GHC.Read.Read Text.Regex.TDFA.Common.ExecOption
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.Action
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.CompOption
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.DFA
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.DT
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.DoPa
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.ExecOption
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.GroupInfo
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.Instructions
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.OP
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.Orbits
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.QNFA
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.QT
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.TagTask
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.TagUpdate
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.WhichTest
+ Text.Regex.TDFA.Common: instance GHC.Show.Show Text.Regex.TDFA.Common.WinEmpty
+ Text.Regex.TDFA.Common: instance Text.Regex.Base.RegexLike.RegexOptions Text.Regex.TDFA.Common.Regex Text.Regex.TDFA.Common.CompOption Text.Regex.TDFA.Common.ExecOption
+ Text.Regex.TDFA.CorePattern: [childGroups] :: Q -> Bool
+ Text.Regex.TDFA.CorePattern: [firstNull] :: P -> Bool
+ Text.Regex.TDFA.CorePattern: [getOrbit] :: P -> Maybe Tag
+ Text.Regex.TDFA.CorePattern: [getTests] :: SetTestInfo -> EnumMap WhichTest (EnumSet DoPa)
+ Text.Regex.TDFA.CorePattern: [nullQ] :: Q -> NullView
+ Text.Regex.TDFA.CorePattern: [postSet] :: Q -> [Tag]
+ Text.Regex.TDFA.CorePattern: [preReset] :: Q -> [Tag]
+ Text.Regex.TDFA.CorePattern: [preTag, postTag] :: Q -> Maybe Tag
+ Text.Regex.TDFA.CorePattern: [resetOrbits] :: P -> [Tag]
+ Text.Regex.TDFA.CorePattern: [tagged] :: Q -> Bool
+ Text.Regex.TDFA.CorePattern: [takes] :: Q -> (Position, Maybe Position)
+ Text.Regex.TDFA.CorePattern: [unQ] :: Q -> P
+ Text.Regex.TDFA.CorePattern: [unStar] :: P -> Q
+ Text.Regex.TDFA.CorePattern: [wants] :: Q -> Wanted
+ Text.Regex.TDFA.CorePattern: instance GHC.Base.Monoid Text.Regex.TDFA.CorePattern.SetTestInfo
+ Text.Regex.TDFA.CorePattern: instance GHC.Classes.Eq Text.Regex.TDFA.CorePattern.P
+ Text.Regex.TDFA.CorePattern: instance GHC.Classes.Eq Text.Regex.TDFA.CorePattern.Q
+ Text.Regex.TDFA.CorePattern: instance GHC.Classes.Eq Text.Regex.TDFA.CorePattern.SetTestInfo
+ Text.Regex.TDFA.CorePattern: instance GHC.Classes.Eq Text.Regex.TDFA.CorePattern.Wanted
+ Text.Regex.TDFA.CorePattern: instance GHC.Show.Show Text.Regex.TDFA.CorePattern.HandleTag
+ Text.Regex.TDFA.CorePattern: instance GHC.Show.Show Text.Regex.TDFA.CorePattern.P
+ Text.Regex.TDFA.CorePattern: instance GHC.Show.Show Text.Regex.TDFA.CorePattern.Q
+ Text.Regex.TDFA.CorePattern: instance GHC.Show.Show Text.Regex.TDFA.CorePattern.SetTestInfo
+ Text.Regex.TDFA.CorePattern: instance GHC.Show.Show Text.Regex.TDFA.CorePattern.Wanted
+ Text.Regex.TDFA.IntArrTrieSet: [next] :: TrieSet v -> Array Int (TrieSet v)
+ Text.Regex.TDFA.IntArrTrieSet: [value] :: TrieSet v -> v
+ Text.Regex.TDFA.NewDFA.Engine_NC: instance GHC.Show.Show Text.Regex.TDFA.NewDFA.Engine_NC.WScratch
+ Text.Regex.TDFA.NewDFA.Uncons: instance Text.Regex.TDFA.NewDFA.Uncons.Uncons (Data.Sequence.Seq GHC.Types.Char)
+ Text.Regex.TDFA.NewDFA.Uncons: instance Text.Regex.TDFA.NewDFA.Uncons.Uncons Data.ByteString.Internal.ByteString
+ Text.Regex.TDFA.NewDFA.Uncons: instance Text.Regex.TDFA.NewDFA.Uncons.Uncons Data.ByteString.Lazy.Internal.ByteString
+ Text.Regex.TDFA.NewDFA.Uncons: instance Text.Regex.TDFA.NewDFA.Uncons.Uncons [GHC.Types.Char]
+ Text.Regex.TDFA.Pattern: [dopaIndex] :: DoPa -> Int
+ Text.Regex.TDFA.Pattern: [getDoPa] :: Pattern -> DoPa
+ Text.Regex.TDFA.Pattern: [getPatternChar] :: Pattern -> Char
+ Text.Regex.TDFA.Pattern: [getPatternSet] :: Pattern -> PatternSet
+ Text.Regex.TDFA.Pattern: [unSCC] :: PatternSetCharacterClass -> String
+ Text.Regex.TDFA.Pattern: [unSCE] :: PatternSetCollatingElement -> String
+ Text.Regex.TDFA.Pattern: [unSEC] :: PatternSetEquivalenceClass -> String
+ Text.Regex.TDFA.Pattern: instance GHC.Classes.Eq Text.Regex.TDFA.Pattern.Pattern
+ Text.Regex.TDFA.Pattern: instance GHC.Classes.Eq Text.Regex.TDFA.Pattern.PatternSet
+ Text.Regex.TDFA.Pattern: instance GHC.Classes.Eq Text.Regex.TDFA.Pattern.PatternSetCharacterClass
+ Text.Regex.TDFA.Pattern: instance GHC.Classes.Eq Text.Regex.TDFA.Pattern.PatternSetCollatingElement
+ Text.Regex.TDFA.Pattern: instance GHC.Classes.Eq Text.Regex.TDFA.Pattern.PatternSetEquivalenceClass
+ Text.Regex.TDFA.Pattern: instance GHC.Classes.Ord Text.Regex.TDFA.Pattern.PatternSetCharacterClass
+ Text.Regex.TDFA.Pattern: instance GHC.Classes.Ord Text.Regex.TDFA.Pattern.PatternSetCollatingElement
+ Text.Regex.TDFA.Pattern: instance GHC.Classes.Ord Text.Regex.TDFA.Pattern.PatternSetEquivalenceClass
+ Text.Regex.TDFA.Pattern: instance GHC.Show.Show Text.Regex.TDFA.Pattern.Pattern
+ Text.Regex.TDFA.Pattern: instance GHC.Show.Show Text.Regex.TDFA.Pattern.PatternSet
+ Text.Regex.TDFA.Pattern: instance GHC.Show.Show Text.Regex.TDFA.Pattern.PatternSetCharacterClass
+ Text.Regex.TDFA.Pattern: instance GHC.Show.Show Text.Regex.TDFA.Pattern.PatternSetCollatingElement
+ Text.Regex.TDFA.Pattern: instance GHC.Show.Show Text.Regex.TDFA.Pattern.PatternSetEquivalenceClass
+ Text.Regex.TDFA.Sequence: instance Text.Regex.Base.RegexLike.RegexContext Text.Regex.TDFA.Common.Regex (Data.Sequence.Seq GHC.Types.Char) (Data.Sequence.Seq GHC.Types.Char)
+ Text.Regex.TDFA.Sequence: instance Text.Regex.Base.RegexLike.RegexLike Text.Regex.TDFA.Common.Regex (Data.Sequence.Seq GHC.Types.Char)
+ Text.Regex.TDFA.Sequence: instance Text.Regex.Base.RegexLike.RegexMaker Text.Regex.TDFA.Common.Regex Text.Regex.TDFA.Common.CompOption Text.Regex.TDFA.Common.ExecOption (Data.Sequence.Seq GHC.Types.Char)
+ Text.Regex.TDFA.String: instance Text.Regex.Base.RegexLike.RegexContext Text.Regex.TDFA.Common.Regex GHC.Base.String GHC.Base.String
+ Text.Regex.TDFA.String: instance Text.Regex.Base.RegexLike.RegexLike Text.Regex.TDFA.Common.Regex GHC.Base.String
+ Text.Regex.TDFA.String: instance Text.Regex.Base.RegexLike.RegexMaker Text.Regex.TDFA.Common.Regex Text.Regex.TDFA.Common.CompOption Text.Regex.TDFA.Common.ExecOption GHC.Base.String
+ Text.Regex.TDFA.TDFA: [d_dt] :: DFA -> DT
+ Text.Regex.TDFA.TDFA: [d_id] :: DFA -> SetIndex
+ Text.Regex.TDFA.TDFA: [dt_a, dt_b] :: DT -> DT
+ Text.Regex.TDFA.TDFA: [dt_dopas] :: DT -> EnumSet DoPa
+ Text.Regex.TDFA.TDFA: [dt_other] :: DT -> Transition
+ Text.Regex.TDFA.TDFA: [dt_test] :: DT -> WhichTest
+ Text.Regex.TDFA.TDFA: [dt_trans] :: DT -> CharMap Transition
+ Text.Regex.TDFA.TDFA: [dt_win] :: DT -> IntMap Instructions
+ Text.Regex.TDFA.TDFA: instance GHC.Show.Show Text.Regex.TDFA.TDFA.AlterOrbit
+ Text.Regex.TDFA.TNFA: [q_id] :: QNFA -> Index
+ Text.Regex.TDFA.TNFA: [q_qt] :: QNFA -> QT
+ Text.Regex.TDFA.TNFA: [qt_a, qt_b] :: QT -> QT
+ Text.Regex.TDFA.TNFA: [qt_dopas] :: QT -> EnumSet DoPa
+ Text.Regex.TDFA.TNFA: [qt_other] :: QT -> QTrans
+ Text.Regex.TDFA.TNFA: [qt_test] :: QT -> WhichTest
+ Text.Regex.TDFA.TNFA: [qt_trans] :: QT -> CharMap QTrans
+ Text.Regex.TDFA.TNFA: [qt_win] :: QT -> WinTags
- Data.IntMap.EnumMap2: (!) :: Enum key => EnumMap key a -> key -> a
+ Data.IntMap.EnumMap2: (!) :: (Enum key) => EnumMap key a -> key -> a
- Data.IntMap.EnumMap2: (\\) :: Enum key => EnumMap key a -> EnumMap key b -> EnumMap key a
+ Data.IntMap.EnumMap2: (\\) :: (Enum key) => EnumMap key a -> EnumMap key b -> EnumMap key a
- Data.IntMap.EnumMap2: adjust :: Enum key => (a -> a) -> key -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: adjust :: (Enum key) => (a -> a) -> key -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: adjustWithKey :: Enum key => (key -> a -> a) -> key -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: adjustWithKey :: (Enum key) => (key -> a -> a) -> key -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: assocs :: Enum key => EnumMap key a -> [(key, a)]
+ Data.IntMap.EnumMap2: assocs :: (Enum key) => EnumMap key a -> [(key, a)]
- Data.IntMap.EnumMap2: delete :: Enum key => key -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: delete :: (Enum key) => key -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: difference :: Enum key => EnumMap key a -> EnumMap key b -> EnumMap key a
+ Data.IntMap.EnumMap2: difference :: (Enum key) => EnumMap key a -> EnumMap key b -> EnumMap key a
- Data.IntMap.EnumMap2: differenceWith :: Enum key => (a -> b -> Maybe a) -> EnumMap key a -> EnumMap key b -> EnumMap key a
+ Data.IntMap.EnumMap2: differenceWith :: (Enum key) => (a -> b -> Maybe a) -> EnumMap key a -> EnumMap key b -> EnumMap key a
- Data.IntMap.EnumMap2: differenceWithKey :: Enum key => (key -> a -> b -> Maybe a) -> EnumMap key a -> EnumMap key b -> EnumMap key a
+ Data.IntMap.EnumMap2: differenceWithKey :: (Enum key) => (key -> a -> b -> Maybe a) -> EnumMap key a -> EnumMap key b -> EnumMap key a
- Data.IntMap.EnumMap2: elems :: Enum key => EnumMap key a -> [a]
+ Data.IntMap.EnumMap2: elems :: (Enum key) => EnumMap key a -> [a]
- Data.IntMap.EnumMap2: empty :: Enum key => EnumMap key a
+ Data.IntMap.EnumMap2: empty :: (Enum key) => EnumMap key a
- Data.IntMap.EnumMap2: filter :: Enum key => (a -> Bool) -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: filter :: (Enum key) => (a -> Bool) -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: filterWithKey :: Enum key => (key -> a -> Bool) -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: filterWithKey :: (Enum key) => (key -> a -> Bool) -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: findWithDefault :: Enum key => a -> key -> EnumMap key a -> a
+ Data.IntMap.EnumMap2: findWithDefault :: (Enum key) => a -> key -> EnumMap key a -> a
- Data.IntMap.EnumMap2: fold :: Enum key => (a -> b -> b) -> b -> EnumMap key a -> b
+ Data.IntMap.EnumMap2: fold :: (Enum key) => (a -> b -> b) -> b -> EnumMap key a -> b
- Data.IntMap.EnumMap2: foldWithKey :: Enum key => (key -> a -> b -> b) -> b -> EnumMap key a -> b
+ Data.IntMap.EnumMap2: foldWithKey :: (Enum key) => (key -> a -> b -> b) -> b -> EnumMap key a -> b
- Data.IntMap.EnumMap2: fromAscList :: Enum key => [(key, a)] -> EnumMap key a
+ Data.IntMap.EnumMap2: fromAscList :: (Enum key) => [(key, a)] -> EnumMap key a
- Data.IntMap.EnumMap2: fromAscListWith :: Enum key => (a -> a -> a) -> [(key, a)] -> EnumMap key a
+ Data.IntMap.EnumMap2: fromAscListWith :: (Enum key) => (a -> a -> a) -> [(key, a)] -> EnumMap key a
- Data.IntMap.EnumMap2: fromAscListWithKey :: Enum key => (key -> a -> a -> a) -> [(key, a)] -> EnumMap key a
+ Data.IntMap.EnumMap2: fromAscListWithKey :: (Enum key) => (key -> a -> a -> a) -> [(key, a)] -> EnumMap key a
- Data.IntMap.EnumMap2: fromDistinctAscList :: Enum key => [(key, a)] -> EnumMap key a
+ Data.IntMap.EnumMap2: fromDistinctAscList :: (Enum key) => [(key, a)] -> EnumMap key a
- Data.IntMap.EnumMap2: fromList :: Enum key => [(key, a)] -> EnumMap key a
+ Data.IntMap.EnumMap2: fromList :: (Enum key) => [(key, a)] -> EnumMap key a
- Data.IntMap.EnumMap2: fromListWith :: Enum key => (a -> a -> a) -> [(key, a)] -> EnumMap key a
+ Data.IntMap.EnumMap2: fromListWith :: (Enum key) => (a -> a -> a) -> [(key, a)] -> EnumMap key a
- Data.IntMap.EnumMap2: fromListWithKey :: Enum key => (key -> a -> a -> a) -> [(key, a)] -> EnumMap key a
+ Data.IntMap.EnumMap2: fromListWithKey :: (Enum key) => (key -> a -> a -> a) -> [(key, a)] -> EnumMap key a
- Data.IntMap.EnumMap2: insert :: Enum key => key -> a -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: insert :: (Enum key) => key -> a -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: insertLookupWithKey :: Enum key => (key -> a -> a -> a) -> key -> a -> EnumMap key a -> (Maybe a, EnumMap key a)
+ Data.IntMap.EnumMap2: insertLookupWithKey :: (Enum key) => (key -> a -> a -> a) -> key -> a -> EnumMap key a -> (Maybe a, EnumMap key a)
- Data.IntMap.EnumMap2: insertWith :: Enum key => (a -> a -> a) -> key -> a -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: insertWith :: (Enum key) => (a -> a -> a) -> key -> a -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: insertWithKey :: Enum key => (key -> a -> a -> a) -> key -> a -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: insertWithKey :: (Enum key) => (key -> a -> a -> a) -> key -> a -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: intersection :: Enum key => EnumMap key a -> EnumMap key b -> EnumMap key a
+ Data.IntMap.EnumMap2: intersection :: (Enum key) => EnumMap key a -> EnumMap key b -> EnumMap key a
- Data.IntMap.EnumMap2: intersectionWith :: Enum key => (a -> b -> a) -> EnumMap key a -> EnumMap key b -> EnumMap key a
+ Data.IntMap.EnumMap2: intersectionWith :: (Enum key) => (a -> b -> a) -> EnumMap key a -> EnumMap key b -> EnumMap key a
- Data.IntMap.EnumMap2: intersectionWithKey :: Enum key => (key -> a -> b -> a) -> EnumMap key a -> EnumMap key b -> EnumMap key a
+ Data.IntMap.EnumMap2: intersectionWithKey :: (Enum key) => (key -> a -> b -> a) -> EnumMap key a -> EnumMap key b -> EnumMap key a
- Data.IntMap.EnumMap2: isProperSubmapOfBy :: Enum key => (a -> b -> Bool) -> EnumMap key a -> EnumMap key b -> Bool
+ Data.IntMap.EnumMap2: isProperSubmapOfBy :: (Enum key) => (a -> b -> Bool) -> EnumMap key a -> EnumMap key b -> Bool
- Data.IntMap.EnumMap2: isSubmapOfBy :: Enum key => (a -> b -> Bool) -> EnumMap key a -> EnumMap key b -> Bool
+ Data.IntMap.EnumMap2: isSubmapOfBy :: (Enum key) => (a -> b -> Bool) -> EnumMap key a -> EnumMap key b -> Bool
- Data.IntMap.EnumMap2: keys :: Enum key => EnumMap key a -> [key]
+ Data.IntMap.EnumMap2: keys :: (Enum key) => EnumMap key a -> [key]
- Data.IntMap.EnumMap2: keysSet :: Enum key => EnumMap key a -> EnumSet key
+ Data.IntMap.EnumMap2: keysSet :: (Enum key) => EnumMap key a -> EnumSet key
- Data.IntMap.EnumMap2: lookup :: Enum key => key -> EnumMap key a -> Maybe a
+ Data.IntMap.EnumMap2: lookup :: (Enum key) => key -> EnumMap key a -> Maybe a
- Data.IntMap.EnumMap2: map :: Enum key => (a -> b) -> EnumMap key a -> EnumMap key b
+ Data.IntMap.EnumMap2: map :: (Enum key) => (a -> b) -> EnumMap key a -> EnumMap key b
- Data.IntMap.EnumMap2: mapAccum :: Enum key => (a -> b -> (a, c)) -> a -> EnumMap key b -> (a, EnumMap key c)
+ Data.IntMap.EnumMap2: mapAccum :: (Enum key) => (a -> b -> (a, c)) -> a -> EnumMap key b -> (a, EnumMap key c)
- Data.IntMap.EnumMap2: mapAccumWithKey :: Enum key => (a -> key -> b -> (a, c)) -> a -> EnumMap key b -> (a, EnumMap key c)
+ Data.IntMap.EnumMap2: mapAccumWithKey :: (Enum key) => (a -> key -> b -> (a, c)) -> a -> EnumMap key b -> (a, EnumMap key c)
- Data.IntMap.EnumMap2: mapEither :: Enum key => (a -> Either b c) -> EnumMap key a -> (EnumMap key b, EnumMap key c)
+ Data.IntMap.EnumMap2: mapEither :: (Enum key) => (a -> Either b c) -> EnumMap key a -> (EnumMap key b, EnumMap key c)
- Data.IntMap.EnumMap2: mapEitherWithKey :: Enum key => (key -> a -> Either b c) -> EnumMap key a -> (EnumMap key b, EnumMap key c)
+ Data.IntMap.EnumMap2: mapEitherWithKey :: (Enum key) => (key -> a -> Either b c) -> EnumMap key a -> (EnumMap key b, EnumMap key c)
- Data.IntMap.EnumMap2: mapMaybe :: Enum key => (a -> Maybe b) -> EnumMap key a -> EnumMap key b
+ Data.IntMap.EnumMap2: mapMaybe :: (Enum key) => (a -> Maybe b) -> EnumMap key a -> EnumMap key b
- Data.IntMap.EnumMap2: mapMaybeWithKey :: Enum key => (key -> a -> Maybe b) -> EnumMap key a -> EnumMap key b
+ Data.IntMap.EnumMap2: mapMaybeWithKey :: (Enum key) => (key -> a -> Maybe b) -> EnumMap key a -> EnumMap key b
- Data.IntMap.EnumMap2: mapWithKey :: Enum key => (key -> a -> b) -> EnumMap key a -> EnumMap key b
+ Data.IntMap.EnumMap2: mapWithKey :: (Enum key) => (key -> a -> b) -> EnumMap key a -> EnumMap key b
- Data.IntMap.EnumMap2: member :: Enum key => key -> EnumMap key a -> Bool
+ Data.IntMap.EnumMap2: member :: (Enum key) => key -> EnumMap key a -> Bool
- Data.IntMap.EnumMap2: notMember :: Enum key => key -> EnumMap key a -> Bool
+ Data.IntMap.EnumMap2: notMember :: (Enum key) => key -> EnumMap key a -> Bool
- Data.IntMap.EnumMap2: null :: Enum key => EnumMap key a -> Bool
+ Data.IntMap.EnumMap2: null :: (Enum key) => EnumMap key a -> Bool
- Data.IntMap.EnumMap2: partition :: Enum key => (a -> Bool) -> EnumMap key a -> (EnumMap key a, EnumMap key a)
+ Data.IntMap.EnumMap2: partition :: (Enum key) => (a -> Bool) -> EnumMap key a -> (EnumMap key a, EnumMap key a)
- Data.IntMap.EnumMap2: partitionWithKey :: Enum key => (key -> a -> Bool) -> EnumMap key a -> (EnumMap key a, EnumMap key a)
+ Data.IntMap.EnumMap2: partitionWithKey :: (Enum key) => (key -> a -> Bool) -> EnumMap key a -> (EnumMap key a, EnumMap key a)
- Data.IntMap.EnumMap2: singleton :: Enum key => key -> a -> EnumMap key a
+ Data.IntMap.EnumMap2: singleton :: (Enum key) => key -> a -> EnumMap key a
- Data.IntMap.EnumMap2: size :: Enum key => EnumMap key a -> Int
+ Data.IntMap.EnumMap2: size :: (Enum key) => EnumMap key a -> Int
- Data.IntMap.EnumMap2: split :: Enum key => key -> EnumMap key a -> (EnumMap key a, EnumMap key a)
+ Data.IntMap.EnumMap2: split :: (Enum key) => key -> EnumMap key a -> (EnumMap key a, EnumMap key a)
- Data.IntMap.EnumMap2: splitLookup :: Enum key => key -> EnumMap key a -> (EnumMap key a, Maybe a, EnumMap key a)
+ Data.IntMap.EnumMap2: splitLookup :: (Enum key) => key -> EnumMap key a -> (EnumMap key a, Maybe a, EnumMap key a)
- Data.IntMap.EnumMap2: toAscList :: Enum key => EnumMap key a -> [(key, a)]
+ Data.IntMap.EnumMap2: toAscList :: (Enum key) => EnumMap key a -> [(key, a)]
- Data.IntMap.EnumMap2: toList :: Enum key => EnumMap key a -> [(key, a)]
+ Data.IntMap.EnumMap2: toList :: (Enum key) => EnumMap key a -> [(key, a)]
- Data.IntMap.EnumMap2: union :: Enum key => EnumMap key a -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: union :: (Enum key) => EnumMap key a -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: unionWith :: Enum key => (a -> a -> a) -> EnumMap key a -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: unionWith :: (Enum key) => (a -> a -> a) -> EnumMap key a -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: unionWithKey :: Enum key => (key -> a -> a -> a) -> EnumMap key a -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: unionWithKey :: (Enum key) => (key -> a -> a -> a) -> EnumMap key a -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: unions :: Enum key => [EnumMap key a] -> EnumMap key a
+ Data.IntMap.EnumMap2: unions :: (Enum key) => [EnumMap key a] -> EnumMap key a
- Data.IntMap.EnumMap2: unionsWith :: Enum key => (a -> a -> a) -> [EnumMap key a] -> EnumMap key a
+ Data.IntMap.EnumMap2: unionsWith :: (Enum key) => (a -> a -> a) -> [EnumMap key a] -> EnumMap key a
- Data.IntMap.EnumMap2: update :: Enum key => (a -> Maybe a) -> key -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: update :: (Enum key) => (a -> Maybe a) -> key -> EnumMap key a -> EnumMap key a
- Data.IntMap.EnumMap2: updateLookupWithKey :: Enum key => (key -> a -> Maybe a) -> key -> EnumMap key a -> (Maybe a, EnumMap key a)
+ Data.IntMap.EnumMap2: updateLookupWithKey :: (Enum key) => (key -> a -> Maybe a) -> key -> EnumMap key a -> (Maybe a, EnumMap key a)
- Data.IntMap.EnumMap2: updateWithKey :: Enum key => (key -> a -> Maybe a) -> key -> EnumMap key a -> EnumMap key a
+ Data.IntMap.EnumMap2: updateWithKey :: (Enum key) => (key -> a -> Maybe a) -> key -> EnumMap key a -> EnumMap key a
- Data.IntSet.EnumSet2: (\\) :: Enum e => EnumSet e -> EnumSet e -> EnumSet e
+ Data.IntSet.EnumSet2: (\\) :: (Enum e) => EnumSet e -> EnumSet e -> EnumSet e
- Data.IntSet.EnumSet2: delete :: Enum e => e -> EnumSet e -> EnumSet e
+ Data.IntSet.EnumSet2: delete :: (Enum e) => e -> EnumSet e -> EnumSet e
- Data.IntSet.EnumSet2: difference :: Enum e => EnumSet e -> EnumSet e -> EnumSet e
+ Data.IntSet.EnumSet2: difference :: (Enum e) => EnumSet e -> EnumSet e -> EnumSet e
- Data.IntSet.EnumSet2: elems :: Enum e => EnumSet e -> [e]
+ Data.IntSet.EnumSet2: elems :: (Enum e) => EnumSet e -> [e]
- Data.IntSet.EnumSet2: empty :: Enum e => EnumSet e
+ Data.IntSet.EnumSet2: empty :: (Enum e) => EnumSet e
- Data.IntSet.EnumSet2: filter :: Enum e => (e -> Bool) -> EnumSet e -> EnumSet e
+ Data.IntSet.EnumSet2: filter :: (Enum e) => (e -> Bool) -> EnumSet e -> EnumSet e
- Data.IntSet.EnumSet2: fold :: Enum e => (e -> b -> b) -> b -> EnumSet e -> b
+ Data.IntSet.EnumSet2: fold :: (Enum e) => (e -> b -> b) -> b -> EnumSet e -> b
- Data.IntSet.EnumSet2: fromAscList :: Enum e => [e] -> EnumSet e
+ Data.IntSet.EnumSet2: fromAscList :: (Enum e) => [e] -> EnumSet e
- Data.IntSet.EnumSet2: fromDistinctAscList :: Enum e => [e] -> EnumSet e
+ Data.IntSet.EnumSet2: fromDistinctAscList :: (Enum e) => [e] -> EnumSet e
- Data.IntSet.EnumSet2: fromList :: Enum e => [e] -> EnumSet e
+ Data.IntSet.EnumSet2: fromList :: (Enum e) => [e] -> EnumSet e
- Data.IntSet.EnumSet2: insert :: Enum e => e -> EnumSet e -> EnumSet e
+ Data.IntSet.EnumSet2: insert :: (Enum e) => e -> EnumSet e -> EnumSet e
- Data.IntSet.EnumSet2: intersection :: Enum e => EnumSet e -> EnumSet e -> EnumSet e
+ Data.IntSet.EnumSet2: intersection :: (Enum e) => EnumSet e -> EnumSet e -> EnumSet e
- Data.IntSet.EnumSet2: isProperSubsetOf :: Enum e => EnumSet e -> EnumSet e -> Bool
+ Data.IntSet.EnumSet2: isProperSubsetOf :: (Enum e) => EnumSet e -> EnumSet e -> Bool
- Data.IntSet.EnumSet2: isSubsetOf :: Enum e => EnumSet e -> EnumSet e -> Bool
+ Data.IntSet.EnumSet2: isSubsetOf :: (Enum e) => EnumSet e -> EnumSet e -> Bool
- Data.IntSet.EnumSet2: map :: Enum e => (e -> e) -> EnumSet e -> EnumSet e
+ Data.IntSet.EnumSet2: map :: (Enum e) => (e -> e) -> EnumSet e -> EnumSet e
- Data.IntSet.EnumSet2: member :: Enum e => e -> EnumSet e -> Bool
+ Data.IntSet.EnumSet2: member :: (Enum e) => e -> EnumSet e -> Bool
- Data.IntSet.EnumSet2: notMember :: Enum e => Int -> EnumSet e -> Bool
+ Data.IntSet.EnumSet2: notMember :: (Enum e) => Int -> EnumSet e -> Bool
- Data.IntSet.EnumSet2: null :: Enum e => EnumSet e -> Bool
+ Data.IntSet.EnumSet2: null :: (Enum e) => EnumSet e -> Bool
- Data.IntSet.EnumSet2: partition :: Enum e => (e -> Bool) -> EnumSet e -> (EnumSet e, EnumSet e)
+ Data.IntSet.EnumSet2: partition :: (Enum e) => (e -> Bool) -> EnumSet e -> (EnumSet e, EnumSet e)
- Data.IntSet.EnumSet2: showTree :: Enum e => EnumSet e -> String
+ Data.IntSet.EnumSet2: showTree :: (Enum e) => EnumSet e -> String
- Data.IntSet.EnumSet2: showTreeWith :: Enum e => Bool -> Bool -> EnumSet e -> String
+ Data.IntSet.EnumSet2: showTreeWith :: (Enum e) => Bool -> Bool -> EnumSet e -> String
- Data.IntSet.EnumSet2: singleton :: Enum e => e -> EnumSet e
+ Data.IntSet.EnumSet2: singleton :: (Enum e) => e -> EnumSet e
- Data.IntSet.EnumSet2: size :: Enum e => EnumSet e -> Int
+ Data.IntSet.EnumSet2: size :: (Enum e) => EnumSet e -> Int
- Data.IntSet.EnumSet2: split :: Enum e => e -> EnumSet e -> (EnumSet e, EnumSet e)
+ Data.IntSet.EnumSet2: split :: (Enum e) => e -> EnumSet e -> (EnumSet e, EnumSet e)
- Data.IntSet.EnumSet2: splitMember :: Enum e => e -> EnumSet e -> (EnumSet e, Bool, EnumSet e)
+ Data.IntSet.EnumSet2: splitMember :: (Enum e) => e -> EnumSet e -> (EnumSet e, Bool, EnumSet e)
- Data.IntSet.EnumSet2: toAscList :: Enum e => EnumSet e -> [e]
+ Data.IntSet.EnumSet2: toAscList :: (Enum e) => EnumSet e -> [e]
- Data.IntSet.EnumSet2: toList :: Enum e => EnumSet e -> [e]
+ Data.IntSet.EnumSet2: toList :: (Enum e) => EnumSet e -> [e]
- Data.IntSet.EnumSet2: union :: Enum e => EnumSet e -> EnumSet e -> EnumSet e
+ Data.IntSet.EnumSet2: union :: (Enum e) => EnumSet e -> EnumSet e -> EnumSet e
- Data.IntSet.EnumSet2: unions :: Enum e => [EnumSet e] -> EnumSet e
+ Data.IntSet.EnumSet2: unions :: (Enum e) => [EnumSet e] -> EnumSet e
- Text.Regex.TDFA.Common: GroupInfo :: GroupIndex -> GroupIndex -> Tag -> Tag -> Tag -> GroupInfo
+ Text.Regex.TDFA.Common: GroupInfo :: GroupIndex -> Tag -> GroupInfo
- Text.Regex.TDFA.Common: Testing :: WhichTest -> EnumSet DoPa -> QT -> QT -> QT
+ Text.Regex.TDFA.Common: Testing :: WhichTest -> EnumSet DoPa -> QT -> QT
- Text.Regex.TDFA.Common: Testing' :: WhichTest -> EnumSet DoPa -> DT -> DT -> DT
+ Text.Regex.TDFA.Common: Testing' :: WhichTest -> EnumSet DoPa -> DT -> DT
- Text.Regex.TDFA.Common: mapFst :: Functor f => (t -> t2) -> f (t, t1) -> f (t2, t1)
+ Text.Regex.TDFA.Common: mapFst :: (Functor f) => (t -> t2) -> f (t, t1) -> f (t2, t1)
- Text.Regex.TDFA.Common: mapSnd :: Functor f => (t1 -> t2) -> f (t, t1) -> f (t, t2)
+ Text.Regex.TDFA.Common: mapSnd :: (Functor f) => (t1 -> t2) -> f (t, t1) -> f (t, t2)
- Text.Regex.TDFA.Common: norep :: Eq a => [a] -> [a]
+ Text.Regex.TDFA.Common: norep :: (Eq a) => [a] -> [a]
- Text.Regex.TDFA.CorePattern: Q :: NullView -> (Position, Maybe Position) -> [Tag] -> [Tag] -> Maybe Tag -> Maybe Tag -> Bool -> Bool -> Wanted -> P -> Q
+ Text.Regex.TDFA.CorePattern: Q :: NullView -> (Position, Maybe Position) -> [Tag] -> [Tag] -> Maybe Tag -> Bool -> Bool -> Wanted -> P -> Q
- Text.Regex.TDFA.TDFA: Testing' :: WhichTest -> EnumSet DoPa -> DT -> DT -> DT
+ Text.Regex.TDFA.TDFA: Testing' :: WhichTest -> EnumSet DoPa -> DT -> DT
- Text.Regex.TDFA.TNFA: Testing :: WhichTest -> EnumSet DoPa -> QT -> QT -> QT
+ Text.Regex.TDFA.TNFA: Testing :: WhichTest -> EnumSet DoPa -> QT -> QT

Files

+ CHANGELOG.md view
@@ -0,0 +1,157 @@+# 1.2.2++* New maintainer.+* Now we don't reexport the problematic `Show` instance for functions.++# 1.2.1++* Updated dependency versions.++# 1.2.0++"Almost ghc-7.8" with the array 0.4 changes for `Data.Array.Unsafe`++# 1.1.8++Make ghc-7.0.2 on platorm 2011.2.0.0.0 happy++# 1.1.7++fix url below++# 1.1.6++Fix bug preventing `[]] [-] [^]] [^-]` (thanks to Maxime Henrion)++# 1.1.5++try `needUniqTags` in `POr` in CorePattern.hs, try `toAdvice b` for `PStar child`++# 1.1.4++fixed ++# 1.1.3++BROKEN after 100 characters the `compressOrbit` dies!++# 1.1.2++worked++# 1.1.1++add gnu escapes++# 1.1.0++NewDFA code working++# 1.0.7++make NewDFA directory and String_NC++# 1.0.6++try NewDFATest_SBS with `uncons`++# 1.0.5++use `uncons` on SBS++# 1.0.4++try repaired NewDFATest_SBS++* np13: try to improve readability with the `mm` combinator? Yes!+* np12: expand `o` in the case where `t` lookup get `Nothing`? Yes – this is the fix!?+* np11: break multi to not look at `o` and just return `True`? Yes !!!!+* np10: Peel off `CharMap`/`IntMap` and DFA/DT with pattern matching? No+* np9:  `INLINE` `endOf`? No+* np8:  np6 and `NOINLINE` `endOff`? No+* np7:  just return `True`? Fast+* np6:  comment out ans check? No+* np5:  comment out all `Multi0` code? No+* np4:  comment out all `Single0` and `Single` code? No+* np3:  `!off` the multi? No+* np2:  comment out all Testing code? No++# 1.0.3++try to alter `matchTest` to not have the `Bool` args? No++# 1.0.2++arg, the prof is fast and the normal slow!++# 1.0.1++add NewDFATest.hs++# 0.99.20++go to many vs single?++# 0.99.19++try for pre-comparison of orbit-logs!++# 0.99.18++try alternate lazy/strict strategy in NewDFA. Fix offset laziness.++# 0.99.17++radical removal of flag array and adding of `SetVal` to handle groups++# 0.99.16++performance? up to v15++# 0.99.15++get string with NewDFA testing, unit tests and 1000 random regex pass++# 0.99.14++start changing to the new real DFA++# 0.99.13++more cleanup++# 0.99.12++try to debug 0.99.11: fixed `updateWinner`++# 0.99.11++improve above fix and make stuff work better – HAS BUG, along with old TDFA!++# 0.99.10++fixed `((.?)*)*` patterns by changing `PStar nullView` when `mayFirstBeNull`++# 0.99.9++testing changing `bestTrans`/`chooseWith`/`choose` to include `enterOrbit`/`newFlags`/`(_,True)` info++# 0.99.8++testing changing `Maximize` to `Minimize` for `Tag`s, decide `(a*)*` is canonical problem++# 0.99.7++Use `(PGroup Nothing)` in `Pattern` to decompose `PBound`++# 0.99.6++change to nested `nonEmpty` calls for `PBound`++# 0.99.5++remove `PNonEmpty` constructor++# 0.99.4++tests `pnonempty' = \ p -> POr [ PEmpty, p ]` instead of `PNonEmpty`
Text/Regex/TDFA.hs view
@@ -9,7 +9,7 @@ This regex-tdfa package implements, correctly, POSIX extended regular expressions.  It is highly unlikely that the regex-posix package on your operating system is correct, see-http://www.haskell.org/haskellwiki/Regex_Posix for examples of your+<http://www.haskell.org/haskellwiki/Regex_Posix> for examples of your OS's bugs.  This package does provide captured parenthesized subexpressions.@@ -23,23 +23,18 @@ As of version 1.1.1 the following GNU extensions are recognized, all anchors: -\\\` at beginning of entire text--\\\' at end of entire text--\\< at beginning of word--\\> at end of word--\\b at either beginning or end of word--\\B at neither beginning nor end of word+* \\\` at beginning of entire text+* \\\' at end of entire text+* \\\< at beginning of word+* \\\> at end of word+* \\b at either beginning or end of word+* \\B at neither beginning nor end of word  The above are controlled by the 'newSyntax' Bool in 'CompOption'.  Where the "word" boundaries means between characters that are and are not in the [:word:] character class which contains [a-zA-Z0-9_].  Note-that \< and \b may match before the entire text and \> and \b may+that \\\< and \\b may match before the entire text and \\\> and \\b may match at the end of the entire text.  There is no locale support, so collating elements like [.ch.] are
Text/Regex/TDFA/Common.hs view
@@ -7,7 +7,6 @@ import Text.Regex.Base(RegexOptions(..))  {- By Chris Kuklewicz, 2007-2009. BSD License, see the LICENSE file. -}-import Text.Show.Functions() import Data.Array.IArray(Array) import Data.IntSet.EnumSet2(EnumSet) import qualified Data.IntSet.EnumSet2 as Set(toList)@@ -32,14 +31,14 @@ on :: (t1 -> t1 -> t2) -> (t -> t1) -> t -> t -> t2 f `on` g = (\x y -> (g x) `f` (g y)) --- | after sort or sortBy the use of nub/nubBy can be replaced by norep/norepBy+-- | after 'sort' or 'sortBy' the use of 'nub'\/'nubBy' can be replaced by 'norep'\/'norepBy' norep :: (Eq a) => [a]->[a] norep [] = [] norep x@[_] = x norep (a:bs@(c:cs)) | a==c = norep (a:cs)                     | otherwise = a:norep bs --- | after sort or sortBy the use of nub/nubBy can be replaced by norep/norepBy+-- | after 'sort' or 'sortBy' the use of 'nub'\/'nubBy' can be replaced by 'norep'\/'norepBy' norepBy :: (a -> a -> Bool) -> [a] -> [a] norepBy _ [] = [] norepBy _ x@[_] = x@@ -81,7 +80,7 @@   showsPrec p (DoPa {dopaIndex=i}) = ('#':) . showsPrec p i  -- | Control whether the pattern is multiline or case-sensitive like Text.Regex and whether to--- capture the subgroups (\1, \2, etc).  Controls enabling extra anchor syntax.+-- capture the subgroups (\\1, \\2, etc).  Controls enabling extra anchor syntax. data CompOption = CompOption {     caseSensitive :: Bool    -- ^ True in blankCompOpt and defaultCompOpt   , multiline :: Bool {- ^ False in blankCompOpt, True in defaultCompOpt. Compile for@@ -115,7 +114,7 @@ type Position = Int  -- | GroupIndex is for indexing submatches from capturing--- parenthesized groups (PGroup/Group)+-- parenthesized groups (PGroup\/Group) type GroupIndex = Int -- | GroupInfo collects the parent and tag information for an instance  -- of a group@@ -180,9 +179,9 @@ type QTrans = IntMap {- Destination Index -} [TagCommand]  -- | Known predicates, just Beginning of Line (^) and End of Line ($).--- Also support for GNU extensions is being added: \` beginning of--- buffer, \' end of buffer, \< and \> for begin and end of words, \b--- and \B for word boundary and not word boundary.+-- Also support for GNU extensions is being added: \\\` beginning of+-- buffer, \\\' end of buffer, \\\< and \\\> for begin and end of words, \\b+-- and \\B for word boundary and not word boundary. data WhichTest = Test_BOL | Test_EOL -- '^' and '$' (affected by multiline option)                | Test_BOB | Test_EOB -- \` and \' begin and end buffer                | Test_BOW | Test_EOW -- \< and \> begin and end word@@ -233,7 +232,7 @@ -- going to the same destination must be compared to find the best. -- -- A Destination IntMap entry may have an empty Source IntMap if and--- only if the destination is the starting index and the NFA/DFA.+-- only if the destination is the starting index and the NFA\/DFA. -- This instructs the matching engine to spawn a new entry starting at -- the post-update position. type DTrans = IntMap {- Index of Destination -} (IntMap {- Index of Source -} (DoPa,Instructions))@@ -259,7 +258,19 @@ data Instructions = Instructions   { newPos :: ![(Tag,Action)] -- False is preUpdate, True is postUpdate (there are no Orbit tags here) -- 2009 : Change to enum from bool?   , newOrbits :: !(Maybe (Position -> OrbitTransformer))-  } deriving (Show)+  }++instance Show Instructions where+  showsPrec p (Instructions pos _)+    = showParen (p >= 11) $+        showString "Instructions {" .+        showString "newPos = " .+        showsPrec 0 pos .+        showString ", " .+        showString "newOrbits = " .+        showString "<function>" .+        showString "}"+ data Action = SetPre | SetPost | SetVal Int deriving (Show,Eq) type OrbitTransformer = OrbitLog -> OrbitLog type OrbitLog = IntMap Orbits
Text/Regex/TDFA/CorePattern.hs view
@@ -1,16 +1,16 @@ -- | The CorePattern module deconstructs the Pattern tree created by--- ReadRegex.parseRegex and returns a simpler Q/P tree with+-- ReadRegex.parseRegex and returns a simpler Q\/P tree with -- annotations at each Q node.  This will be converted by the TNFA -- module into a QNFA finite automata. ----- Of particular note, this Pattern to Q/P conversion creates and+-- Of particular note, this Pattern to Q\/P conversion creates and -- assigns all the internal Tags that will be used during the matching -- process, and associates the captures groups with the tags that -- represent their starting and ending locations and with their -- immediate parent group. -- -- Each Maximize and Minimize tag is held as either a preTag or a--- postTag by one and only one location in the Q/P tree.  The Orbit+-- postTag by one and only one location in the Q\/P tree.  The Orbit -- tags are each held by one and only one Star node.  Tags that stop a -- Group are also held in perhaps numerous preReset lists. --
Text/Regex/TDFA/NewDFA/Engine.hs view
@@ -529,11 +529,11 @@  newtype F s = F ([F s] -> C s) type C s = Position-	  -> ((Int, Instructions), STUArray s Tag Position, IntMap Orbits)-	  -> [(Int, Action)]-	  -> ((Int, Instructions), STUArray s Tag Position, IntMap Orbits)-	  -> [(Int, Action)]-	  -> ST s Ordering+        -> ((Int, Instructions), STUArray s Tag Position, IntMap Orbits)+        -> [(Int, Action)]+        -> ((Int, Instructions), STUArray s Tag Position, IntMap Orbits)+        -> [(Int, Action)]+        -> ST s Ordering  {-# INLINE orderOf #-} orderOf :: Action -> Action -> Ordering@@ -703,7 +703,7 @@ Prelude Data.Array.Base> :i STUArray data STUArray s i e   = STUArray !i !i !Int (GHC.Prim.MutableByteArray# s)-  	-- Defined in Data.Array.Base+  -- Defined in Data.Array.Base -} -- This has been updated for ghc 6.8.3 and still works with ghc 6.10.1 {-# INLINE copySTU #-}
Text/Regex/TDFA/NewDFA/Engine_FA.hs view
@@ -388,11 +388,11 @@  newtype F s = F ([F s] -> C s) type C s = Position-	  -> ((Int, Instructions), STUArray s Tag Position, IntMap Orbits)-	  -> [(Int, Action)]-	  -> ((Int, Instructions), STUArray s Tag Position, IntMap Orbits)-	  -> [(Int, Action)]-	  -> ST s Ordering+        -> ((Int, Instructions), STUArray s Tag Position, IntMap Orbits)+        -> [(Int, Action)]+        -> ((Int, Instructions), STUArray s Tag Position, IntMap Orbits)+        -> [(Int, Action)]+        -> ST s Ordering  {-# INLINE orderOf #-} orderOf :: Action -> Action -> Ordering@@ -561,7 +561,7 @@ Prelude Data.Array.Base> :i STUArray data STUArray s i e   = STUArray !i !i !Int (GHC.Prim.MutableByteArray# s)-  	-- Defined in Data.Array.Base+  -- Defined in Data.Array.Base -} -- This has been updated for ghc 6.8.3 and still works with ghc 6.10.1 {-# INLINE copySTU #-}
Text/Regex/TDFA/Pattern.hs view
@@ -132,7 +132,7 @@  -- | Do the transformation and simplification in a single traversal. -- This removes the PPlus, PQuest, and PBound values, changing to POr--- and PEmpty and PStar True/False.  For some PBound values it adds+-- and PEmpty and PStar True\/False.  For some PBound values it adds -- PNonEmpty and PNonCapture semantic marker.  It also simplifies to -- flatten out nested POr and PConcat instances and eliminate some -- unneeded PEmpty values.
Text/Regex/TDFA/ReadRegex.hs view
@@ -1,6 +1,6 @@ {-# OPTIONS_GHC -fno-warn-missing-signatures #-} -- | This is a POSIX version of parseRegex that allows NUL characters.--- Lazy/Possessive/Backrefs are not recognized.  Anchors ^ and $ are+-- Lazy\/Possessive\/Backrefs are not recognized.  Anchors \^ and \$ are -- recognized. -- -- The PGroup returned always have (Maybe GroupIndex) set to (Just _)@@ -23,7 +23,7 @@ -- | Return either an error message or a tuple of the Pattern and the -- largest group index and the largest DoPa index (both have smallest -- index of 1).  Since the regular expression is supplied as [Char] it--- automatically supports unicode and '\NUL' characters.+-- automatically supports unicode and @\\NUL@ characters. parseRegex :: String -> Either ParseError (Pattern,(GroupIndex,DoPa)) parseRegex x = runParser (do pat <- p_regex                              eof
Text/Regex/TDFA/TDFA.hs view
@@ -6,7 +6,6 @@                             ,examineDFA,nfaToDFA,dfaMap) where  --import Control.Arrow((***))-import Control.Monad.Instances() import Data.Monoid(Monoid(..)) import Control.Monad.State(State,MonadState(..),execState) import Data.Array.IArray(Array,(!),bounds,{-assocs-})
Text/Regex/TDFA/TNFA.hs view
@@ -6,7 +6,7 @@ -- TODO : try rewriting whole qToNFA in terms of "act" -- (That will require re-organizing the continuation data a bit) --- | "Text.Regex.TDFA.TNFA" converts the CorePattern Q/P data (and its+-- | "Text.Regex.TDFA.TNFA" converts the CorePattern Q\/P data (and its -- Pattern leafs) to a QNFA tagged non-deterministic finite automata. --  -- This holds every possible way to follow one state by another, while@@ -17,7 +17,7 @@ -- far, keeping all this information has helped fix bugs in both the -- design and implementation. ----- The QNFA for a Pattern with a starTraned Q/P form with N one+-- The QNFA for a Pattern with a starTraned Q\/P form with N one -- character accepting leaves has at most N+1 nodes.  These nodes -- repesent the future choices after accepting a leaf.  The processing -- of Or nodes often reduces this number by sharing at the end of the
regex-tdfa.cabal view
@@ -1,76 +1,40 @@ Name:                   regex-tdfa-Version:                1.2.1--- 0.99.4 tests pnonempty' = \ p -> POr [ PEmpty, p ] instead of PNonEmpty--- 0.99.5 remove PNonEmpty constructor--- 0.99.6 change to nested nonEmpty calls for PBound--- 0.99.7 Use (PGroup Nothing) in Pattern to decompose PBound--- 0.99.8 testing chaning Maximize to Minimize for Tags, decide (a*)* is canonical problem--- 0.99.9 testing changing bestTrans/chooseWith/choose to include enterOrbit/newFlags/(_,True) info--- 0.99.10 fixed ((.?)*)* patterns by changing PStar nullView when mayFirstBeNull--- 0.99.11 improve above fix and make stuff work better -- HAS BUG, along with old TDFA!--- 0.99.12 try to debug 0.99.11 : fixed updateWinner--- 0.99.13 more cleanup--- 0.99.14 start changing to the new real DFA--- 0.99.15 get string with NewDFA testing, unit tests and 1000 random regex pass--- 0.99.16 performance? up to v15--- 0.99.17 radical removal of flag array and adding of SetVal to handle groups--- 0.99.18 try alternate lazy/strict strategy in NewDFA.  Fix offset laziness.--- 0.99.19 try for pre-comparison of orbit-logs!--- 0.99.20 go to many vs single?--- 1.0.0--- 1.0.1 add NewDFATest.hs--- 1.0.2 arg, the prof is fast and the normal slow!--- 1.0.3 try to alter matchTest to not have the Bool args? No---  np2  comment out all Testing code? No---  np3  !off the multi? No---  np4  comment out all Single0 and Single code? No---  np5  comment out all Multi0 code? No---  np6  comment out ans check? No---  np7  just return True? Fast---  np8  np6 and NOINLINE endOff? No---  np9  INLINE endOf? No---  np10 Peel off CharMap/IntMap and DFA/DT with pattern matching? No---  np11 break multi to not look at o and just return True? Yes !!!!---  np12 expand o in the case where t lookup get Nothing? Yes--this is the fix!?---  np13 try to improve readability with the "mm" combinator? Yes!--- 1.0.4 try repaired NewDFATest_SBS--- 1.0.5 use "uncons" on SBS--- 1.0.6 try NewDFATest_SBS with uncons--- 1.0.7 make NewDFA directory and String_NC--- 1.1.0 NewDFA code working--- 1.1.1 add gnu escapes--- 1.1.2 worked--- 1.1.3 BROKEN after 100 characters the compressOrbit dies!--- 1.1.4 fixed --- 1.1.5 try needUniqTags in POr in CorePattern.hs, try (toAdvice b) for PStar child--- 1.1.6 Fix bug preventing []] [-] [^]] [^-] (thanks to Maxime Henrion)--- 1.1.7 fix url below--- 1.1.8 Make ghc-7.0.2 on platorm 2011.2.0.0.0 happy--- 1.2.0 "Almost ghc-7.8" with the array 0.4 changes for Data.Array.Unsafe--- 1.2.1 Get Build-Depends from "Mon Jun 15 14:24:28 UTC 2015 by AdamBergmark to revision 1"+Version:                1.2.2 License:                BSD3 License-File:           LICENSE Copyright:              Copyright (c) 2007, Christopher Kuklewicz Author:                 Christopher Kuklewicz-Maintainer:             TextRegexLazy@personal.mightyreason.com+Maintainer:             Artyom <yom@artyom.me>, Christopher Kuklewicz <TextRegexLazy@personal.mightyreason.com> Stability:              Seems to work, but not POSIX yet-Homepage:               http://hackage.haskell.org/package/regex-tdfa-Package-URL:            http://code.haskell.org/regex-tdfa/+Homepage:               https://github.com/ChrisKuklewicz/regex-tdfa+Bug-Reports:            https://github.com/ChrisKuklewicz/regex-tdfa/issues Synopsis:               Replaces/Enhances Text.Regex Description:            A new all Haskell "tagged" DFA regex engine, inspired by libtre Category:               Text-Tested-With:            GHC+Tested-With:            GHC == 7.6.3, GHC == 7.8.4, GHC == 7.10.3, GHC == 8.0.1 Build-Type:             Simple-Cabal-Version:          >= 1.2.3+extra-source-files:+  CHANGELOG.md+Cabal-Version:          >= 1.6 -flag base4+source-repository head+  type:                git+  location:            git://github.com/ChrisKuklewicz/regex-tdfa.git +flag devel+  description: enable flags that are useful for development+  default: False+  manual: True+ library -  Build-Depends:        regex-base >= 0.93.1, parsec, mtl, containers, array >= 0.4, bytestring-  if flag(base4)-    Build-Depends:      base >= 4 && < 5, base >= 4.4 || < 4.4, ghc-prim-  else-    Build-Depends:      base < 4.0+  Build-Depends:        array >= 0.4+                      , base >= 4 && < 5+                      , bytestring+                      , containers+                      , ghc-prim+                      , mtl+                      , parsec+                      , regex-base >= 0.93.1    other-modules:          Paths_regex_tdfa   Exposed-Modules:        Data.IntMap.CharMap2@@ -98,4 +62,5 @@   Buildable:              True   Extensions:             MultiParamTypeClasses, FunctionalDependencies, BangPatterns, MagicHash, RecursiveDo, NoMonoPatBinds, ForeignFunctionInterface, UnboxedTuples, TypeOperators, FlexibleContexts, ExistentialQuantification, UnliftedFFITypes, TypeSynonymInstances, FlexibleInstances   GHC-Options:            -Wall -funbox-strict-fields -fspec-constr-count=10 -O2 -fno-warn-orphans-  GHC-Prof-Options:       -auto-all+  if flag(devel)+    ghc-prof-options: -auto-all