Text.Regex.Do.Type.Do

Documentation

newtype GroupReplacer b

see Text.Regex.Do.Pcre.ReplaceOpen defaultReplacer for example implementation

Constructors

GroupReplacer (MatchArray -> ReplaceAcc b -> ReplaceAcc b)

Instances

Enc enc => Enc' GroupReplacer enc

ReplaceOpen [] GroupReplacer

ReplaceOpen Maybe GroupReplacer

Replace' All Utf8_ ByteString GroupReplacer

>>> replacer::GroupReplacer (Utf8_ ByteString)
        replacer = defaultReplacer 1 tweak1
         where tweak1 bs1 = toByteString' $
                               if bs1 == toByteString' "左" then
                                     "ー右ー"
                                      else "?"

>>> runFn1 `shouldBe` toByteString "100メートルー右ー折後、左"
       where runFn1 =
                let rx1 = Pattern $ toByteString' "(?<=ル)(左)"
                    body1 = Body $ toByteString' "100メートル左折後、左"
                in replace (All rx1) replacer body1        

Replace' Once Utf8_ ByteString GroupReplacer

data ReplaceAcc b

Constructors

ReplaceAcc

Fields

acc :: b

content with some replacements made

pos_adj :: Int

position adjustment: group replacement length may differ from replaced text length

Instances

Functor ReplaceAcc

data Pattern a

Needle

Constructors

Pattern a

Instances

Functor Pattern

Applicative Pattern

(Regex a, Hint all, Replace' all a repl b) => Replace (all (Pattern a)) (repl b) (Body b) b

full typed arg

>>> replace (Once (Pattern "^a\\s")) (Replacement "A") (Body "a bc")

Replace' all enc b repl => Replace (all (Pattern (enc b))) (repl (enc b)) (Body (enc b)) b

full typed arg

>>> replace (Once $ Pattern $ Utf8_ "праздник")
        (Replacement $ Utf8_ "радость")
        (Body $ Utf8_ "экзамен - всегда праздник")

data Body b

Haystack

Constructors

Body b

Instances

Functor Body

Applicative Body

(Regex a, Hint all, Replace' all a repl b) => Replace (all (Pattern a)) (repl b) (Body b) b

full typed arg

>>> replace (Once (Pattern "^a\\s")) (Replacement "A") (Body "a bc")

Replace' all enc b repl => Replace (all (Pattern (enc b))) (repl (enc b)) (Body (enc b)) b

full typed arg

>>> replace (Once $ Pattern $ Utf8_ "праздник")
        (Replacement $ Utf8_ "радость")
        (Body $ Utf8_ "экзамен - всегда праздник")

data Replacement r

Constructors

Replacement r

Instances

Functor Replacement

Applicative Replacement

Enc enc => Enc' Replacement enc

ReplaceOpen [] Replacement

ReplaceOpen Maybe Replacement

Replace' All Utf8_ String Replacement

Replace' All Utf8_ ByteString Replacement

Replace' Once Utf8_ String Replacement

Replace' Once Utf8_ ByteString Replacement

type PosLen = (MatchOffset, MatchLength)

Offset, Length

newtype Utf8_ a

Constructors

Utf8_ a

values

Instances

Functor Utf8_

Applicative Utf8_

does not do any codec. Plain wrap / unwrap newtype

Enc Utf8_

MatchHint PosLen_ Utf8_ String

MatchHint PosLen_ Utf8_ ByteString

MatchHint PosLen' Utf8_ String

>>> PosLen' ("и"::String) =~ "бывает и хуже"

[(13,2)]

MatchHint PosLen' Utf8_ ByteString

MatchHint All Utf8_ String

MatchHint All Utf8_ ByteString

MatchHint Once Utf8_ String

>>> Once ("^all"::String) =~ "all the time"

["all"]

MatchHint Once Utf8_ ByteString

MatchHint Test Utf8_ String

MatchHint Test Utf8_ ByteString

>>> Test (toByteString "в") =~ toByteString "тихо в лесу"

True

Replace' All Utf8_ String Replacement

Replace' All Utf8_ ByteString Replacement

Replace' All Utf8_ ByteString GroupReplacer

>>> replacer::GroupReplacer (Utf8_ ByteString)
        replacer = defaultReplacer 1 tweak1
         where tweak1 bs1 = toByteString' $
                               if bs1 == toByteString' "左" then
                                     "ー右ー"
                                      else "?"

>>> runFn1 `shouldBe` toByteString "100メートルー右ー折後、左"
       where runFn1 =
                let rx1 = Pattern $ toByteString' "(?<=ル)(左)"
                    body1 = Body $ toByteString' "100メートル左折後、左"
                in replace (All rx1) replacer body1        

Replace' Once Utf8_ String Replacement

Replace' Once Utf8_ ByteString Replacement

Replace' Once Utf8_ ByteString GroupReplacer

Rx_ a b => Match Utf8_ a b Bool

test. Note that a and b may be different types e.g. ByteString and String

>>> toByteString "в" =~ ("тихо в лесу"::String)::Bool

True

Rx_ a b => Match Utf8_ a b [[PosLen]]

match all

Rx_ a b => Match Utf8_ a b [PosLen]

match once

>>> ("и"::String) =~ ("бывает и хуже"::String)::[PosLen]

[(13,2)]

Rx_ a b => Match Utf8_ a b [[b]]

match all

>>> ("well"::String) =~ ("all is well that ends well"::String)::[[String]]

[["well"],["well"]]

Rx_ a b => Match Utf8_ a b [b]

match once

precompiled regex as pattern

>>> let rx1 = makeRegexOpt' (Pattern $ toByteString' "左") [] []      --  add options as needed
        rx2 = Utf8_ <$> rx1
        m1 = U.match rx2 (Body $ toByteString' "100メートル左折後、左")::[ByteString]
     m1 `shouldBe` [toByteString "左"]        

Eq a => Eq (Utf8_ a)

Ord a => Ord (Utf8_ a)

Regex a => Regex (Utf8_ a)

Extract' (Utf8_ ByteString)

class Enc enc where

does not do any codec. Plain wrap / unwrap newtype

Methods

val :: enc a -> a

enc :: a -> enc a

Instances

Enc Utf8_

class Enc' f enc where

Methods

val' :: f (enc a) -> f a

enc' :: f a -> f (enc a)

Instances

Enc enc => Enc' Replacement enc

Enc enc => Enc' GroupReplacer enc