1mod constants;
78#[cfg(feature = "presets")]
79pub mod presets;
80pub mod readable;
81pub mod solvers;
82
83pub use readable::ReadableRe;
84use std::ops::RangeBounds;
85
86pub const fn digit<'a>() -> ReadableRe<'a> {
87 ReadableRe::Digit
88}
89
90pub const fn word<'a>() -> ReadableRe<'a> {
91 ReadableRe::Word
92}
93
94pub const fn whitespace<'a>() -> ReadableRe<'a> {
95 ReadableRe::Whitespace
96}
97
98pub const fn non_digit<'a>() -> ReadableRe<'a> {
99 ReadableRe::NonDigit
100}
101
102pub const fn non_word<'a>() -> ReadableRe<'a> {
103 ReadableRe::NonWord
104}
105
106pub const fn non_whitespace<'a>() -> ReadableRe<'a> {
107 ReadableRe::NonWhitespace
108}
109
110pub const fn boundary<'a>() -> ReadableRe<'a> {
111 ReadableRe::Boundary
112}
113
114pub const fn ascii_letter<'a>() -> ReadableRe<'a> {
115 ReadableRe::AsciiLetter
116}
117
118pub const fn ascii_non_letter<'a>() -> ReadableRe<'a> {
119 ReadableRe::AsciiNonLetter
120}
121
122pub const fn ascii_uppercase<'a>() -> ReadableRe<'a> {
123 ReadableRe::AsciiUppercase
124}
125
126pub const fn ascii_non_uppercase<'a>() -> ReadableRe<'a> {
127 ReadableRe::AsciiNonUppercase
128}
129
130pub const fn ascii_lowercase<'a>() -> ReadableRe<'a> {
131 ReadableRe::AsciiLowercase
132}
133
134pub const fn ascii_non_lowercase<'a>() -> ReadableRe<'a> {
135 ReadableRe::AsciiNonLowercase
136}
137
138pub const fn ascii_alphanumeric<'a>() -> ReadableRe<'a> {
139 ReadableRe::AsciiAlphanumeric
140}
141
142pub const fn ascii_non_alphanumeric<'a>() -> ReadableRe<'a> {
143 ReadableRe::AsciiNonAlphanumeric
144}
145
146pub const fn ascii_numeric<'a>() -> ReadableRe<'a> {
147 ReadableRe::AsciiNumeric
148}
149
150pub const fn ascii_non_numeric<'a>() -> ReadableRe<'a> {
151 ReadableRe::AsciiNonNumeric
152}
153
154pub const fn hexadecimal<'a>() -> ReadableRe<'a> {
155 ReadableRe::Hexadecimal
156}
157
158pub const fn non_hexadecimal<'a>() -> ReadableRe<'a> {
159 ReadableRe::NonHexadecimal
160}
161
162pub const fn anything<'a>() -> ReadableRe<'a> {
163 ReadableRe::Anything
164}
165
166pub const fn everything<'a>() -> ReadableRe<'a> {
167 ReadableRe::Everything
168}
169
170pub const fn something_greedy<'a>() -> ReadableRe<'a> {
171 ReadableRe::SomethingGreedy
172}
173
174pub const fn something<'a>() -> ReadableRe<'a> {
175 ReadableRe::Something
176}
177
178pub const fn any_char<'a>() -> ReadableRe<'a> {
179 ReadableRe::AnyChar
180}
181
182pub const fn period<'a>() -> ReadableRe<'a> {
183 ReadableRe::Period
184}
185
186pub const fn caret<'a>() -> ReadableRe<'a> {
187 ReadableRe::Caret
188}
189
190pub const fn dollar<'a>() -> ReadableRe<'a> {
191 ReadableRe::Dollar
192}
193
194pub const fn asterisk<'a>() -> ReadableRe<'a> {
195 ReadableRe::Asterisk
196}
197
198pub const fn plus_sign<'a>() -> ReadableRe<'a> {
199 ReadableRe::PlusSign
200}
201
202pub const fn minus_sign<'a>() -> ReadableRe<'a> {
203 ReadableRe::MinusSign
204}
205
206pub const fn question_mark<'a>() -> ReadableRe<'a> {
207 ReadableRe::QuestionMark
208}
209
210pub const fn open_brace<'a>() -> ReadableRe<'a> {
211 ReadableRe::OpenBrace
212}
213
214pub const fn close_brace<'a>() -> ReadableRe<'a> {
215 ReadableRe::CloseBrace
216}
217
218pub const fn open_bracket<'a>() -> ReadableRe<'a> {
219 ReadableRe::OpenBracket
220}
221
222pub const fn close_bracket<'a>() -> ReadableRe<'a> {
223 ReadableRe::CloseBracket
224}
225
226pub const fn open_parenthesis<'a>() -> ReadableRe<'a> {
227 ReadableRe::OpenParenthesis
228}
229
230pub const fn close_parenthesis<'a>() -> ReadableRe<'a> {
231 ReadableRe::CloseParenthesis
232}
233
234pub const fn back_slash<'a>() -> ReadableRe<'a> {
235 ReadableRe::BackSlash
236}
237
238pub const fn pipe<'a>() -> ReadableRe<'a> {
239 ReadableRe::Pipe
240}
241
242pub const fn new_line<'a>() -> ReadableRe<'a> {
243 ReadableRe::Newline
244}
245
246pub const fn tab<'a>() -> ReadableRe<'a> {
247 ReadableRe::Tab
248}
249
250pub const fn quote<'a>() -> ReadableRe<'a> {
251 ReadableRe::Quote
252}
253
254pub const fn double_quote<'a>() -> ReadableRe<'a> {
255 ReadableRe::DoubleQuote
256}
257
258#[cfg(feature = "re-fancy")]
259pub const fn back1<'a>() -> ReadableRe<'a> {
260 ReadableRe::Back1
261}
262
263#[cfg(feature = "re-fancy")]
264pub const fn back2<'a>() -> ReadableRe<'a> {
265 ReadableRe::Back2
266}
267
268#[cfg(feature = "re-fancy")]
269pub const fn back3<'a>() -> ReadableRe<'a> {
270 ReadableRe::Back3
271}
272
273#[cfg(feature = "re-fancy")]
274pub const fn back4<'a>() -> ReadableRe<'a> {
275 ReadableRe::Back4
276}
277
278#[cfg(feature = "re-fancy")]
279pub const fn back5<'a>() -> ReadableRe<'a> {
280 ReadableRe::Back5
281}
282
283#[cfg(feature = "re-fancy")]
284pub const fn back6<'a>() -> ReadableRe<'a> {
285 ReadableRe::Back6
286}
287
288#[cfg(feature = "re-fancy")]
289pub const fn back7<'a>() -> ReadableRe<'a> {
290 ReadableRe::Back7
291}
292
293#[cfg(feature = "re-fancy")]
294pub const fn back8<'a>() -> ReadableRe<'a> {
295 ReadableRe::Back8
296}
297
298#[cfg(feature = "re-fancy")]
299pub const fn back9<'a>() -> ReadableRe<'a> {
300 ReadableRe::Back9
301}
302
303pub const fn raw_regex(s: &str) -> ReadableRe {
304 ReadableRe::Raw(s)
305}
306
307pub const fn string_regex<'a>(s: String) -> ReadableRe<'a> {
308 ReadableRe::String(s)
309}
310
311pub fn concat<'a>(iter: impl IntoIterator<Item = ReadableRe<'a>>) -> ReadableRe<'a> {
312 ReadableRe::Concat(solvers::Concat::new(iter))
313}
314
315#[cfg(feature = "re-fancy")]
316pub const fn back_reference<'a>(n: usize) -> ReadableRe<'a> {
317 ReadableRe::BackReference(solvers::BackReference(n))
318}
319
320pub fn escape_str(s: &str) -> ReadableRe {
321 ReadableRe::Escape(solvers::Escape::new_str(s))
322}
323
324pub fn escape(re: ReadableRe) -> ReadableRe {
325 ReadableRe::Escape(solvers::Escape::new(re))
326}
327
328pub fn group(re: ReadableRe) -> ReadableRe {
329 ReadableRe::Group(solvers::Group::new(re))
330}
331
332#[cfg(feature = "re-fancy")]
333pub fn positive_look_ahead(re: ReadableRe) -> ReadableRe {
334 ReadableRe::PositiveLookAhead(solvers::PositiveLookAhead::new(re))
335}
336
337#[cfg(feature = "re-fancy")]
338pub fn negative_look_ahead(re: ReadableRe) -> ReadableRe {
339 ReadableRe::NegativeLookAhead(solvers::NegativeLookAhead::new(re))
340}
341
342#[cfg(feature = "re-fancy")]
343pub fn positive_look_behind(re: ReadableRe) -> ReadableRe {
344 ReadableRe::PositiveLookBehind(solvers::PositiveLookBehind::new(re))
345}
346
347#[cfg(feature = "re-fancy")]
348pub fn negative_look_behind(re: ReadableRe) -> ReadableRe {
349 ReadableRe::NegativeLookBehind(solvers::NegativeLookBehind::new(re))
350}
351
352pub fn named_group<'a>(name: &'a str, re: ReadableRe<'a>) -> ReadableRe<'a> {
353 ReadableRe::NamedGroup(solvers::NamedGroup::new(name, re))
354}
355
356pub fn non_capture_group(re: ReadableRe) -> ReadableRe {
357 ReadableRe::NonCaptureGroup(solvers::NonCaptureGroup::new(re))
358}
359
360pub fn optional(re: ReadableRe) -> ReadableRe {
361 ReadableRe::Optional(solvers::Optional::new(re))
362}
363
364pub fn either<'a>(iter: impl IntoIterator<Item = ReadableRe<'a>>) -> ReadableRe<'a> {
365 ReadableRe::Either(solvers::Either::new(iter))
366}
367
368pub fn exactly(n: usize, re: ReadableRe) -> ReadableRe {
369 ReadableRe::Exactly(solvers::Exactly::new(n, re))
370}
371
372pub fn ranged<R>(range: R, re: ReadableRe) -> ReadableRe
373where
374 R: RangeBounds<usize> + 'static,
375{
376 ReadableRe::Ranged(solvers::Ranged::new(range, re))
377}
378
379pub fn at_least(n: usize, re: ReadableRe) -> ReadableRe {
380 ReadableRe::Ranged(solvers::Ranged::new(n.., re))
381}
382
383pub fn at_most(n: usize, re: ReadableRe) -> ReadableRe {
384 ReadableRe::Ranged(solvers::Ranged::new(..n, re))
385}
386
387pub fn zero_or_more(re: ReadableRe) -> ReadableRe {
388 ReadableRe::ZeroOrMore(solvers::ZeroOrMore::new(re))
389}
390
391pub fn zero_or_more_lazy(re: ReadableRe) -> ReadableRe {
392 ReadableRe::ZeroOrMoreLazy(solvers::ZeroOrMoreLazy::new(re))
393}
394
395pub fn one_or_more(re: ReadableRe) -> ReadableRe {
396 ReadableRe::OneOrMore(solvers::OneOrMore::new(re))
397}
398
399pub fn one_or_more_lazy(re: ReadableRe) -> ReadableRe {
400 ReadableRe::OneOrMoreLazy(solvers::OneOrMoreLazy::new(re))
401}
402
403pub fn starts_with(re: ReadableRe) -> ReadableRe {
404 ReadableRe::StartsWith(solvers::StartsWith::new(re))
405}
406
407pub fn ends_with(re: ReadableRe) -> ReadableRe {
408 ReadableRe::EndsWith(solvers::EndsWith::new(re))
409}
410
411pub fn starts_and_ends_with(re: ReadableRe) -> ReadableRe {
412 ReadableRe::StartsAndEndsWith(solvers::StartsAndEndsWith::new(re))
413}
414
415pub fn chars(re: &str) -> ReadableRe {
416 ReadableRe::Chars(solvers::Chars::new(re))
417}
418
419pub fn not_chars<'a>(s: &str) -> ReadableRe<'a> {
420 ReadableRe::NotChars(solvers::NotChars::new(s))
421}
422
423#[cfg(feature = "re-fancy")]
424pub fn atomic_group(re: ReadableRe) -> ReadableRe {
425 ReadableRe::AtomicGroup(solvers::AtomicGroup::new(re))
426}