/
Sequence.hs
173 lines (158 loc) · 5.3 KB
/
Sequence.hs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# LANGUAGE CPP #-}
#if __GLASGOW_HASKELL__ >= 800
{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}
#endif
module Text.RE.TDFA.Sequence
(
-- * Tutorial
-- $tutorial
-- * The 'Matches' and 'Match' Operators
(*=~)
, (?=~)
-- * The 'SearchReplace' Operators
, (*=~/)
, (?=~/)
-- * Matches
, Matches
, matchesSource
, allMatches
, anyMatches
, countMatches
, matches
-- * Match
, Match
, matchSource
, matched
, matchedText
-- * The 'RE' Type
, RE
, reSource
-- * Options
-- $options
, SimpleREOptions(..)
-- * Compiling and Escaping REs
, SearchReplace(..)
, compileRegex
, compileRegexWith
, compileSearchReplace
, compileSearchReplaceWith
, escape
, escapeWith
, escapeREString
-- * The Classic rexex-base Match Operators
, (=~)
, (=~~)
-- * IsRegex
, IsRegex(..)
-- * The Quasi Quoters and Minor Functions
-- $re
, module Text.RE.ZeInternals.TDFA
-- $ed
, module Text.RE.ZeInternals.SearchReplace.TDFA.Sequence
) where
import qualified Data.Sequence as S
import Data.Typeable
import Prelude.Compat
import Text.RE.REOptions
import Text.RE.Replace
import Text.RE.ZeInternals.AddCaptureNames
import Text.RE.ZeInternals.SearchReplace.TDFA.Sequence
import Text.RE.ZeInternals.TDFA
import Text.RE.ZeInternals.Types.IsRegex
import Text.Regex.Base
import qualified Text.Regex.TDFA as TDFA
-- | find all the matches in the argument text; e.g., to count the number
-- of naturals in s:
--
-- @countMatches $ s *=~ [re|[0-9]+|]@
--
(*=~) :: (S.Seq Char)
-> RE
-> Matches (S.Seq Char)
(*=~) bs rex = addCaptureNamesToMatches (reCaptureNames rex) $ match (reRegex rex) bs
-- | find the first match in the argument text; e.g., to test if there
-- is a natural number in the input text:
--
-- @matched $ s ?=~ [re|[0-9]+|]@
--
(?=~) :: (S.Seq Char)
-> RE
-> Match (S.Seq Char)
(?=~) bs rex = addCaptureNamesToMatch (reCaptureNames rex) $ match (reRegex rex) bs
-- | search and replace all matches in the argument text; e.g., this section
-- will convert every YYYY-MM-DD format date in its argument text into a
-- DD\/MM\/YYYY date:
--
-- @(*=~\/ [ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@
--
(*=~/) :: (S.Seq Char) -> SearchReplace RE (S.Seq Char) -> (S.Seq Char)
(*=~/) = flip searchReplaceAll
-- | search and replace the first occurrence only (if any) in the input text
-- e.g., to prefix the first string of four hex digits in the imput text,
-- if any, with @0x@:
--
-- @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@
--
(?=~/) :: (S.Seq Char) -> SearchReplace RE (S.Seq Char) -> (S.Seq Char)
(?=~/) = flip searchReplaceFirst
-- | the regex-base polymorphic match operator
(=~) :: ( Typeable a
, RegexContext TDFA.Regex (S.Seq Char) a
, RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String
)
=> (S.Seq Char)
-> RE
-> a
(=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs
-- | the regex-base monadic, polymorphic match operator
(=~~) :: ( Monad m
, Functor m
, Typeable a
, RegexContext TDFA.Regex (S.Seq Char) a
, RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String
)
=> (S.Seq Char)
-> RE
-> m a
(=~~) bs rex = addCaptureNames (reCaptureNames rex) <$> matchM (reRegex rex) bs
instance IsRegex RE (S.Seq Char) where
matchOnce = flip (?=~)
matchMany = flip (*=~)
makeRegexWith = \o -> compileRegexWith o . unpackR
makeSearchReplaceWith = \o r t -> compileSearchReplaceWith o (unpackR r) (unpackR t)
regexSource = packR . reSource
-- $tutorial
-- We have a regex tutorial at <http://tutorial.regex.uk>.
-- $options
-- You can specify different compilation options by appending a
-- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter
-- to select the corresponding compilation option. For example, the
-- section,
--
-- @(?=~/ [edBlockInsensitive|foo$\/\/\/bar|])@
--
-- will replace a @foo@ suffix of the argument text, of any
-- capitalisation, with a (lower case) @bar@. If you need to specify the
-- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@
-- quasi quoters, which generate functions that take an 'IsOption' option
-- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace'
-- as apropriate. For example if you have a 'SimpleReOptions' value in
-- @sro@ then
--
-- @(?=~/ [ed_|foo$\/\/\/bar|] sro)@
--
-- will compile the @foo$@ RE according to the value of @sro@. For more
-- on specifying RE options see "Text.RE.REOptions".
-- $re
-- The @[re|.*|]@ quasi quoters, with variants for specifing different
-- options to the RE compiler (see "Text.RE.REOptions"), and the
-- specialised back-end types and functions.
-- $ed
-- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different
-- options to the RE compiler (see "Text.RE.REOptions").