{-# LANGUAGE Haskell2010, FlexibleInstances #-}
module Data.Monoid.Textual (
TextualMonoid(..)
)
where
import qualified Data.Foldable as Foldable
import qualified Data.Traversable as Traversable
import Data.Functor
import qualified Data.List as List
import qualified Data.Text as Text
import qualified Data.Text.Lazy as LazyText
import Data.Text (Text)
import Data.Monoid
import qualified Data.Sequence as Sequence
import Data.String (IsString(fromString))
import Data.Int (Int64)
import Data.Semigroup.Cancellative (LeftReductive)
import Data.Monoid.GCD (LeftGCDMonoid)
import Data.Monoid.Factorial (FactorialMonoid)
import qualified Data.Monoid.Factorial as Factorial
import Prelude hiding (all, any, break, concatMap, dropWhile, foldl, foldl1, foldr, foldr1, map,
scanl, scanl1, scanr, scanr1, span, takeWhile)
class (IsString t, LeftReductive t, LeftGCDMonoid t, FactorialMonoid t) => TextualMonoid t where
fromText :: Text -> t
singleton :: Char -> t
splitCharacterPrefix :: t -> Maybe (Char, t)
characterPrefix :: t -> Maybe Char
map :: (Char -> Char) -> t -> t
concatMap :: (Char -> t) -> t -> t
toString :: (t -> String) -> t -> String
any :: (Char -> Bool) -> t -> Bool
all :: (Char -> Bool) -> t -> Bool
foldl :: (a -> t -> a) -> (a -> Char -> a) -> a -> t -> a
foldl' :: (a -> t -> a) -> (a -> Char -> a) -> a -> t -> a
foldr :: (t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
scanl :: (Char -> Char -> Char) -> Char -> t -> t
scanl1 :: (Char -> Char -> Char) -> t -> t
scanr :: (Char -> Char -> Char) -> Char -> t -> t
scanr1 :: (Char -> Char -> Char) -> t -> t
mapAccumL :: (a -> Char -> (a, Char)) -> a -> t -> (a, t)
mapAccumR :: (a -> Char -> (a, Char)) -> a -> t -> (a, t)
takeWhile :: (t -> Bool) -> (Char -> Bool) -> t -> t
dropWhile :: (t -> Bool) -> (Char -> Bool) -> t -> t
break :: (t -> Bool) -> (Char -> Bool) -> t -> (t, t)
span :: (t -> Bool) -> (Char -> Bool) -> t -> (t, t)
spanMaybe :: s -> (s -> t -> Maybe s) -> (s -> Char -> Maybe s) -> t -> (t, t, s)
spanMaybe' :: s -> (s -> t -> Maybe s) -> (s -> Char -> Maybe s) -> t -> (t, t, s)
split :: (Char -> Bool) -> t -> [t]
find :: (Char -> Bool) -> t -> Maybe Char
elem :: Char -> t -> Bool
foldl_ :: (a -> Char -> a) -> a -> t -> a
foldl_' :: (a -> Char -> a) -> a -> t -> a
foldr_ :: (Char -> a -> a) -> a -> t -> a
takeWhile_ :: Bool -> (Char -> Bool) -> t -> t
dropWhile_ :: Bool -> (Char -> Bool) -> t -> t
break_ :: Bool -> (Char -> Bool) -> t -> (t, t)
span_ :: Bool -> (Char -> Bool) -> t -> (t, t)
spanMaybe_ :: s -> (s -> Char -> Maybe s) -> t -> (t, t, s)
spanMaybe_' :: s -> (s -> Char -> Maybe s) -> t -> (t, t, s)
fromText = String -> t
forall a. IsString a => String -> a
fromString (String -> t) -> (Text -> String) -> Text -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
Text.unpack
singleton = String -> t
forall a. IsString a => String -> a
fromString (String -> t) -> (Char -> String) -> Char -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> String -> String
forall a. a -> [a] -> [a]
:[])
characterPrefix = ((Char, t) -> Char) -> Maybe (Char, t) -> Maybe Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Char, t) -> Char
forall a b. (a, b) -> a
fst (Maybe (Char, t) -> Maybe Char)
-> (t -> Maybe (Char, t)) -> t -> Maybe Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> Maybe (Char, t)
forall t. TextualMonoid t => t -> Maybe (Char, t)
splitCharacterPrefix
map f :: Char -> Char
f = (Char -> t) -> t -> t
forall t. TextualMonoid t => (Char -> t) -> t -> t
concatMap (Char -> t
forall t. TextualMonoid t => Char -> t
singleton (Char -> t) -> (Char -> Char) -> Char -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char
f)
concatMap f :: Char -> t
f = (t -> t -> t) -> (Char -> t -> t) -> t -> t -> t
forall t a.
TextualMonoid t =>
(t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
foldr t -> t -> t
forall a. Monoid a => a -> a -> a
mappend (t -> t -> t
forall a. Monoid a => a -> a -> a
mappend (t -> t -> t) -> (Char -> t) -> Char -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> t
f) t
forall a. Monoid a => a
mempty
toString f :: t -> String
f = (t -> String -> String)
-> (Char -> String -> String) -> String -> t -> String
forall t a.
TextualMonoid t =>
(t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
foldr (String -> String -> String
forall a. Monoid a => a -> a -> a
mappend (String -> String -> String)
-> (t -> String) -> t -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> String
f) (:) []
all p :: Char -> Bool
p = (t -> Bool -> Bool) -> (Char -> Bool -> Bool) -> Bool -> t -> Bool
forall t a.
TextualMonoid t =>
(t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
foldr ((Bool -> Bool) -> t -> Bool -> Bool
forall a b. a -> b -> a
const Bool -> Bool
forall a. a -> a
id) (Bool -> Bool -> Bool
(&&) (Bool -> Bool -> Bool) -> (Char -> Bool) -> Char -> Bool -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
p) Bool
True
any p :: Char -> Bool
p = (t -> Bool -> Bool) -> (Char -> Bool -> Bool) -> Bool -> t -> Bool
forall t a.
TextualMonoid t =>
(t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
foldr ((Bool -> Bool) -> t -> Bool -> Bool
forall a b. a -> b -> a
const Bool -> Bool
forall a. a -> a
id) (Bool -> Bool -> Bool
(||) (Bool -> Bool -> Bool) -> (Char -> Bool) -> Char -> Bool -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
p) Bool
False
foldl ft :: a -> t -> a
ft fc :: a -> Char -> a
fc = (a -> t -> a) -> a -> t -> a
forall m a. Factorial m => (a -> m -> a) -> a -> m -> a
Factorial.foldl (\a :: a
a prime :: t
prime-> a -> (Char -> a) -> Maybe Char -> a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (a -> t -> a
ft a
a t
prime) (a -> Char -> a
fc a
a) (t -> Maybe Char
forall t. TextualMonoid t => t -> Maybe Char
characterPrefix t
prime))
foldr ft :: t -> a -> a
ft fc :: Char -> a -> a
fc = (t -> a -> a) -> a -> t -> a
forall m a. Factorial m => (m -> a -> a) -> a -> m -> a
Factorial.foldr (\prime :: t
prime-> (a -> a) -> (Char -> a -> a) -> Maybe Char -> a -> a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (t -> a -> a
ft t
prime) Char -> a -> a
fc (t -> Maybe Char
forall t. TextualMonoid t => t -> Maybe Char
characterPrefix t
prime))
foldl' ft :: a -> t -> a
ft fc :: a -> Char -> a
fc = (a -> t -> a) -> a -> t -> a
forall m a. Factorial m => (a -> m -> a) -> a -> m -> a
Factorial.foldl' (\a :: a
a prime :: t
prime-> a -> (Char -> a) -> Maybe Char -> a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (a -> t -> a
ft a
a t
prime) (a -> Char -> a
fc a
a) (t -> Maybe Char
forall t. TextualMonoid t => t -> Maybe Char
characterPrefix t
prime))
foldl_ = (a -> t -> a) -> (a -> Char -> a) -> a -> t -> a
forall t a.
TextualMonoid t =>
(a -> t -> a) -> (a -> Char -> a) -> a -> t -> a
foldl a -> t -> a
forall a b. a -> b -> a
const
foldr_ = (t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
forall t a.
TextualMonoid t =>
(t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
foldr ((a -> a) -> t -> a -> a
forall a b. a -> b -> a
const a -> a
forall a. a -> a
id)
foldl_' = (a -> t -> a) -> (a -> Char -> a) -> a -> t -> a
forall t a.
TextualMonoid t =>
(a -> t -> a) -> (a -> Char -> a) -> a -> t -> a
foldl' a -> t -> a
forall a b. a -> b -> a
const
scanl f :: Char -> Char -> Char
f c :: Char
c = t -> t -> t
forall a. Monoid a => a -> a -> a
mappend (Char -> t
forall t. TextualMonoid t => Char -> t
singleton Char
c) (t -> t) -> (t -> t) -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (t, Char) -> t
forall a b. (a, b) -> a
fst ((t, Char) -> t) -> (t -> (t, Char)) -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((t, Char) -> t -> (t, Char))
-> ((t, Char) -> Char -> (t, Char)) -> (t, Char) -> t -> (t, Char)
forall t a.
TextualMonoid t =>
(a -> t -> a) -> (a -> Char -> a) -> a -> t -> a
foldl (t, Char) -> t -> (t, Char)
forall t. Monoid t => (t, Char) -> t -> (t, Char)
foldlOther ((Char -> Char -> Char) -> (t, Char) -> Char -> (t, Char)
forall t.
TextualMonoid t =>
(Char -> Char -> Char) -> (t, Char) -> Char -> (t, Char)
foldlChars Char -> Char -> Char
f) (t
forall a. Monoid a => a
mempty, Char
c)
scanl1 f :: Char -> Char -> Char
f t :: t
t = case (t -> Maybe (t, t)
forall m. FactorialMonoid m => m -> Maybe (m, m)
Factorial.splitPrimePrefix t
t, t -> Maybe (Char, t)
forall t. TextualMonoid t => t -> Maybe (Char, t)
splitCharacterPrefix t
t)
of (Nothing, _) -> t
t
(Just (prefix :: t
prefix, suffix :: t
suffix), Nothing) -> t -> t -> t
forall a. Monoid a => a -> a -> a
mappend t
prefix ((Char -> Char -> Char) -> t -> t
forall t. TextualMonoid t => (Char -> Char -> Char) -> t -> t
scanl1 Char -> Char -> Char
f t
suffix)
(Just _, Just (c :: Char
c, suffix :: t
suffix)) -> (Char -> Char -> Char) -> Char -> t -> t
forall t.
TextualMonoid t =>
(Char -> Char -> Char) -> Char -> t -> t
scanl Char -> Char -> Char
f Char
c t
suffix
scanr f :: Char -> Char -> Char
f c :: Char
c = (t, Char) -> t
forall a b. (a, b) -> a
fst ((t, Char) -> t) -> (t -> (t, Char)) -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (t -> (t, Char) -> (t, Char))
-> (Char -> (t, Char) -> (t, Char)) -> (t, Char) -> t -> (t, Char)
forall t a.
TextualMonoid t =>
(t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
foldr t -> (t, Char) -> (t, Char)
forall t a. Monoid t => t -> (t, a) -> (t, a)
foldrOther ((Char -> Char -> Char) -> Char -> (t, Char) -> (t, Char)
forall t.
TextualMonoid t =>
(Char -> Char -> Char) -> Char -> (t, Char) -> (t, Char)
foldrChars Char -> Char -> Char
f) (Char -> t
forall t. TextualMonoid t => Char -> t
singleton Char
c, Char
c)
scanr1 f :: Char -> Char -> Char
f = (t, Maybe Char) -> t
forall a b. (a, b) -> a
fst ((t, Maybe Char) -> t) -> (t -> (t, Maybe Char)) -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (t -> (t, Maybe Char) -> (t, Maybe Char))
-> (Char -> (t, Maybe Char) -> (t, Maybe Char))
-> (t, Maybe Char)
-> t
-> (t, Maybe Char)
forall t a.
TextualMonoid t =>
(t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
foldr t -> (t, Maybe Char) -> (t, Maybe Char)
forall t a. Monoid t => t -> (t, a) -> (t, a)
foldrOther Char -> (t, Maybe Char) -> (t, Maybe Char)
forall a.
TextualMonoid a =>
Char -> (a, Maybe Char) -> (a, Maybe Char)
fc (t
forall a. Monoid a => a
mempty, Maybe Char
forall a. Maybe a
Nothing)
where fc :: Char -> (a, Maybe Char) -> (a, Maybe Char)
fc c :: Char
c (t :: a
t, Nothing) = (a -> a -> a
forall a. Monoid a => a -> a -> a
mappend (Char -> a
forall t. TextualMonoid t => Char -> t
singleton Char
c) a
t, Char -> Maybe Char
forall a. a -> Maybe a
Just Char
c)
fc c1 :: Char
c1 (t :: a
t, Just c2 :: Char
c2) = (a -> a -> a
forall a. Monoid a => a -> a -> a
mappend (Char -> a
forall t. TextualMonoid t => Char -> t
singleton Char
c') a
t, Char -> Maybe Char
forall a. a -> Maybe a
Just Char
c')
where c' :: Char
c' = Char -> Char -> Char
f Char
c1 Char
c2
mapAccumL f :: a -> Char -> (a, Char)
f a0 :: a
a0 = ((a, t) -> t -> (a, t))
-> ((a, t) -> Char -> (a, t)) -> (a, t) -> t -> (a, t)
forall t a.
TextualMonoid t =>
(a -> t -> a) -> (a -> Char -> a) -> a -> t -> a
foldl (a, t) -> t -> (a, t)
forall b a. Monoid b => (a, b) -> b -> (a, b)
ft (a, t) -> Char -> (a, t)
forall b. TextualMonoid b => (a, b) -> Char -> (a, b)
fc (a
a0, t
forall a. Monoid a => a
mempty)
where ft :: (a, b) -> b -> (a, b)
ft (a :: a
a, t1 :: b
t1) t2 :: b
t2 = (a
a, b -> b -> b
forall a. Monoid a => a -> a -> a
mappend b
t1 b
t2)
fc :: (a, b) -> Char -> (a, b)
fc (a :: a
a, t :: b
t) c :: Char
c = (a
a', b -> b -> b
forall a. Monoid a => a -> a -> a
mappend b
t (Char -> b
forall t. TextualMonoid t => Char -> t
singleton Char
c'))
where (a' :: a
a', c' :: Char
c') = a -> Char -> (a, Char)
f a
a Char
c
mapAccumR f :: a -> Char -> (a, Char)
f a0 :: a
a0 = (t -> (a, t) -> (a, t))
-> (Char -> (a, t) -> (a, t)) -> (a, t) -> t -> (a, t)
forall t a.
TextualMonoid t =>
(t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
foldr t -> (a, t) -> (a, t)
forall b a. Monoid b => b -> (a, b) -> (a, b)
ft Char -> (a, t) -> (a, t)
forall b. TextualMonoid b => Char -> (a, b) -> (a, b)
fc (a
a0, t
forall a. Monoid a => a
mempty)
where ft :: b -> (a, b) -> (a, b)
ft t1 :: b
t1 (a :: a
a, t2 :: b
t2) = (a
a, b -> b -> b
forall a. Monoid a => a -> a -> a
mappend b
t1 b
t2)
fc :: Char -> (a, b) -> (a, b)
fc c :: Char
c (a :: a
a, t :: b
t) = (a
a', b -> b -> b
forall a. Monoid a => a -> a -> a
mappend (Char -> b
forall t. TextualMonoid t => Char -> t
singleton Char
c') b
t)
where (a' :: a
a', c' :: Char
c') = a -> Char -> (a, Char)
f a
a Char
c
takeWhile pt :: t -> Bool
pt pc :: Char -> Bool
pc = (t, t) -> t
forall a b. (a, b) -> a
fst ((t, t) -> t) -> (t -> (t, t)) -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (t -> Bool) -> (Char -> Bool) -> t -> (t, t)
forall t.
TextualMonoid t =>
(t -> Bool) -> (Char -> Bool) -> t -> (t, t)
span t -> Bool
pt Char -> Bool
pc
dropWhile pt :: t -> Bool
pt pc :: Char -> Bool
pc = (t, t) -> t
forall a b. (a, b) -> b
snd ((t, t) -> t) -> (t -> (t, t)) -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (t -> Bool) -> (Char -> Bool) -> t -> (t, t)
forall t.
TextualMonoid t =>
(t -> Bool) -> (Char -> Bool) -> t -> (t, t)
span t -> Bool
pt Char -> Bool
pc
span pt :: t -> Bool
pt pc :: Char -> Bool
pc = (t -> Bool) -> t -> (t, t)
forall m. FactorialMonoid m => (m -> Bool) -> m -> (m, m)
Factorial.span (\prime :: t
prime-> Bool -> (Char -> Bool) -> Maybe Char -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (t -> Bool
pt t
prime) Char -> Bool
pc (t -> Maybe Char
forall t. TextualMonoid t => t -> Maybe Char
characterPrefix t
prime))
break pt :: t -> Bool
pt pc :: Char -> Bool
pc = (t -> Bool) -> t -> (t, t)
forall m. FactorialMonoid m => (m -> Bool) -> m -> (m, m)
Factorial.break (\prime :: t
prime-> Bool -> (Char -> Bool) -> Maybe Char -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (t -> Bool
pt t
prime) Char -> Bool
pc (t -> Maybe Char
forall t. TextualMonoid t => t -> Maybe Char
characterPrefix t
prime))
spanMaybe s0 :: s
s0 ft :: s -> t -> Maybe s
ft fc :: s -> Char -> Maybe s
fc t0 :: t
t0 = (t -> t) -> s -> t -> (t, t, s)
spanAfter t -> t
forall a. a -> a
id s
s0 t
t0
where spanAfter :: (t -> t) -> s -> t -> (t, t, s)
spanAfter g :: t -> t
g s :: s
s t :: t
t = case t -> Maybe (t, t)
forall m. FactorialMonoid m => m -> Maybe (m, m)
Factorial.splitPrimePrefix t
t
of Just (prime :: t
prime, rest :: t
rest) | Just s' :: s
s' <- Maybe s -> (Char -> Maybe s) -> Maybe Char -> Maybe s
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (s -> t -> Maybe s
ft s
s t
prime) (s -> Char -> Maybe s
fc s
s) (t -> Maybe Char
forall t. TextualMonoid t => t -> Maybe Char
characterPrefix t
prime) ->
(t -> t) -> s -> t -> (t, t, s)
spanAfter (t -> t
g (t -> t) -> (t -> t) -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> t -> t
forall a. Monoid a => a -> a -> a
mappend t
prime) s
s' t
rest
| Bool
otherwise -> (t -> t
g t
forall a. Monoid a => a
mempty, t
t, s
s)
Nothing -> (t
t0, t
t, s
s)
spanMaybe' s0 :: s
s0 ft :: s -> t -> Maybe s
ft fc :: s -> Char -> Maybe s
fc t0 :: t
t0 = (t -> t) -> s -> t -> (t, t, s)
spanAfter t -> t
forall a. a -> a
id s
s0 t
t0
where spanAfter :: (t -> t) -> s -> t -> (t, t, s)
spanAfter g :: t -> t
g s :: s
s t :: t
t = s -> (t, t, s) -> (t, t, s)
forall a b. a -> b -> b
seq s
s ((t, t, s) -> (t, t, s)) -> (t, t, s) -> (t, t, s)
forall a b. (a -> b) -> a -> b
$
case t -> Maybe (t, t)
forall m. FactorialMonoid m => m -> Maybe (m, m)
Factorial.splitPrimePrefix t
t
of Just (prime :: t
prime, rest :: t
rest) | Just s' :: s
s' <- Maybe s -> (Char -> Maybe s) -> Maybe Char -> Maybe s
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (s -> t -> Maybe s
ft s
s t
prime) (s -> Char -> Maybe s
fc s
s) (t -> Maybe Char
forall t. TextualMonoid t => t -> Maybe Char
characterPrefix t
prime) ->
(t -> t) -> s -> t -> (t, t, s)
spanAfter (t -> t
g (t -> t) -> (t -> t) -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> t -> t
forall a. Monoid a => a -> a -> a
mappend t
prime) s
s' t
rest
| Bool
otherwise -> (t -> t
g t
forall a. Monoid a => a
mempty, t
t, s
s)
Nothing -> (t
t0, t
t, s
s)
takeWhile_ = (t -> Bool) -> (Char -> Bool) -> t -> t
forall t.
TextualMonoid t =>
(t -> Bool) -> (Char -> Bool) -> t -> t
takeWhile ((t -> Bool) -> (Char -> Bool) -> t -> t)
-> (Bool -> t -> Bool) -> Bool -> (Char -> Bool) -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> t -> Bool
forall a b. a -> b -> a
const
dropWhile_ = (t -> Bool) -> (Char -> Bool) -> t -> t
forall t.
TextualMonoid t =>
(t -> Bool) -> (Char -> Bool) -> t -> t
dropWhile ((t -> Bool) -> (Char -> Bool) -> t -> t)
-> (Bool -> t -> Bool) -> Bool -> (Char -> Bool) -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> t -> Bool
forall a b. a -> b -> a
const
break_ = (t -> Bool) -> (Char -> Bool) -> t -> (t, t)
forall t.
TextualMonoid t =>
(t -> Bool) -> (Char -> Bool) -> t -> (t, t)
break ((t -> Bool) -> (Char -> Bool) -> t -> (t, t))
-> (Bool -> t -> Bool) -> Bool -> (Char -> Bool) -> t -> (t, t)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> t -> Bool
forall a b. a -> b -> a
const
span_ = (t -> Bool) -> (Char -> Bool) -> t -> (t, t)
forall t.
TextualMonoid t =>
(t -> Bool) -> (Char -> Bool) -> t -> (t, t)
span ((t -> Bool) -> (Char -> Bool) -> t -> (t, t))
-> (Bool -> t -> Bool) -> Bool -> (Char -> Bool) -> t -> (t, t)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> t -> Bool
forall a b. a -> b -> a
const
spanMaybe_ s :: s
s = s
-> (s -> t -> Maybe s) -> (s -> Char -> Maybe s) -> t -> (t, t, s)
forall t s.
TextualMonoid t =>
s
-> (s -> t -> Maybe s) -> (s -> Char -> Maybe s) -> t -> (t, t, s)
spanMaybe s
s (Maybe s -> t -> Maybe s
forall a b. a -> b -> a
const (Maybe s -> t -> Maybe s) -> (s -> Maybe s) -> s -> t -> Maybe s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> Maybe s
forall a. a -> Maybe a
Just)
spanMaybe_' s :: s
s = s
-> (s -> t -> Maybe s) -> (s -> Char -> Maybe s) -> t -> (t, t, s)
forall t s.
TextualMonoid t =>
s
-> (s -> t -> Maybe s) -> (s -> Char -> Maybe s) -> t -> (t, t, s)
spanMaybe' s
s (Maybe s -> t -> Maybe s
forall a b. a -> b -> a
const (Maybe s -> t -> Maybe s) -> (s -> Maybe s) -> s -> t -> Maybe s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> Maybe s
forall a. a -> Maybe a
Just)
split p :: Char -> Bool
p m :: t
m = t
prefix t -> [t] -> [t]
forall a. a -> [a] -> [a]
: [t]
splitRest
where (prefix :: t
prefix, rest :: t
rest) = (t -> Bool) -> (Char -> Bool) -> t -> (t, t)
forall t.
TextualMonoid t =>
(t -> Bool) -> (Char -> Bool) -> t -> (t, t)
break (Bool -> t -> Bool
forall a b. a -> b -> a
const Bool
False) Char -> Bool
p t
m
splitRest :: [t]
splitRest = case t -> Maybe (Char, t)
forall t. TextualMonoid t => t -> Maybe (Char, t)
splitCharacterPrefix t
rest
of Nothing -> []
Just (_, tl :: t
tl) -> (Char -> Bool) -> t -> [t]
forall t. TextualMonoid t => (Char -> Bool) -> t -> [t]
split Char -> Bool
p t
tl
find p :: Char -> Bool
p = (t -> Maybe Char -> Maybe Char)
-> (Char -> Maybe Char -> Maybe Char)
-> Maybe Char
-> t
-> Maybe Char
forall t a.
TextualMonoid t =>
(t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
foldr ((Maybe Char -> Maybe Char) -> t -> Maybe Char -> Maybe Char
forall a b. a -> b -> a
const Maybe Char -> Maybe Char
forall a. a -> a
id) (\c :: Char
c r :: Maybe Char
r-> if Char -> Bool
p Char
c then Char -> Maybe Char
forall a. a -> Maybe a
Just Char
c else Maybe Char
r) Maybe Char
forall a. Maybe a
Nothing
elem c :: Char
c = (Char -> Bool) -> t -> Bool
forall t. TextualMonoid t => (Char -> Bool) -> t -> Bool
any (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
c)
{-# INLINE characterPrefix #-}
{-# INLINE concatMap #-}
{-# INLINE dropWhile #-}
{-# INLINE fromText #-}
{-# INLINE map #-}
{-# INLINE mapAccumL #-}
{-# INLINE mapAccumR #-}
{-# INLINE scanl #-}
{-# INLINE scanl1 #-}
{-# INLINE scanr #-}
{-# INLINE scanr1 #-}
{-# INLINE singleton #-}
{-# INLINE spanMaybe #-}
{-# INLINE spanMaybe' #-}
{-# INLINE split #-}
{-# INLINE takeWhile #-}
{-# INLINE foldl_ #-}
{-# INLINE foldl_' #-}
{-# INLINE foldr_ #-}
{-# INLINE spanMaybe_ #-}
{-# INLINE spanMaybe_' #-}
{-# INLINE span_ #-}
{-# INLINE break_ #-}
{-# INLINE takeWhile_ #-}
{-# INLINE dropWhile_ #-}
{-# MINIMAL splitCharacterPrefix #-}
foldlChars :: TextualMonoid t => (Char -> Char -> Char) -> (t, Char) -> Char -> (t, Char)
foldlOther :: Monoid t => (t, Char) -> t -> (t, Char)
foldrChars :: TextualMonoid t => (Char -> Char -> Char) -> Char -> (t, Char) -> (t, Char)
foldrOther :: Monoid t => t -> (t, a) -> (t, a)
foldlChars :: (Char -> Char -> Char) -> (t, Char) -> Char -> (t, Char)
foldlChars f :: Char -> Char -> Char
f (t :: t
t, c1 :: Char
c1) c2 :: Char
c2 = (t -> t -> t
forall a. Monoid a => a -> a -> a
mappend t
t (Char -> t
forall t. TextualMonoid t => Char -> t
singleton Char
c'), Char
c')
where c' :: Char
c' = Char -> Char -> Char
f Char
c1 Char
c2
foldlOther :: (t, Char) -> t -> (t, Char)
foldlOther (t1 :: t
t1, c :: Char
c) t2 :: t
t2 = (t -> t -> t
forall a. Monoid a => a -> a -> a
mappend t
t1 t
t2, Char
c)
foldrChars :: (Char -> Char -> Char) -> Char -> (t, Char) -> (t, Char)
foldrChars f :: Char -> Char -> Char
f c1 :: Char
c1 (t :: t
t, c2 :: Char
c2) = (t -> t -> t
forall a. Monoid a => a -> a -> a
mappend (Char -> t
forall t. TextualMonoid t => Char -> t
singleton Char
c') t
t, Char
c')
where c' :: Char
c' = Char -> Char -> Char
f Char
c1 Char
c2
foldrOther :: t -> (t, a) -> (t, a)
foldrOther t1 :: t
t1 (t2 :: t
t2, c :: a
c) = (t -> t -> t
forall a. Monoid a => a -> a -> a
mappend t
t1 t
t2, a
c)
instance TextualMonoid String where
fromText :: Text -> String
fromText = Text -> String
Text.unpack
singleton :: Char -> String
singleton c :: Char
c = [Char
c]
splitCharacterPrefix :: String -> Maybe (Char, String)
splitCharacterPrefix (c :: Char
c:rest :: String
rest) = (Char, String) -> Maybe (Char, String)
forall a. a -> Maybe a
Just (Char
c, String
rest)
splitCharacterPrefix [] = Maybe (Char, String)
forall a. Maybe a
Nothing
characterPrefix :: String -> Maybe Char
characterPrefix (c :: Char
c:_) = Char -> Maybe Char
forall a. a -> Maybe a
Just Char
c
characterPrefix [] = Maybe Char
forall a. Maybe a
Nothing
map :: (Char -> Char) -> String -> String
map = (Char -> Char) -> String -> String
forall a b. (a -> b) -> [a] -> [b]
List.map
concatMap :: (Char -> String) -> String -> String
concatMap = (Char -> String) -> String -> String
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
List.concatMap
toString :: (String -> String) -> String -> String
toString = (String -> String) -> (String -> String) -> String -> String
forall a b. a -> b -> a
const String -> String
forall a. a -> a
id
any :: (Char -> Bool) -> String -> Bool
any = (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.any
all :: (Char -> Bool) -> String -> Bool
all = (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.all
foldl :: (a -> String -> a) -> (a -> Char -> a) -> a -> String -> a
foldl = ((a -> Char -> a) -> a -> String -> a)
-> (a -> String -> a) -> (a -> Char -> a) -> a -> String -> a
forall a b. a -> b -> a
const (a -> Char -> a) -> a -> String -> a
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl
foldl' :: (a -> String -> a) -> (a -> Char -> a) -> a -> String -> a
foldl' = ((a -> Char -> a) -> a -> String -> a)
-> (a -> String -> a) -> (a -> Char -> a) -> a -> String -> a
forall a b. a -> b -> a
const (a -> Char -> a) -> a -> String -> a
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl'
foldr :: (String -> a -> a) -> (Char -> a -> a) -> a -> String -> a
foldr = ((Char -> a -> a) -> a -> String -> a)
-> (String -> a -> a) -> (Char -> a -> a) -> a -> String -> a
forall a b. a -> b -> a
const (Char -> a -> a) -> a -> String -> a
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
List.foldr
scanl :: (Char -> Char -> Char) -> Char -> String -> String
scanl = (Char -> Char -> Char) -> Char -> String -> String
forall b a. (b -> a -> b) -> b -> [a] -> [b]
List.scanl
scanl1 :: (Char -> Char -> Char) -> String -> String
scanl1 = (Char -> Char -> Char) -> String -> String
forall a. (a -> a -> a) -> [a] -> [a]
List.scanl1
scanr :: (Char -> Char -> Char) -> Char -> String -> String
scanr = (Char -> Char -> Char) -> Char -> String -> String
forall a b. (a -> b -> b) -> b -> [a] -> [b]
List.scanr
scanr1 :: (Char -> Char -> Char) -> String -> String
scanr1 = (Char -> Char -> Char) -> String -> String
forall a. (a -> a -> a) -> [a] -> [a]
List.scanr1
mapAccumL :: (a -> Char -> (a, Char)) -> a -> String -> (a, String)
mapAccumL = (a -> Char -> (a, Char)) -> a -> String -> (a, String)
forall (t :: * -> *) a b c.
Traversable t =>
(a -> b -> (a, c)) -> a -> t b -> (a, t c)
List.mapAccumL
mapAccumR :: (a -> Char -> (a, Char)) -> a -> String -> (a, String)
mapAccumR = (a -> Char -> (a, Char)) -> a -> String -> (a, String)
forall (t :: * -> *) a b c.
Traversable t =>
(a -> b -> (a, c)) -> a -> t b -> (a, t c)
List.mapAccumR
takeWhile :: (String -> Bool) -> (Char -> Bool) -> String -> String
takeWhile _ = (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
List.takeWhile
dropWhile :: (String -> Bool) -> (Char -> Bool) -> String -> String
dropWhile _ = (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
List.dropWhile
break :: (String -> Bool) -> (Char -> Bool) -> String -> (String, String)
break _ = (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
List.break
span :: (String -> Bool) -> (Char -> Bool) -> String -> (String, String)
span _ = (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
List.span
spanMaybe :: s
-> (s -> String -> Maybe s)
-> (s -> Char -> Maybe s)
-> String
-> (String, String, s)
spanMaybe s0 :: s
s0 _ft :: s -> String -> Maybe s
_ft fc :: s -> Char -> Maybe s
fc l :: String
l = (String -> String
prefix' [], String -> String
suffix' [], s
s')
where (prefix' :: String -> String
prefix', suffix' :: String -> String
suffix', s' :: s
s', _) = ((String -> String, String -> String, s, Bool)
-> Char -> (String -> String, String -> String, s, Bool))
-> (String -> String, String -> String, s, Bool)
-> String
-> (String -> String, String -> String, s, Bool)
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (String -> String, String -> String, s, Bool)
-> Char -> (String -> String, String -> String, s, Bool)
forall c.
(String -> c, String -> String, s, Bool)
-> Char -> (String -> c, String -> String, s, Bool)
g (String -> String
forall a. a -> a
id, String -> String
forall a. a -> a
id, s
s0, Bool
True) String
l
g :: (String -> c, String -> String, s, Bool)
-> Char -> (String -> c, String -> String, s, Bool)
g (prefix :: String -> c
prefix, suffix :: String -> String
suffix, s :: s
s, live :: Bool
live) c :: Char
c | Bool
live, Just s1 :: s
s1 <- s -> Char -> Maybe s
fc s
s Char
c = (String -> c
prefix (String -> c) -> (String -> String) -> String -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char
cChar -> String -> String
forall a. a -> [a] -> [a]
:), String -> String
forall a. a -> a
id, s
s1, Bool
True)
| Bool
otherwise = (String -> c
prefix, String -> String
suffix (String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char
cChar -> String -> String
forall a. a -> [a] -> [a]
:), s
s, Bool
False)
spanMaybe' :: s
-> (s -> String -> Maybe s)
-> (s -> Char -> Maybe s)
-> String
-> (String, String, s)
spanMaybe' s0 :: s
s0 _ft :: s -> String -> Maybe s
_ft fc :: s -> Char -> Maybe s
fc l :: String
l = (String -> String
prefix' [], String -> String
suffix' [], s
s')
where (prefix' :: String -> String
prefix', suffix' :: String -> String
suffix', s' :: s
s', _) = ((String -> String, String -> String, s, Bool)
-> Char -> (String -> String, String -> String, s, Bool))
-> (String -> String, String -> String, s, Bool)
-> String
-> (String -> String, String -> String, s, Bool)
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (String -> String, String -> String, s, Bool)
-> Char -> (String -> String, String -> String, s, Bool)
forall c.
(String -> c, String -> String, s, Bool)
-> Char -> (String -> c, String -> String, s, Bool)
g (String -> String
forall a. a -> a
id, String -> String
forall a. a -> a
id, s
s0, Bool
True) String
l
g :: (String -> c, String -> String, s, Bool)
-> Char -> (String -> c, String -> String, s, Bool)
g (prefix :: String -> c
prefix, suffix :: String -> String
suffix, s :: s
s, live :: Bool
live) c :: Char
c | Bool
live, Just s1 :: s
s1 <- s -> Char -> Maybe s
fc s
s Char
c = s
-> (String -> c, String -> String, s, Bool)
-> (String -> c, String -> String, s, Bool)
forall a b. a -> b -> b
seq s
s1 (String -> c
prefix (String -> c) -> (String -> String) -> String -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char
cChar -> String -> String
forall a. a -> [a] -> [a]
:), String -> String
forall a. a -> a
id, s
s1, Bool
True)
| Bool
otherwise = (String -> c
prefix, String -> String
suffix (String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char
cChar -> String -> String
forall a. a -> [a] -> [a]
:), s
s, Bool
False)
find :: (Char -> Bool) -> String -> Maybe Char
find = (Char -> Bool) -> String -> Maybe Char
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
List.find
elem :: Char -> String -> Bool
elem = Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
List.elem
{-# INLINE all #-}
{-# INLINE any #-}
{-# INLINE break #-}
{-# INLINE characterPrefix #-}
{-# INLINE concatMap #-}
{-# INLINE dropWhile #-}
{-# INLINE elem #-}
{-# INLINE find #-}
{-# INLINE foldl #-}
{-# INLINE foldl' #-}
{-# INLINE foldr #-}
{-# INLINE fromText #-}
{-# INLINE map #-}
{-# INLINE mapAccumL #-}
{-# INLINE mapAccumR #-}
{-# INLINE scanl #-}
{-# INLINE scanl1 #-}
{-# INLINE scanr #-}
{-# INLINE scanr1 #-}
{-# INLINE singleton #-}
{-# INLINE span #-}
{-# INLINE spanMaybe #-}
{-# INLINE spanMaybe' #-}
{-# INLINE splitCharacterPrefix #-}
{-# INLINE takeWhile #-}
instance TextualMonoid Text where
fromText :: Text -> Text
fromText = Text -> Text
forall a. a -> a
id
singleton :: Char -> Text
singleton = Char -> Text
Text.singleton
splitCharacterPrefix :: Text -> Maybe (Char, Text)
splitCharacterPrefix = Text -> Maybe (Char, Text)
Text.uncons
characterPrefix :: Text -> Maybe Char
characterPrefix t :: Text
t = if Text -> Bool
Text.null Text
t then Maybe Char
forall a. Maybe a
Nothing else Char -> Maybe Char
forall a. a -> Maybe a
Just (Text -> Char
Text.head Text
t)
map :: (Char -> Char) -> Text -> Text
map = (Char -> Char) -> Text -> Text
Text.map
concatMap :: (Char -> Text) -> Text -> Text
concatMap = (Char -> Text) -> Text -> Text
Text.concatMap
toString :: (Text -> String) -> Text -> String
toString = (Text -> String) -> (Text -> String) -> Text -> String
forall a b. a -> b -> a
const Text -> String
Text.unpack
any :: (Char -> Bool) -> Text -> Bool
any = (Char -> Bool) -> Text -> Bool
Text.any
all :: (Char -> Bool) -> Text -> Bool
all = (Char -> Bool) -> Text -> Bool
Text.all
foldl :: (a -> Text -> a) -> (a -> Char -> a) -> a -> Text -> a
foldl = ((a -> Char -> a) -> a -> Text -> a)
-> (a -> Text -> a) -> (a -> Char -> a) -> a -> Text -> a
forall a b. a -> b -> a
const (a -> Char -> a) -> a -> Text -> a
forall a. (a -> Char -> a) -> a -> Text -> a
Text.foldl
foldl' :: (a -> Text -> a) -> (a -> Char -> a) -> a -> Text -> a
foldl' = ((a -> Char -> a) -> a -> Text -> a)
-> (a -> Text -> a) -> (a -> Char -> a) -> a -> Text -> a
forall a b. a -> b -> a
const (a -> Char -> a) -> a -> Text -> a
forall a. (a -> Char -> a) -> a -> Text -> a
Text.foldl'
foldr :: (Text -> a -> a) -> (Char -> a -> a) -> a -> Text -> a
foldr = ((Char -> a -> a) -> a -> Text -> a)
-> (Text -> a -> a) -> (Char -> a -> a) -> a -> Text -> a
forall a b. a -> b -> a
const (Char -> a -> a) -> a -> Text -> a
forall a. (Char -> a -> a) -> a -> Text -> a
Text.foldr
scanl :: (Char -> Char -> Char) -> Char -> Text -> Text
scanl = (Char -> Char -> Char) -> Char -> Text -> Text
Text.scanl
scanl1 :: (Char -> Char -> Char) -> Text -> Text
scanl1 = (Char -> Char -> Char) -> Text -> Text
Text.scanl1
scanr :: (Char -> Char -> Char) -> Char -> Text -> Text
scanr = (Char -> Char -> Char) -> Char -> Text -> Text
Text.scanr
scanr1 :: (Char -> Char -> Char) -> Text -> Text
scanr1 = (Char -> Char -> Char) -> Text -> Text
Text.scanr1
mapAccumL :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
mapAccumL = (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
forall a. (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
Text.mapAccumL
mapAccumR :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
mapAccumR = (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
forall a. (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
Text.mapAccumR
takeWhile :: (Text -> Bool) -> (Char -> Bool) -> Text -> Text
takeWhile _ = (Char -> Bool) -> Text -> Text
Text.takeWhile
dropWhile :: (Text -> Bool) -> (Char -> Bool) -> Text -> Text
dropWhile _ = (Char -> Bool) -> Text -> Text
Text.dropWhile
break :: (Text -> Bool) -> (Char -> Bool) -> Text -> (Text, Text)
break _ = (Char -> Bool) -> Text -> (Text, Text)
Text.break
span :: (Text -> Bool) -> (Char -> Bool) -> Text -> (Text, Text)
span _ = (Char -> Bool) -> Text -> (Text, Text)
Text.span
spanMaybe :: s
-> (s -> Text -> Maybe s)
-> (s -> Char -> Maybe s)
-> Text
-> (Text, Text, s)
spanMaybe s0 :: s
s0 _ft :: s -> Text -> Maybe s
_ft fc :: s -> Char -> Maybe s
fc t :: Text
t = case (Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s))
-> ((Int, s) -> (Int, s)) -> Text -> (Int, s) -> (Int, s)
forall a. (Char -> a -> a) -> a -> Text -> a
Text.foldr Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
g (Int, s) -> (Int, s)
forall a. a -> a
id Text
t (0, s
s0)
of (i :: Int
i, s' :: s
s') | (prefix :: Text
prefix, suffix :: Text
suffix) <- Int -> Text -> (Text, Text)
Text.splitAt Int
i Text
t -> (Text
prefix, Text
suffix, s
s')
where g :: Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
g c :: Char
c cont :: (Int, s) -> (Int, s)
cont (i :: Int
i, s :: s
s) | Just s' :: s
s' <- s -> Char -> Maybe s
fc s
s Char
c = let i' :: Int
i' = Int -> Int
forall a. Enum a => a -> a
succ Int
i :: Int in Int -> (Int, s) -> (Int, s)
forall a b. a -> b -> b
seq Int
i' ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
forall a b. (a -> b) -> a -> b
$ (Int, s) -> (Int, s)
cont (Int
i', s
s')
| Bool
otherwise = (Int
i, s
s)
spanMaybe' :: s
-> (s -> Text -> Maybe s)
-> (s -> Char -> Maybe s)
-> Text
-> (Text, Text, s)
spanMaybe' s0 :: s
s0 _ft :: s -> Text -> Maybe s
_ft fc :: s -> Char -> Maybe s
fc t :: Text
t = case (Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s))
-> ((Int, s) -> (Int, s)) -> Text -> (Int, s) -> (Int, s)
forall a. (Char -> a -> a) -> a -> Text -> a
Text.foldr Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
g (Int, s) -> (Int, s)
forall a. a -> a
id Text
t (0, s
s0)
of (i :: Int
i, s' :: s
s') | (prefix :: Text
prefix, suffix :: Text
suffix) <- Int -> Text -> (Text, Text)
Text.splitAt Int
i Text
t -> (Text
prefix, Text
suffix, s
s')
where g :: Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
g c :: Char
c cont :: (Int, s) -> (Int, s)
cont (i :: Int
i, s :: s
s) | Just s' :: s
s' <- s -> Char -> Maybe s
fc s
s Char
c = let i' :: Int
i' = Int -> Int
forall a. Enum a => a -> a
succ Int
i :: Int in Int -> (Int, s) -> (Int, s)
forall a b. a -> b -> b
seq Int
i' ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
forall a b. (a -> b) -> a -> b
$ s -> (Int, s) -> (Int, s)
forall a b. a -> b -> b
seq s
s' ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
forall a b. (a -> b) -> a -> b
$ (Int, s) -> (Int, s)
cont (Int
i', s
s')
| Bool
otherwise = (Int
i, s
s)
split :: (Char -> Bool) -> Text -> [Text]
split = (Char -> Bool) -> Text -> [Text]
Text.split
find :: (Char -> Bool) -> Text -> Maybe Char
find = (Char -> Bool) -> Text -> Maybe Char
Text.find
{-# INLINE all #-}
{-# INLINE any #-}
{-# INLINE break #-}
{-# INLINE characterPrefix #-}
{-# INLINE concatMap #-}
{-# INLINE dropWhile #-}
{-# INLINE find #-}
{-# INLINE foldl #-}
{-# INLINE foldl' #-}
{-# INLINE foldr #-}
{-# INLINE fromText #-}
{-# INLINE map #-}
{-# INLINE mapAccumL #-}
{-# INLINE mapAccumR #-}
{-# INLINE scanl #-}
{-# INLINE scanl1 #-}
{-# INLINE scanr #-}
{-# INLINE scanr1 #-}
{-# INLINE singleton #-}
{-# INLINE span #-}
{-# INLINE spanMaybe #-}
{-# INLINE spanMaybe' #-}
{-# INLINE split #-}
{-# INLINE splitCharacterPrefix #-}
{-# INLINE takeWhile #-}
instance TextualMonoid LazyText.Text where
fromText :: Text -> Text
fromText = Text -> Text
LazyText.fromStrict
singleton :: Char -> Text
singleton = Char -> Text
LazyText.singleton
splitCharacterPrefix :: Text -> Maybe (Char, Text)
splitCharacterPrefix = Text -> Maybe (Char, Text)
LazyText.uncons
characterPrefix :: Text -> Maybe Char
characterPrefix t :: Text
t = if Text -> Bool
LazyText.null Text
t then Maybe Char
forall a. Maybe a
Nothing else Char -> Maybe Char
forall a. a -> Maybe a
Just (Text -> Char
LazyText.head Text
t)
map :: (Char -> Char) -> Text -> Text
map = (Char -> Char) -> Text -> Text
LazyText.map
concatMap :: (Char -> Text) -> Text -> Text
concatMap = (Char -> Text) -> Text -> Text
LazyText.concatMap
toString :: (Text -> String) -> Text -> String
toString = (Text -> String) -> (Text -> String) -> Text -> String
forall a b. a -> b -> a
const Text -> String
LazyText.unpack
any :: (Char -> Bool) -> Text -> Bool
any = (Char -> Bool) -> Text -> Bool
LazyText.any
all :: (Char -> Bool) -> Text -> Bool
all = (Char -> Bool) -> Text -> Bool
LazyText.all
foldl :: (a -> Text -> a) -> (a -> Char -> a) -> a -> Text -> a
foldl = ((a -> Char -> a) -> a -> Text -> a)
-> (a -> Text -> a) -> (a -> Char -> a) -> a -> Text -> a
forall a b. a -> b -> a
const (a -> Char -> a) -> a -> Text -> a
forall a. (a -> Char -> a) -> a -> Text -> a
LazyText.foldl
foldl' :: (a -> Text -> a) -> (a -> Char -> a) -> a -> Text -> a
foldl' = ((a -> Char -> a) -> a -> Text -> a)
-> (a -> Text -> a) -> (a -> Char -> a) -> a -> Text -> a
forall a b. a -> b -> a
const (a -> Char -> a) -> a -> Text -> a
forall a. (a -> Char -> a) -> a -> Text -> a
LazyText.foldl'
foldr :: (Text -> a -> a) -> (Char -> a -> a) -> a -> Text -> a
foldr = ((Char -> a -> a) -> a -> Text -> a)
-> (Text -> a -> a) -> (Char -> a -> a) -> a -> Text -> a
forall a b. a -> b -> a
const (Char -> a -> a) -> a -> Text -> a
forall a. (Char -> a -> a) -> a -> Text -> a
LazyText.foldr
scanl :: (Char -> Char -> Char) -> Char -> Text -> Text
scanl = (Char -> Char -> Char) -> Char -> Text -> Text
LazyText.scanl
scanl1 :: (Char -> Char -> Char) -> Text -> Text
scanl1 = (Char -> Char -> Char) -> Text -> Text
LazyText.scanl1
scanr :: (Char -> Char -> Char) -> Char -> Text -> Text
scanr = (Char -> Char -> Char) -> Char -> Text -> Text
LazyText.scanr
scanr1 :: (Char -> Char -> Char) -> Text -> Text
scanr1 = (Char -> Char -> Char) -> Text -> Text
LazyText.scanr1
mapAccumL :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
mapAccumL = (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
forall a. (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
LazyText.mapAccumL
mapAccumR :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
mapAccumR = (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
forall a. (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
LazyText.mapAccumR
takeWhile :: (Text -> Bool) -> (Char -> Bool) -> Text -> Text
takeWhile _ = (Char -> Bool) -> Text -> Text
LazyText.takeWhile
dropWhile :: (Text -> Bool) -> (Char -> Bool) -> Text -> Text
dropWhile _ = (Char -> Bool) -> Text -> Text
LazyText.dropWhile
break :: (Text -> Bool) -> (Char -> Bool) -> Text -> (Text, Text)
break _ = (Char -> Bool) -> Text -> (Text, Text)
LazyText.break
span :: (Text -> Bool) -> (Char -> Bool) -> Text -> (Text, Text)
span _ = (Char -> Bool) -> Text -> (Text, Text)
LazyText.span
spanMaybe :: s
-> (s -> Text -> Maybe s)
-> (s -> Char -> Maybe s)
-> Text
-> (Text, Text, s)
spanMaybe s0 :: s
s0 _ft :: s -> Text -> Maybe s
_ft fc :: s -> Char -> Maybe s
fc t :: Text
t = case (Char -> ((Int64, s) -> (Int64, s)) -> (Int64, s) -> (Int64, s))
-> ((Int64, s) -> (Int64, s)) -> Text -> (Int64, s) -> (Int64, s)
forall a. (Char -> a -> a) -> a -> Text -> a
LazyText.foldr Char -> ((Int64, s) -> (Int64, s)) -> (Int64, s) -> (Int64, s)
g (Int64, s) -> (Int64, s)
forall a. a -> a
id Text
t (0, s
s0)
of (i :: Int64
i, s' :: s
s') | (prefix :: Text
prefix, suffix :: Text
suffix) <- Int64 -> Text -> (Text, Text)
LazyText.splitAt Int64
i Text
t -> (Text
prefix, Text
suffix, s
s')
where g :: Char -> ((Int64, s) -> (Int64, s)) -> (Int64, s) -> (Int64, s)
g c :: Char
c cont :: (Int64, s) -> (Int64, s)
cont (i :: Int64
i, s :: s
s) | Just s' :: s
s' <- s -> Char -> Maybe s
fc s
s Char
c = let i' :: Int64
i' = Int64 -> Int64
forall a. Enum a => a -> a
succ Int64
i :: Int64 in Int64 -> (Int64, s) -> (Int64, s)
forall a b. a -> b -> b
seq Int64
i' ((Int64, s) -> (Int64, s)) -> (Int64, s) -> (Int64, s)
forall a b. (a -> b) -> a -> b
$ (Int64, s) -> (Int64, s)
cont (Int64
i', s
s')
| Bool
otherwise = (Int64
i, s
s)
spanMaybe' :: s
-> (s -> Text -> Maybe s)
-> (s -> Char -> Maybe s)
-> Text
-> (Text, Text, s)
spanMaybe' s0 :: s
s0 _ft :: s -> Text -> Maybe s
_ft fc :: s -> Char -> Maybe s
fc t :: Text
t = case (Char -> ((Int64, s) -> (Int64, s)) -> (Int64, s) -> (Int64, s))
-> ((Int64, s) -> (Int64, s)) -> Text -> (Int64, s) -> (Int64, s)
forall a. (Char -> a -> a) -> a -> Text -> a
LazyText.foldr Char -> ((Int64, s) -> (Int64, s)) -> (Int64, s) -> (Int64, s)
g (Int64, s) -> (Int64, s)
forall a. a -> a
id Text
t (0, s
s0)
of (i :: Int64
i, s' :: s
s') | (prefix :: Text
prefix, suffix :: Text
suffix) <- Int64 -> Text -> (Text, Text)
LazyText.splitAt Int64
i Text
t -> (Text
prefix, Text
suffix, s
s')
where g :: Char -> ((Int64, s) -> (Int64, s)) -> (Int64, s) -> (Int64, s)
g c :: Char
c cont :: (Int64, s) -> (Int64, s)
cont (i :: Int64
i, s :: s
s) | Just s' :: s
s' <- s -> Char -> Maybe s
fc s
s Char
c = let i' :: Int64
i' = Int64 -> Int64
forall a. Enum a => a -> a
succ Int64
i :: Int64 in Int64 -> (Int64, s) -> (Int64, s)
forall a b. a -> b -> b
seq Int64
i' ((Int64, s) -> (Int64, s)) -> (Int64, s) -> (Int64, s)
forall a b. (a -> b) -> a -> b
$ s -> (Int64, s) -> (Int64, s)
forall a b. a -> b -> b
seq s
s' ((Int64, s) -> (Int64, s)) -> (Int64, s) -> (Int64, s)
forall a b. (a -> b) -> a -> b
$ (Int64, s) -> (Int64, s)
cont (Int64
i', s
s')
| Bool
otherwise = (Int64
i, s
s)
split :: (Char -> Bool) -> Text -> [Text]
split = (Char -> Bool) -> Text -> [Text]
LazyText.split
find :: (Char -> Bool) -> Text -> Maybe Char
find = (Char -> Bool) -> Text -> Maybe Char
LazyText.find
{-# INLINE all #-}
{-# INLINE any #-}
{-# INLINE break #-}
{-# INLINE characterPrefix #-}
{-# INLINE concatMap #-}
{-# INLINE dropWhile #-}
{-# INLINE find #-}
{-# INLINE foldl #-}
{-# INLINE foldl' #-}
{-# INLINE foldr #-}
{-# INLINE fromText #-}
{-# INLINE map #-}
{-# INLINE mapAccumL #-}
{-# INLINE mapAccumR #-}
{-# INLINE scanl #-}
{-# INLINE scanl1 #-}
{-# INLINE scanr #-}
{-# INLINE scanr1 #-}
{-# INLINE singleton #-}
{-# INLINE span #-}
{-# INLINE spanMaybe #-}
{-# INLINE spanMaybe' #-}
{-# INLINE split #-}
{-# INLINE splitCharacterPrefix #-}
{-# INLINE takeWhile #-}
instance TextualMonoid (Sequence.Seq Char) where
singleton :: Char -> Seq Char
singleton = Char -> Seq Char
forall a. a -> Seq a
Sequence.singleton
splitCharacterPrefix :: Seq Char -> Maybe (Char, Seq Char)
splitCharacterPrefix s :: Seq Char
s = case Seq Char -> ViewL Char
forall a. Seq a -> ViewL a
Sequence.viewl Seq Char
s
of Sequence.EmptyL -> Maybe (Char, Seq Char)
forall a. Maybe a
Nothing
c :: Char
c Sequence.:< rest :: Seq Char
rest -> (Char, Seq Char) -> Maybe (Char, Seq Char)
forall a. a -> Maybe a
Just (Char
c, Seq Char
rest)
characterPrefix :: Seq Char -> Maybe Char
characterPrefix s :: Seq Char
s = case Seq Char -> ViewL Char
forall a. Seq a -> ViewL a
Sequence.viewl Seq Char
s
of Sequence.EmptyL -> Maybe Char
forall a. Maybe a
Nothing
c :: Char
c Sequence.:< _ -> Char -> Maybe Char
forall a. a -> Maybe a
Just Char
c
map :: (Char -> Char) -> Seq Char -> Seq Char
map = (Char -> Char) -> Seq Char -> Seq Char
forall (t :: * -> *) a b. Traversable t => (a -> b) -> t a -> t b
Traversable.fmapDefault
concatMap :: (Char -> Seq Char) -> Seq Char -> Seq Char
concatMap = (Char -> Seq Char) -> Seq Char -> Seq Char
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
Foldable.foldMap
toString :: (Seq Char -> String) -> Seq Char -> String
toString = (Seq Char -> String) -> (Seq Char -> String) -> Seq Char -> String
forall a b. a -> b -> a
const Seq Char -> String
forall (t :: * -> *) a. Foldable t => t a -> [a]
Foldable.toList
any :: (Char -> Bool) -> Seq Char -> Bool
any = (Char -> Bool) -> Seq Char -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Foldable.any
all :: (Char -> Bool) -> Seq Char -> Bool
all = (Char -> Bool) -> Seq Char -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Foldable.all
foldl :: (a -> Seq Char -> a) -> (a -> Char -> a) -> a -> Seq Char -> a
foldl = ((a -> Char -> a) -> a -> Seq Char -> a)
-> (a -> Seq Char -> a) -> (a -> Char -> a) -> a -> Seq Char -> a
forall a b. a -> b -> a
const (a -> Char -> a) -> a -> Seq Char -> a
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
Foldable.foldl
foldl' :: (a -> Seq Char -> a) -> (a -> Char -> a) -> a -> Seq Char -> a
foldl' = ((a -> Char -> a) -> a -> Seq Char -> a)
-> (a -> Seq Char -> a) -> (a -> Char -> a) -> a -> Seq Char -> a
forall a b. a -> b -> a
const (a -> Char -> a) -> a -> Seq Char -> a
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
Foldable.foldl'
foldr :: (Seq Char -> a -> a) -> (Char -> a -> a) -> a -> Seq Char -> a
foldr = ((Char -> a -> a) -> a -> Seq Char -> a)
-> (Seq Char -> a -> a) -> (Char -> a -> a) -> a -> Seq Char -> a
forall a b. a -> b -> a
const (Char -> a -> a) -> a -> Seq Char -> a
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Foldable.foldr
scanl :: (Char -> Char -> Char) -> Char -> Seq Char -> Seq Char
scanl = (Char -> Char -> Char) -> Char -> Seq Char -> Seq Char
forall a b. (a -> b -> a) -> a -> Seq b -> Seq a
Sequence.scanl
scanl1 :: (Char -> Char -> Char) -> Seq Char -> Seq Char
scanl1 f :: Char -> Char -> Char
f v :: Seq Char
v | Seq Char -> Bool
forall a. Seq a -> Bool
Sequence.null Seq Char
v = Seq Char
forall a. Seq a
Sequence.empty
| Bool
otherwise = (Char -> Char -> Char) -> Seq Char -> Seq Char
forall a. (a -> a -> a) -> Seq a -> Seq a
Sequence.scanl1 Char -> Char -> Char
f Seq Char
v
scanr :: (Char -> Char -> Char) -> Char -> Seq Char -> Seq Char
scanr = (Char -> Char -> Char) -> Char -> Seq Char -> Seq Char
forall a b. (a -> b -> b) -> b -> Seq a -> Seq b
Sequence.scanr
scanr1 :: (Char -> Char -> Char) -> Seq Char -> Seq Char
scanr1 f :: Char -> Char -> Char
f v :: Seq Char
v | Seq Char -> Bool
forall a. Seq a -> Bool
Sequence.null Seq Char
v = Seq Char
forall a. Seq a
Sequence.empty
| Bool
otherwise = (Char -> Char -> Char) -> Seq Char -> Seq Char
forall a. (a -> a -> a) -> Seq a -> Seq a
Sequence.scanr1 Char -> Char -> Char
f Seq Char
v
takeWhile :: (Seq Char -> Bool) -> (Char -> Bool) -> Seq Char -> Seq Char
takeWhile _ = (Char -> Bool) -> Seq Char -> Seq Char
forall a. (a -> Bool) -> Seq a -> Seq a
Sequence.takeWhileL
dropWhile :: (Seq Char -> Bool) -> (Char -> Bool) -> Seq Char -> Seq Char
dropWhile _ = (Char -> Bool) -> Seq Char -> Seq Char
forall a. (a -> Bool) -> Seq a -> Seq a
Sequence.dropWhileL
break :: (Seq Char -> Bool)
-> (Char -> Bool) -> Seq Char -> (Seq Char, Seq Char)
break _ = (Char -> Bool) -> Seq Char -> (Seq Char, Seq Char)
forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
Sequence.breakl
span :: (Seq Char -> Bool)
-> (Char -> Bool) -> Seq Char -> (Seq Char, Seq Char)
span _ = (Char -> Bool) -> Seq Char -> (Seq Char, Seq Char)
forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
Sequence.spanl
spanMaybe :: s
-> (s -> Seq Char -> Maybe s)
-> (s -> Char -> Maybe s)
-> Seq Char
-> (Seq Char, Seq Char, s)
spanMaybe s0 :: s
s0 _ft :: s -> Seq Char -> Maybe s
_ft fc :: s -> Char -> Maybe s
fc b :: Seq Char
b = case (Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s))
-> ((Int, s) -> (Int, s)) -> Seq Char -> (Int, s) -> (Int, s)
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Foldable.foldr Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
g (Int, s) -> (Int, s)
forall a. a -> a
id Seq Char
b (0, s
s0)
of (i :: Int
i, s' :: s
s') | (prefix :: Seq Char
prefix, suffix :: Seq Char
suffix) <- Int -> Seq Char -> (Seq Char, Seq Char)
forall a. Int -> Seq a -> (Seq a, Seq a)
Sequence.splitAt Int
i Seq Char
b -> (Seq Char
prefix, Seq Char
suffix, s
s')
where g :: Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
g c :: Char
c cont :: (Int, s) -> (Int, s)
cont (i :: Int
i, s :: s
s) | Just s' :: s
s' <- s -> Char -> Maybe s
fc s
s Char
c = let i' :: Int
i' = Int -> Int
forall a. Enum a => a -> a
succ Int
i :: Int in Int -> (Int, s) -> (Int, s)
forall a b. a -> b -> b
seq Int
i' ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
forall a b. (a -> b) -> a -> b
$ (Int, s) -> (Int, s)
cont (Int
i', s
s')
| Bool
otherwise = (Int
i, s
s)
spanMaybe' :: s
-> (s -> Seq Char -> Maybe s)
-> (s -> Char -> Maybe s)
-> Seq Char
-> (Seq Char, Seq Char, s)
spanMaybe' s0 :: s
s0 _ft :: s -> Seq Char -> Maybe s
_ft fc :: s -> Char -> Maybe s
fc b :: Seq Char
b = case (Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s))
-> ((Int, s) -> (Int, s)) -> Seq Char -> (Int, s) -> (Int, s)
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Foldable.foldr Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
g (Int, s) -> (Int, s)
forall a. a -> a
id Seq Char
b (0, s
s0)
of (i :: Int
i, s' :: s
s') | (prefix :: Seq Char
prefix, suffix :: Seq Char
suffix) <- Int -> Seq Char -> (Seq Char, Seq Char)
forall a. Int -> Seq a -> (Seq a, Seq a)
Sequence.splitAt Int
i Seq Char
b -> (Seq Char
prefix, Seq Char
suffix, s
s')
where g :: Char -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
g c :: Char
c cont :: (Int, s) -> (Int, s)
cont (i :: Int
i, s :: s
s) | Just s' :: s
s' <- s -> Char -> Maybe s
fc s
s Char
c = let i' :: Int
i' = Int -> Int
forall a. Enum a => a -> a
succ Int
i :: Int in Int -> (Int, s) -> (Int, s)
forall a b. a -> b -> b
seq Int
i' ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
forall a b. (a -> b) -> a -> b
$ s -> (Int, s) -> (Int, s)
forall a b. a -> b -> b
seq s
s' ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
forall a b. (a -> b) -> a -> b
$ (Int, s) -> (Int, s)
cont (Int
i', s
s')
| Bool
otherwise = (Int
i, s
s)
find :: (Char -> Bool) -> Seq Char -> Maybe Char
find = (Char -> Bool) -> Seq Char -> Maybe Char
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
Foldable.find
elem :: Char -> Seq Char -> Bool
elem = Char -> Seq Char -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
Foldable.elem
{-# INLINE all #-}
{-# INLINE any #-}
{-# INLINE break #-}
{-# INLINE characterPrefix #-}
{-# INLINE concatMap #-}
{-# INLINE dropWhile #-}
{-# INLINE elem #-}
{-# INLINE find #-}
{-# INLINE foldl #-}
{-# INLINE foldl' #-}
{-# INLINE foldr #-}
{-# INLINE map #-}
{-# INLINE scanl #-}
{-# INLINE scanl1 #-}
{-# INLINE scanr #-}
{-# INLINE scanr1 #-}
{-# INLINE singleton #-}
{-# INLINE span #-}
{-# INLINE spanMaybe #-}
{-# INLINE spanMaybe' #-}
{-# INLINE splitCharacterPrefix #-}
{-# INLINE takeWhile #-}