Safe Haskell	Safe
Language	Haskell2010

Kleene.Functor

Contents

Synopsis

Documentation

data K c a Source #

Applicative Functor regular expression.

Instances

Functor (K c) Source #
Methods fmap :: (a -> b) -> K c a -> K c b # (<$) :: a -> K c b -> K c a #
Applicative (K c) Source #
Methods pure :: a -> K c a # (<>) :: K c (a -> b) -> K c a -> K c b # liftA2 :: (a -> b -> c) -> K c a -> K c b -> K c c # (>) :: K c a -> K c b -> K c b # (<*) :: K c a -> K c b -> K c a #
Alternative (K c) Source #
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] #
((~) * c Char, IsString a) => IsString (K c a) Source #
Methods fromString :: String -> K c a #
(~) * c Char => Pretty (K c a) Source #	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)*$
Methods pretty :: K c a -> String Source # prettyS :: K c a -> ShowS Source #

Star behaviour

Constructors

Greedy	`many`
NonGreedy	`few`

Instances

Bounded Greediness Source #
Methods minBound :: Greediness # maxBound :: Greediness #
Enum Greediness Source #
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 Source #
Methods (==) :: Greediness -> Greediness -> Bool # (/=) :: Greediness -> Greediness -> Bool #
Ord Greediness Source #
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 Source #
Methods showsPrec :: Int -> Greediness -> ShowS # show :: Greediness -> String # showList :: [Greediness] -> ShowS #

Constructors

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

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","")

>>> putPretty anyChar
^[^]$

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

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

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

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

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

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

>>> putPretty dot
^.$

>>> putPretty everything
^[^]*$

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

Matches nothing?

Matches whole input?

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

Match using regex-applicative

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

Convert to RE.

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

Convert to any Kleene

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

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 Source #

Convert K to RE from regex-applicative.

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