Kleene.Functor

Documentation

data K c a

Applicative Functor regular expression.

Instances

Functor (K c)

Defined in Kleene.Internal.Functor

Methods

fmap :: (a -> b) -> K c a -> K c b

(<$) :: a -> K c b -> K c a

Applicative (K c)

Defined in Kleene.Internal.Functor

Methods

pure :: a -> K c a

(<*>) :: K c (a -> b) -> K c a -> K c b

liftA2 :: (a -> b -> c0) -> K c a -> K c b -> K c c0

(*>) :: K c a -> K c b -> K c b

(<*) :: K c a -> K c b -> K c a

Alternative (K c)

Defined in Kleene.Internal.Functor

Methods

empty :: K c a

(<|>) :: K c a -> K c a -> K c a

some :: K c a -> K c [a]

many :: K c a -> K c [a]

Alt (K c)

Defined in Kleene.Internal.Functor

Methods

(<!>) :: K c a -> K c a -> K c a

some :: Applicative (K c) => K c a -> K c [a]

many :: Applicative (K c) => K c a -> K c [a]

Apply (K c)

Defined in Kleene.Internal.Functor

Methods

(<.>) :: K c (a -> b) -> K c a -> K c b

(.>) :: K c a -> K c b -> K c b

(<.) :: K c a -> K c b -> K c a

liftF2 :: (a -> b -> c0) -> K c a -> K c b -> K c c0

(c ~ Char, IsString a) => IsString (K c a)

Defined in Kleene.Internal.Functor

Methods

fromString :: String -> K c a

c ~ Char => Pretty (K c a)

Convert to non-matching JavaScript string which can be used as an argument to new RegExp

>>> putPretty ("foobar" :: K Char String)
^foobar$

>>> putPretty $ many ("foobar" :: K Char String)
^(foobar)*$

Defined in Kleene.Internal.Functor

Methods

pretty :: K c a -> String

prettyS :: K c a -> ShowS

data Greediness

Star behaviour

Constructors

Greedy

many

NonGreedy

few

Instances

Bounded Greediness

Defined in Kleene.Internal.Functor

Methods

minBound :: Greediness

maxBound :: Greediness

Enum Greediness

Defined in Kleene.Internal.Functor

Methods

succ :: Greediness -> Greediness

pred :: Greediness -> Greediness

toEnum :: Int -> Greediness

fromEnum :: Greediness -> Int

enumFrom :: Greediness -> [Greediness]

enumFromThen :: Greediness -> Greediness -> [Greediness]

enumFromTo :: Greediness -> Greediness -> [Greediness]

enumFromThenTo :: Greediness -> Greediness -> Greediness -> [Greediness]

Eq Greediness

Defined in Kleene.Internal.Functor

Methods

(==) :: Greediness -> Greediness -> Bool

(/=) :: Greediness -> Greediness -> Bool

Ord Greediness

Defined in Kleene.Internal.Functor

Methods

compare :: Greediness -> Greediness -> Ordering

(<) :: Greediness -> Greediness -> Bool

(<=) :: Greediness -> Greediness -> Bool

(>) :: Greediness -> Greediness -> Bool

(>=) :: Greediness -> Greediness -> Bool

max :: Greediness -> Greediness -> Greediness

min :: Greediness -> Greediness -> Greediness

Show Greediness

Defined in Kleene.Internal.Functor

Methods

showsPrec :: Int -> Greediness -> ShowS

show :: Greediness -> String

showList :: [Greediness] -> ShowS

Constructors

few :: K c a -> K c [a]

few, not many.

Let's define two similar regexps

>>> let re1 = liftA2 (,) (few  $ char 'a') (many $ char 'a')
>>> let re2 = liftA2 (,) (many $ char 'a') (few  $ char 'a')

Their RE behaviour is the same:

>>> C.equivalent (toRE re1) (toRE re2)
True

>>> map (C.match $ toRE re1) ["aaa","bbb"]
[True,False]

However, the RA behaviour is different!

>>> R.match (toRA re1) "aaaa"
Just ("","aaaa")

>>> R.match (toRA re2) "aaaa"
Just ("aaaa","")

anyChar :: (Ord c, Enum c, Bounded c) => K c c

>>> putPretty anyChar
^[^]$

oneof :: (Ord c, Enum c, Foldable f) => f c -> K c c

>>> putPretty $ oneof ("foobar" :: [Char])
^[a-bfor]$

char :: (Ord c, Enum c) => c -> K c c

>>> putPretty $ char 'x'
^x$

charRange :: (Enum c, Ord c) => c -> c -> K c c

>>> putPretty $ charRange 'a' 'z'
^[a-z]$

dot :: K Char Char

>>> putPretty dot
^.$

everything :: (Ord c, Enum c, Bounded c) => K c [c]

>>> putPretty everything
^[^]*$

everything1 :: (Ord c, Enum c, Bounded c) => K c [c]

>>> putPretty everything1
^[^][^]*$

Queries

isEmpty :: (Ord c, Enum c, Bounded c) => K c a -> Bool

Matches nothing?

isEverything :: (Ord c, Enum c, Bounded c) => K c a -> Bool

Matches whole input?

Matching

match :: K c a -> [c] -> Maybe a

Match using regex-applicative

Conversions

toRE :: (Ord c, Enum c, Bounded c) => K c a -> RE c

Convert to RE.

>>> putPretty (toRE $ many "foo" :: RE.RE Char)
^(foo)*$

toKleene :: FiniteKleene c k => K c a -> k

Convert to any Kleene

fromRE :: (Ord c, Enum c) => RE c -> K c [c]

Convert from RE.

Note: all REStars are converted to Greedy ones, it doesn't matter, as we don't capture anything.

>>> match (fromRE "foobar") "foobar"
Just "foobar"

>>> match (fromRE $ C.star "a" <> C.star "a") "aaaa"
Just "aaaa"

toRA :: K c a -> RE c a

Convert K to RE from regex-applicative.

>>> R.match (toRA ("xx" *> everything <* "zz" :: K Char String)) "xxyyyzz"
Just "yyy"

See also match.