Text.Regex.Do.Match.Latin

although sometimes funs in Ascii modules work with non-ascii text (as some examples show), for reliable results with Utf8 pattern or body, use Text.Regex.Do.Match.Utf8

see also Text.Regex.Base.RegexLike

Documentation

class MatchOnce pattern body out where

API changes:

Once is hinted with ~?

All is hinted with ~*

All regex-computing instances catch regex errors, return Either String out (Left String is the error message)

• pattern: String, ByteString, Regex

String | ByteString pattern may contains regex

• body: String, ByteString

• out: out | E out

  • Bool: test if regex matches
  • [String]
  • [ByteString]
  • [PosLen]

precompiled Regex may be used as pattern too. see Text.Regex.Do.Match.Utf8

Minimal complete definition

(~?)

Methods

(~?) :: pattern -> body -> out

Instances

RegexLike Regex b => MatchOnce Regex b Bool

test.

always succeeds

Methods

(~?) :: Regex -> b -> Bool

(Regex b, RegexLike Regex b) => MatchOnce b b (E [PosLen])

>>> "à" ~? "tourner à gauche"::E [PosLen]

Right [(8,2)]

Methods

(~?) :: b -> b -> E [PosLen]

(Regex b, RegexLike Regex b) => MatchOnce b b (E Bool)

test

>>> "chilly" ~? "it's chilly inside, chilly outside"::E Bool

Right True

Methods

(~?) :: b -> b -> E Bool

(Regex b, RegexLike Regex b) => MatchOnce b b (E [b])

>>> "^all" ~? "all the time"::E [String]

Right ["all"]

Methods

(~?) :: b -> b -> E [b]

RegexLike Regex b => MatchOnce Regex b [PosLen]

always succeeds

Methods

(~?) :: Regex -> b -> [PosLen]

RegexLike Regex b => MatchOnce Regex b [b]

always succeeds

Methods

(~?) :: Regex -> b -> [b]

class MatchAll pattern body out where

• pattern: String, ByteString, Regex
• body: String, ByteString

• out: out | E out

  • [[String]]
  • [[ByteString]]
  • [[PosLen]]

Minimal complete definition

(~*)

Methods

(~*) :: pattern -> body -> out

Instances

(Regex b, RegexLike Regex b) => MatchAll b b (E [[PosLen]])

Methods

(~*) :: b -> b -> E [[PosLen]]

(Regex b, RegexLike Regex b) => MatchAll b b (E [[b]])

"chilly" ~* "it's chilly inside, chilly outside"::E [[ByteString]]

Right [["chilly"],["chilly"]]   
     

Methods

(~*) :: b -> b -> E [[b]]

RegexLike Regex b => MatchAll Regex b [[PosLen]]

always succeeds

Methods

(~*) :: Regex -> b -> [[PosLen]]

RegexLike Regex b => MatchAll Regex b [[b]]

always succeeds

Methods

(~*) :: Regex -> b -> [[b]]

extract :: Extract source => (Int, Int) -> source -> source

extract takes an offset and length and has a default implementation of extract (off,len) source = before len (after off source)

extract is reexport from Text.Regex.Base.RegexLike