Text.Regex.Do.Type.MatchHint

Documentation

newtype Test a

Constructors

Test a

test: does body match pattern?

Instances

Hint Test

MatchHint Test String

MatchHint Test ByteString

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

True

MatchHint Test Utf8_ String

MatchHint Test Utf8_ ByteString

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

True

type F Test String = Bool

type F Test ByteString = Bool

type F Test String = Bool

type F Test ByteString = Bool

newtype Once a

Constructors

Once a

values

Instances

Functor Once

Applicative Once

Hint Once

Matchf Once b

MatchHint Once String

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

["all"]

MatchHint Once ByteString

MatchHint Once Utf8_ String

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

["all"]

MatchHint Once Utf8_ ByteString

Repl_ Maybe a repl b => Replace' Once a repl b

static replace for simple (no group) needle

for no-regex ByteString replacement see Text.Regex.Do.Split

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

"Abc"

dynamic group replace

>>> replace (Once (Pattern "\\w=(\\d{1,3})")) replacer $ Body "a=101 b=3 12"

"a=[1 0 1] b=3 12"

Replace' Once Utf8_ String Replacement

Replace' Once Utf8_ ByteString Replacement

Replace' Once Utf8_ ByteString GroupReplacer

(Regex a, Replace' Once a repl b) => Replace a (repl b) (Once b) b

hint Body

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

(Regex b, Replace' Once Utf8_ b repl, Enc' repl Utf8_) => Replace b (repl b) (Once b) b

hint Body

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

type H Once = Maybe MatchArray

type P Once = Maybe [PosLen]

type F Once String = [String]

type F Once ByteString = [ByteString]

type F Once String = [String]

type F Once ByteString = [ByteString]

newtype All a

Constructors

All a

values

Instances

Functor All

Applicative All

Hint All

Matchf All b

MatchHint All String

MatchHint All ByteString

MatchHint All Utf8_ String

MatchHint All Utf8_ ByteString

Repl_ [] a repl b => Replace' All a repl b

to tweak regex with Comp or Exec, see Text.Regex.Do.Type.Regex

dynamic group replace

custom replacer fn returns replacement value. See defaultReplacer

>>> replacer::GroupReplacer String
    replacer = defaultReplacer 1 tweak1
          where tweak1 str1 = case str1 of
                                "101" -> "[1 0 1]"
                                "3" -> "[ 3 ]"
                                otherwise -> trace str1 "?"

>>> replace (All (Pattern "\\w=(\\d{1,3})")) replacer $ Body "a=101 b=3 12"

"a=[1 0 1] b=[ 3 ] 12"

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        

(Regex a, Replace' All a repl b) => Replace a (repl b) (All b) b

hint Body

(Regex b, Replace' All Utf8_ b repl, Enc' repl Utf8_) => Replace b (repl b) (All b) b

hint Body

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

type H All = [MatchArray]

type P All = [[PosLen]]

type F All String = [[String]]

type F All ByteString = [[ByteString]]

type F All String = [[String]]

type F All ByteString = [[ByteString]]

newtype PosLen' a

Constructors

PosLen' a

once

Instances

Hint PosLen'

MatchHint PosLen' String

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

[(13,2)]

MatchHint PosLen' ByteString

MatchHint PosLen' Utf8_ String

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

[(13,2)]

MatchHint PosLen' Utf8_ ByteString

type F PosLen' String = [PosLen]

type F PosLen' ByteString = [PosLen]

type F PosLen' String = [PosLen]

type F PosLen' ByteString = [PosLen]

newtype PosLen_ a

Constructors

PosLen_ a

all

Instances

Hint PosLen_

MatchHint PosLen_ String

MatchHint PosLen_ ByteString

MatchHint PosLen_ Utf8_ String

MatchHint PosLen_ Utf8_ ByteString

type F PosLen_ String = [[PosLen]]

type F PosLen_ ByteString = [[PosLen]]

type F PosLen_ String = [[PosLen]]

type F PosLen_ ByteString = [[PosLen]]

class Hint hint where

Methods

unhint :: hint a -> a

hint :: a -> hint a

Instances

Hint PosLen_

Hint PosLen'

Hint All

Hint Once

Hint Test

swap :: Hint hint => hint a -> b -> hint b