{-# LANGUAGE Haskell2010, FlexibleInstances, Trustworthy #-}
module Data.Semigroup.Cancellative (
Commutative, Reductive(..), Cancellative, SumCancellative(..),
LeftReductive(..), RightReductive(..),
LeftCancellative, RightCancellative
)
where
import Data.Semigroup
import qualified Data.List as List
import Data.Maybe (isJust)
import qualified Data.ByteString as ByteString
import qualified Data.ByteString.Unsafe as ByteString
import qualified Data.ByteString.Lazy as LazyByteString
import qualified Data.Text as Text
import qualified Data.Text.Lazy as LazyText
import qualified Data.IntMap as IntMap
import qualified Data.IntSet as IntSet
import qualified Data.Map as Map
import qualified Data.Sequence as Sequence
import qualified Data.Set as Set
import qualified Data.Vector as Vector
import Numeric.Natural (Natural)
class Semigroup m => Commutative m
class (Commutative m, LeftReductive m, RightReductive m) => Reductive m where
(</>) :: m -> m -> Maybe m
infix 5 </>
class (LeftCancellative m, RightCancellative m, Reductive m) => Cancellative m
class Semigroup m => LeftReductive m where
isPrefixOf :: m -> m -> Bool
stripPrefix :: m -> m -> Maybe m
isPrefixOf a :: m
a b :: m
b = Maybe m -> Bool
forall a. Maybe a -> Bool
isJust (m -> m -> Maybe m
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix m
a m
b)
{-# MINIMAL stripPrefix #-}
class Semigroup m => RightReductive m where
isSuffixOf :: m -> m -> Bool
stripSuffix :: m -> m -> Maybe m
isSuffixOf a :: m
a b :: m
b = Maybe m -> Bool
forall a. Maybe a -> Bool
isJust (m -> m -> Maybe m
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix m
a m
b)
{-# MINIMAL stripSuffix #-}
class LeftReductive m => LeftCancellative m
class RightReductive m => RightCancellative m
instance Commutative ()
instance Reductive () where
() </> :: () -> () -> Maybe ()
</> () = () -> Maybe ()
forall a. a -> Maybe a
Just ()
instance Cancellative ()
instance LeftReductive () where
stripPrefix :: () -> () -> Maybe ()
stripPrefix () () = () -> Maybe ()
forall a. a -> Maybe a
Just ()
instance RightReductive () where
stripSuffix :: () -> () -> Maybe ()
stripSuffix () () = () -> Maybe ()
forall a. a -> Maybe a
Just ()
instance LeftCancellative ()
instance RightCancellative ()
instance Commutative a => Commutative (Dual a)
instance Reductive a => Reductive (Dual a) where
Dual a :: a
a </> :: Dual a -> Dual a -> Maybe (Dual a)
</> Dual b :: a
b = (a -> Dual a) -> Maybe a -> Maybe (Dual a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Dual a
forall a. a -> Dual a
Dual (a
a a -> a -> Maybe a
forall m. Reductive m => m -> m -> Maybe m
</> a
b)
instance Cancellative a => Cancellative (Dual a)
instance LeftReductive a => RightReductive (Dual a) where
stripSuffix :: Dual a -> Dual a -> Maybe (Dual a)
stripSuffix (Dual a :: a
a) (Dual b :: a
b) = (a -> Dual a) -> Maybe a -> Maybe (Dual a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Dual a
forall a. a -> Dual a
Dual (a -> a -> Maybe a
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix a
a a
b)
Dual a :: a
a isSuffixOf :: Dual a -> Dual a -> Bool
`isSuffixOf` Dual b :: a
b = a
a a -> a -> Bool
forall m. LeftReductive m => m -> m -> Bool
`isPrefixOf` a
b
instance RightReductive a => LeftReductive (Dual a) where
stripPrefix :: Dual a -> Dual a -> Maybe (Dual a)
stripPrefix (Dual a :: a
a) (Dual b :: a
b) = (a -> Dual a) -> Maybe a -> Maybe (Dual a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Dual a
forall a. a -> Dual a
Dual (a -> a -> Maybe a
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix a
a a
b)
Dual a :: a
a isPrefixOf :: Dual a -> Dual a -> Bool
`isPrefixOf` Dual b :: a
b = a
a a -> a -> Bool
forall m. RightReductive m => m -> m -> Bool
`isSuffixOf` a
b
instance LeftCancellative a => RightCancellative (Dual a)
instance RightCancellative a => LeftCancellative (Dual a)
instance Num a => Commutative (Sum a)
class Num a => SumCancellative a where
cancelAddition :: a -> a -> Maybe a
cancelAddition a :: a
a b :: a
b = a -> Maybe a
forall a. a -> Maybe a
Just (a
a a -> a -> a
forall a. Num a => a -> a -> a
- a
b)
instance SumCancellative Int
instance SumCancellative Integer
instance SumCancellative Rational
instance SumCancellative Natural where
cancelAddition :: Natural -> Natural -> Maybe Natural
cancelAddition a :: Natural
a b :: Natural
b
| Natural
a Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
< Natural
b = Maybe Natural
forall a. Maybe a
Nothing
| Bool
otherwise = Natural -> Maybe Natural
forall a. a -> Maybe a
Just (Natural
a Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
- Natural
b)
instance SumCancellative a => Reductive (Sum a) where
Sum a :: a
a </> :: Sum a -> Sum a -> Maybe (Sum a)
</> Sum b :: a
b = a -> Sum a
forall a. a -> Sum a
Sum (a -> Sum a) -> Maybe a -> Maybe (Sum a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> a -> Maybe a
forall a. SumCancellative a => a -> a -> Maybe a
cancelAddition a
a a
b
instance SumCancellative a => LeftReductive (Sum a) where
stripPrefix :: Sum a -> Sum a -> Maybe (Sum a)
stripPrefix a :: Sum a
a b :: Sum a
b = Sum a
b Sum a -> Sum a -> Maybe (Sum a)
forall m. Reductive m => m -> m -> Maybe m
</> Sum a
a
instance SumCancellative a => RightReductive (Sum a) where
stripSuffix :: Sum a -> Sum a -> Maybe (Sum a)
stripSuffix a :: Sum a
a b :: Sum a
b = Sum a
b Sum a -> Sum a -> Maybe (Sum a)
forall m. Reductive m => m -> m -> Maybe m
</> Sum a
a
instance SumCancellative a => Cancellative (Sum a)
instance SumCancellative a => LeftCancellative (Sum a)
instance SumCancellative a => RightCancellative (Sum a)
instance Num a => Commutative (Product a)
instance Integral a => Reductive (Product a) where
Product 0 </> :: Product a -> Product a -> Maybe (Product a)
</> Product 0 = Product a -> Maybe (Product a)
forall a. a -> Maybe a
Just (a -> Product a
forall a. a -> Product a
Product 0)
Product _ </> Product 0 = Maybe (Product a)
forall a. Maybe a
Nothing
Product a :: a
a </> Product b :: a
b = if a
remainder a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== 0 then Product a -> Maybe (Product a)
forall a. a -> Maybe a
Just (a -> Product a
forall a. a -> Product a
Product a
quotient) else Maybe (Product a)
forall a. Maybe a
Nothing
where (quotient :: a
quotient, remainder :: a
remainder) = a -> a -> (a, a)
forall a. Integral a => a -> a -> (a, a)
quotRem a
a a
b
instance Integral a => LeftReductive (Product a) where
stripPrefix :: Product a -> Product a -> Maybe (Product a)
stripPrefix a :: Product a
a b :: Product a
b = Product a
b Product a -> Product a -> Maybe (Product a)
forall m. Reductive m => m -> m -> Maybe m
</> Product a
a
instance Integral a => RightReductive (Product a) where
stripSuffix :: Product a -> Product a -> Maybe (Product a)
stripSuffix a :: Product a
a b :: Product a
b = Product a
b Product a -> Product a -> Maybe (Product a)
forall m. Reductive m => m -> m -> Maybe m
</> Product a
a
instance (Commutative a, Commutative b) => Commutative (a, b)
instance (Reductive a, Reductive b) => Reductive (a, b) where
(a :: a
a, b :: b
b) </> :: (a, b) -> (a, b) -> Maybe (a, b)
</> (c :: a
c, d :: b
d) = case (a
a a -> a -> Maybe a
forall m. Reductive m => m -> m -> Maybe m
</> a
c, b
b b -> b -> Maybe b
forall m. Reductive m => m -> m -> Maybe m
</> b
d)
of (Just a' :: a
a', Just b' :: b
b') -> (a, b) -> Maybe (a, b)
forall a. a -> Maybe a
Just (a
a', b
b')
_ -> Maybe (a, b)
forall a. Maybe a
Nothing
instance (Cancellative a, Cancellative b) => Cancellative (a, b)
instance (LeftReductive a, LeftReductive b) => LeftReductive (a, b) where
stripPrefix :: (a, b) -> (a, b) -> Maybe (a, b)
stripPrefix (a :: a
a, b :: b
b) (c :: a
c, d :: b
d) = case (a -> a -> Maybe a
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix a
a a
c, b -> b -> Maybe b
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix b
b b
d)
of (Just a' :: a
a', Just b' :: b
b') -> (a, b) -> Maybe (a, b)
forall a. a -> Maybe a
Just (a
a', b
b')
_ -> Maybe (a, b)
forall a. Maybe a
Nothing
isPrefixOf :: (a, b) -> (a, b) -> Bool
isPrefixOf (a :: a
a, b :: b
b) (c :: a
c, d :: b
d) = a -> a -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf a
a a
c Bool -> Bool -> Bool
&& b -> b -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf b
b b
d
instance (RightReductive a, RightReductive b) => RightReductive (a, b) where
stripSuffix :: (a, b) -> (a, b) -> Maybe (a, b)
stripSuffix (a :: a
a, b :: b
b) (c :: a
c, d :: b
d) = case (a -> a -> Maybe a
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix a
a a
c, b -> b -> Maybe b
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix b
b b
d)
of (Just a' :: a
a', Just b' :: b
b') -> (a, b) -> Maybe (a, b)
forall a. a -> Maybe a
Just (a
a', b
b')
_ -> Maybe (a, b)
forall a. Maybe a
Nothing
isSuffixOf :: (a, b) -> (a, b) -> Bool
isSuffixOf (a :: a
a, b :: b
b) (c :: a
c, d :: b
d) = a -> a -> Bool
forall m. RightReductive m => m -> m -> Bool
isSuffixOf a
a a
c Bool -> Bool -> Bool
&& b -> b -> Bool
forall m. RightReductive m => m -> m -> Bool
isSuffixOf b
b b
d
instance (LeftCancellative a, LeftCancellative b) => LeftCancellative (a, b)
instance (RightCancellative a, RightCancellative b) => RightCancellative (a, b)
instance (Commutative a, Commutative b, Commutative c) => Commutative (a, b, c)
instance (Reductive a, Reductive b, Reductive c) => Reductive (a, b, c) where
(a1 :: a
a1, b1 :: b
b1, c1 :: c
c1) </> :: (a, b, c) -> (a, b, c) -> Maybe (a, b, c)
</> (a2 :: a
a2, b2 :: b
b2, c2 :: c
c2) = (,,) (a -> b -> c -> (a, b, c))
-> Maybe a -> Maybe (b -> c -> (a, b, c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a
a1 a -> a -> Maybe a
forall m. Reductive m => m -> m -> Maybe m
</> a
a2) Maybe (b -> c -> (a, b, c)) -> Maybe b -> Maybe (c -> (a, b, c))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (b
b1 b -> b -> Maybe b
forall m. Reductive m => m -> m -> Maybe m
</> b
b2) Maybe (c -> (a, b, c)) -> Maybe c -> Maybe (a, b, c)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (c
c1 c -> c -> Maybe c
forall m. Reductive m => m -> m -> Maybe m
</> c
c2)
instance (Cancellative a, Cancellative b, Cancellative c) => Cancellative (a, b, c)
instance (LeftReductive a, LeftReductive b, LeftReductive c) => LeftReductive (a, b, c) where
stripPrefix :: (a, b, c) -> (a, b, c) -> Maybe (a, b, c)
stripPrefix (a1 :: a
a1, b1 :: b
b1, c1 :: c
c1) (a2 :: a
a2, b2 :: b
b2, c2 :: c
c2) = (,,) (a -> b -> c -> (a, b, c))
-> Maybe a -> Maybe (b -> c -> (a, b, c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> a -> Maybe a
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix a
a1 a
a2 Maybe (b -> c -> (a, b, c)) -> Maybe b -> Maybe (c -> (a, b, c))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> b -> b -> Maybe b
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix b
b1 b
b2 Maybe (c -> (a, b, c)) -> Maybe c -> Maybe (a, b, c)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> c -> c -> Maybe c
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix c
c1 c
c2
isPrefixOf :: (a, b, c) -> (a, b, c) -> Bool
isPrefixOf (a1 :: a
a1, b1 :: b
b1, c1 :: c
c1) (a2 :: a
a2, b2 :: b
b2, c2 :: c
c2) = a -> a -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf a
a1 a
a2 Bool -> Bool -> Bool
&& b -> b -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf b
b1 b
b2 Bool -> Bool -> Bool
&& c -> c -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf c
c1 c
c2
instance (RightReductive a, RightReductive b, RightReductive c) => RightReductive (a, b, c) where
stripSuffix :: (a, b, c) -> (a, b, c) -> Maybe (a, b, c)
stripSuffix (a1 :: a
a1, b1 :: b
b1, c1 :: c
c1) (a2 :: a
a2, b2 :: b
b2, c2 :: c
c2) = (,,) (a -> b -> c -> (a, b, c))
-> Maybe a -> Maybe (b -> c -> (a, b, c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> a -> Maybe a
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix a
a1 a
a2 Maybe (b -> c -> (a, b, c)) -> Maybe b -> Maybe (c -> (a, b, c))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> b -> b -> Maybe b
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix b
b1 b
b2 Maybe (c -> (a, b, c)) -> Maybe c -> Maybe (a, b, c)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> c -> c -> Maybe c
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix c
c1 c
c2
isSuffixOf :: (a, b, c) -> (a, b, c) -> Bool
isSuffixOf (a1 :: a
a1, b1 :: b
b1, c1 :: c
c1) (a2 :: a
a2, b2 :: b
b2, c2 :: c
c2) = a -> a -> Bool
forall m. RightReductive m => m -> m -> Bool
isSuffixOf a
a1 a
a2 Bool -> Bool -> Bool
&& b -> b -> Bool
forall m. RightReductive m => m -> m -> Bool
isSuffixOf b
b1 b
b2 Bool -> Bool -> Bool
&& c -> c -> Bool
forall m. RightReductive m => m -> m -> Bool
isSuffixOf c
c1 c
c2
instance (LeftCancellative a, LeftCancellative b, LeftCancellative c) => LeftCancellative (a, b, c)
instance (RightCancellative a, RightCancellative b, RightCancellative c) => RightCancellative (a, b, c)
instance (Commutative a, Commutative b, Commutative c, Commutative d) => Commutative (a, b, c, d)
instance (Reductive a, Reductive b, Reductive c, Reductive d) => Reductive (a, b, c, d) where
(a1 :: a
a1, b1 :: b
b1, c1 :: c
c1, d1 :: d
d1) </> :: (a, b, c, d) -> (a, b, c, d) -> Maybe (a, b, c, d)
</> (a2 :: a
a2, b2 :: b
b2, c2 :: c
c2, d2 :: d
d2) = (,,,) (a -> b -> c -> d -> (a, b, c, d))
-> Maybe a -> Maybe (b -> c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a
a1 a -> a -> Maybe a
forall m. Reductive m => m -> m -> Maybe m
</> a
a2) Maybe (b -> c -> d -> (a, b, c, d))
-> Maybe b -> Maybe (c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (b
b1 b -> b -> Maybe b
forall m. Reductive m => m -> m -> Maybe m
</> b
b2) Maybe (c -> d -> (a, b, c, d))
-> Maybe c -> Maybe (d -> (a, b, c, d))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (c
c1 c -> c -> Maybe c
forall m. Reductive m => m -> m -> Maybe m
</> c
c2) Maybe (d -> (a, b, c, d)) -> Maybe d -> Maybe (a, b, c, d)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (d
d1 d -> d -> Maybe d
forall m. Reductive m => m -> m -> Maybe m
</> d
d2)
instance (Cancellative a, Cancellative b, Cancellative c, Cancellative d) => Cancellative (a, b, c, d)
instance (LeftReductive a, LeftReductive b, LeftReductive c, LeftReductive d) => LeftReductive (a, b, c, d) where
stripPrefix :: (a, b, c, d) -> (a, b, c, d) -> Maybe (a, b, c, d)
stripPrefix (a1 :: a
a1, b1 :: b
b1, c1 :: c
c1, d1 :: d
d1) (a2 :: a
a2, b2 :: b
b2, c2 :: c
c2, d2 :: d
d2) =
(,,,) (a -> b -> c -> d -> (a, b, c, d))
-> Maybe a -> Maybe (b -> c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> a -> Maybe a
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix a
a1 a
a2 Maybe (b -> c -> d -> (a, b, c, d))
-> Maybe b -> Maybe (c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> b -> b -> Maybe b
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix b
b1 b
b2 Maybe (c -> d -> (a, b, c, d))
-> Maybe c -> Maybe (d -> (a, b, c, d))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> c -> c -> Maybe c
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix c
c1 c
c2 Maybe (d -> (a, b, c, d)) -> Maybe d -> Maybe (a, b, c, d)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> d -> d -> Maybe d
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix d
d1 d
d2
isPrefixOf :: (a, b, c, d) -> (a, b, c, d) -> Bool
isPrefixOf (a1 :: a
a1, b1 :: b
b1, c1 :: c
c1, d1 :: d
d1) (a2 :: a
a2, b2 :: b
b2, c2 :: c
c2, d2 :: d
d2) =
a -> a -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf a
a1 a
a2 Bool -> Bool -> Bool
&& b -> b -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf b
b1 b
b2 Bool -> Bool -> Bool
&& c -> c -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf c
c1 c
c2 Bool -> Bool -> Bool
&& d -> d -> Bool
forall m. LeftReductive m => m -> m -> Bool
isPrefixOf d
d1 d
d2
instance (RightReductive a, RightReductive b, RightReductive c, RightReductive d) => RightReductive (a, b, c, d) where
stripSuffix :: (a, b, c, d) -> (a, b, c, d) -> Maybe (a, b, c, d)
stripSuffix (a1 :: a
a1, b1 :: b
b1, c1 :: c
c1, d1 :: d
d1) (a2 :: a
a2, b2 :: b
b2, c2 :: c
c2, d2 :: d
d2) =
(,,,) (a -> b -> c -> d -> (a, b, c, d))
-> Maybe a -> Maybe (b -> c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> a -> Maybe a
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix a
a1 a
a2 Maybe (b -> c -> d -> (a, b, c, d))
-> Maybe b -> Maybe (c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> b -> b -> Maybe b
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix b
b1 b
b2 Maybe (c -> d -> (a, b, c, d))
-> Maybe c -> Maybe (d -> (a, b, c, d))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> c -> c -> Maybe c
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix c
c1 c
c2 Maybe (d -> (a, b, c, d)) -> Maybe d -> Maybe (a, b, c, d)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> d -> d -> Maybe d
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix d
d1 d
d2
isSuffixOf :: (a, b, c, d) -> (a, b, c, d) -> Bool
isSuffixOf (a1 :: a
a1, b1 :: b
b1, c1 :: c
c1, d1 :: d
d1) (a2 :: a
a2, b2 :: b
b2, c2 :: c
c2, d2 :: d
d2) =
a -> a -> Bool
forall m. RightReductive m => m -> m -> Bool
isSuffixOf a
a1 a
a2 Bool -> Bool -> Bool
&& b -> b -> Bool
forall m. RightReductive m => m -> m -> Bool
isSuffixOf b
b1 b
b2 Bool -> Bool -> Bool
&& c -> c -> Bool
forall m. RightReductive m => m -> m -> Bool
isSuffixOf c
c1 c
c2 Bool -> Bool -> Bool
&& d -> d -> Bool
forall m. RightReductive m => m -> m -> Bool
isSuffixOf d
d1 d
d2
instance (LeftCancellative a, LeftCancellative b,
LeftCancellative c, LeftCancellative d) => LeftCancellative (a, b, c, d)
instance (RightCancellative a, RightCancellative b,
RightCancellative c, RightCancellative d) => RightCancellative (a, b, c, d)
instance Commutative x => Commutative (Maybe x)
instance Reductive x => Reductive (Maybe x) where
Just x :: x
x </> :: Maybe x -> Maybe x -> Maybe (Maybe x)
</> Just y :: x
y = x -> Maybe x
forall a. a -> Maybe a
Just (x -> Maybe x) -> Maybe x -> Maybe (Maybe x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> x
x x -> x -> Maybe x
forall m. Reductive m => m -> m -> Maybe m
</> x
y
x :: Maybe x
x </> Nothing = Maybe x -> Maybe (Maybe x)
forall a. a -> Maybe a
Just Maybe x
x
Nothing </> _ = Maybe (Maybe x)
forall a. Maybe a
Nothing
instance LeftReductive x => LeftReductive (Maybe x) where
stripPrefix :: Maybe x -> Maybe x -> Maybe (Maybe x)
stripPrefix Nothing y :: Maybe x
y = Maybe x -> Maybe (Maybe x)
forall a. a -> Maybe a
Just Maybe x
y
stripPrefix Just{} Nothing = Maybe (Maybe x)
forall a. Maybe a
Nothing
stripPrefix (Just x :: x
x) (Just y :: x
y) = (x -> Maybe x) -> Maybe x -> Maybe (Maybe x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap x -> Maybe x
forall a. a -> Maybe a
Just (Maybe x -> Maybe (Maybe x)) -> Maybe x -> Maybe (Maybe x)
forall a b. (a -> b) -> a -> b
$ x -> x -> Maybe x
forall m. LeftReductive m => m -> m -> Maybe m
stripPrefix x
x x
y
instance RightReductive x => RightReductive (Maybe x) where
stripSuffix :: Maybe x -> Maybe x -> Maybe (Maybe x)
stripSuffix Nothing y :: Maybe x
y = Maybe x -> Maybe (Maybe x)
forall a. a -> Maybe a
Just Maybe x
y
stripSuffix Just{} Nothing = Maybe (Maybe x)
forall a. Maybe a
Nothing
stripSuffix (Just x :: x
x) (Just y :: x
y) = (x -> Maybe x) -> Maybe x -> Maybe (Maybe x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap x -> Maybe x
forall a. a -> Maybe a
Just (Maybe x -> Maybe (Maybe x)) -> Maybe x -> Maybe (Maybe x)
forall a b. (a -> b) -> a -> b
$ x -> x -> Maybe x
forall m. RightReductive m => m -> m -> Maybe m
stripSuffix x
x x
y
instance Ord a => Commutative (Set.Set a)
instance Ord a => LeftReductive (Set.Set a) where
isPrefixOf :: Set a -> Set a -> Bool
isPrefixOf = Set a -> Set a -> Bool
forall a. Ord a => Set a -> Set a -> Bool
Set.isSubsetOf
stripPrefix :: Set a -> Set a -> Maybe (Set a)
stripPrefix a :: Set a
a b :: Set a
b = Set a
b Set a -> Set a -> Maybe (Set a)
forall m. Reductive m => m -> m -> Maybe m
</> Set a
a
instance Ord a => RightReductive (Set.Set a) where
isSuffixOf :: Set a -> Set a -> Bool
isSuffixOf = Set a -> Set a -> Bool
forall a. Ord a => Set a -> Set a -> Bool
Set.isSubsetOf
stripSuffix :: Set a -> Set a -> Maybe (Set a)
stripSuffix a :: Set a
a b :: Set a
b = Set a
b Set a -> Set a -> Maybe (Set a)
forall m. Reductive m => m -> m -> Maybe m
</> Set a
a
instance Ord a => Reductive (Set.Set a) where
a :: Set a
a </> :: Set a -> Set a -> Maybe (Set a)
</> b :: Set a
b | Set a -> Set a -> Bool
forall a. Ord a => Set a -> Set a -> Bool
Set.isSubsetOf Set a
b Set a
a = Set a -> Maybe (Set a)
forall a. a -> Maybe a
Just (Set a
a Set a -> Set a -> Set a
forall a. Ord a => Set a -> Set a -> Set a
Set.\\ Set a
b)
| Bool
otherwise = Maybe (Set a)
forall a. Maybe a
Nothing
instance Commutative IntSet.IntSet
instance LeftReductive IntSet.IntSet where
isPrefixOf :: IntSet -> IntSet -> Bool
isPrefixOf = IntSet -> IntSet -> Bool
IntSet.isSubsetOf
stripPrefix :: IntSet -> IntSet -> Maybe IntSet
stripPrefix a :: IntSet
a b :: IntSet
b = IntSet
b IntSet -> IntSet -> Maybe IntSet
forall m. Reductive m => m -> m -> Maybe m
</> IntSet
a
instance RightReductive IntSet.IntSet where
isSuffixOf :: IntSet -> IntSet -> Bool
isSuffixOf = IntSet -> IntSet -> Bool
IntSet.isSubsetOf
stripSuffix :: IntSet -> IntSet -> Maybe IntSet
stripSuffix a :: IntSet
a b :: IntSet
b = IntSet
b IntSet -> IntSet -> Maybe IntSet
forall m. Reductive m => m -> m -> Maybe m
</> IntSet
a
instance Reductive IntSet.IntSet where
a :: IntSet
a </> :: IntSet -> IntSet -> Maybe IntSet
</> b :: IntSet
b | IntSet -> IntSet -> Bool
IntSet.isSubsetOf IntSet
b IntSet
a = IntSet -> Maybe IntSet
forall a. a -> Maybe a
Just (IntSet
a IntSet -> IntSet -> IntSet
IntSet.\\ IntSet
b)
| Bool
otherwise = Maybe IntSet
forall a. Maybe a
Nothing
instance (Ord k, Eq a) => LeftReductive (Map.Map k a) where
isPrefixOf :: Map k a -> Map k a -> Bool
isPrefixOf = Map k a -> Map k a -> Bool
forall k a. (Ord k, Eq a) => Map k a -> Map k a -> Bool
Map.isSubmapOf
stripPrefix :: Map k a -> Map k a -> Maybe (Map k a)
stripPrefix a :: Map k a
a b :: Map k a
b | Map k a -> Map k a -> Bool
forall k a. (Ord k, Eq a) => Map k a -> Map k a -> Bool
Map.isSubmapOf Map k a
a Map k a
b = Map k a -> Maybe (Map k a)
forall a. a -> Maybe a
Just (Map k a
b Map k a -> Map k a -> Map k a
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.\\ Map k a
a)
| Bool
otherwise = Maybe (Map k a)
forall a. Maybe a
Nothing
instance (Ord k, Eq a) => RightReductive (Map.Map k a) where
isSuffixOf :: Map k a -> Map k a -> Bool
isSuffixOf = (a -> a -> Bool) -> Map k a -> Map k a -> Bool
forall k a b.
Ord k =>
(a -> b -> Bool) -> Map k a -> Map k b -> Bool
Map.isSubmapOfBy ((a -> Bool) -> a -> a -> Bool
forall a b. a -> b -> a
const ((a -> Bool) -> a -> a -> Bool) -> (a -> Bool) -> a -> a -> Bool
forall a b. (a -> b) -> a -> b
$ Bool -> a -> Bool
forall a b. a -> b -> a
const Bool
True)
stripSuffix :: Map k a -> Map k a -> Maybe (Map k a)
stripSuffix a :: Map k a
a b :: Map k a
b | Map k a
a Map k a -> Map k a -> Bool
forall m. RightReductive m => m -> m -> Bool
`isSuffixOf` Map k a
b = Map k a -> Maybe (Map k a)
forall a. a -> Maybe a
Just ((a -> a -> Maybe a) -> Map k a -> Map k a -> Map k a
forall k a b.
Ord k =>
(a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
Map.differenceWith (\x :: a
x y :: a
y-> if a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
y then Maybe a
forall a. Maybe a
Nothing else a -> Maybe a
forall a. a -> Maybe a
Just a
x) Map k a
b Map k a
a)
| Bool
otherwise = Maybe (Map k a)
forall a. Maybe a
Nothing
instance Eq a => LeftReductive (IntMap.IntMap a) where
isPrefixOf :: IntMap a -> IntMap a -> Bool
isPrefixOf = IntMap a -> IntMap a -> Bool
forall a. Eq a => IntMap a -> IntMap a -> Bool
IntMap.isSubmapOf
stripPrefix :: IntMap a -> IntMap a -> Maybe (IntMap a)
stripPrefix a :: IntMap a
a b :: IntMap a
b | IntMap a -> IntMap a -> Bool
forall a. Eq a => IntMap a -> IntMap a -> Bool
IntMap.isSubmapOf IntMap a
a IntMap a
b = IntMap a -> Maybe (IntMap a)
forall a. a -> Maybe a
Just (IntMap a
b IntMap a -> IntMap a -> IntMap a
forall a b. IntMap a -> IntMap b -> IntMap a
IntMap.\\ IntMap a
a)
| Bool
otherwise = Maybe (IntMap a)
forall a. Maybe a
Nothing
instance Eq a => RightReductive (IntMap.IntMap a) where
isSuffixOf :: IntMap a -> IntMap a -> Bool
isSuffixOf = (a -> a -> Bool) -> IntMap a -> IntMap a -> Bool
forall a b. (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool
IntMap.isSubmapOfBy ((a -> Bool) -> a -> a -> Bool
forall a b. a -> b -> a
const ((a -> Bool) -> a -> a -> Bool) -> (a -> Bool) -> a -> a -> Bool
forall a b. (a -> b) -> a -> b
$ Bool -> a -> Bool
forall a b. a -> b -> a
const Bool
True)
stripSuffix :: IntMap a -> IntMap a -> Maybe (IntMap a)
stripSuffix a :: IntMap a
a b :: IntMap a
b | IntMap a
a IntMap a -> IntMap a -> Bool
forall m. RightReductive m => m -> m -> Bool
`isSuffixOf` IntMap a
b = IntMap a -> Maybe (IntMap a)
forall a. a -> Maybe a
Just ((a -> a -> Maybe a) -> IntMap a -> IntMap a -> IntMap a
forall a b. (a -> b -> Maybe a) -> IntMap a -> IntMap b -> IntMap a
IntMap.differenceWith (\x :: a
x y :: a
y-> if a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
y then Maybe a
forall a. Maybe a
Nothing else a -> Maybe a
forall a. a -> Maybe a
Just a
x) IntMap a
b IntMap a
a)
| Bool
otherwise = Maybe (IntMap a)
forall a. Maybe a
Nothing
instance Eq x => LeftReductive [x] where
stripPrefix :: [x] -> [x] -> Maybe [x]
stripPrefix = [x] -> [x] -> Maybe [x]
forall x. Eq x => [x] -> [x] -> Maybe [x]
List.stripPrefix
isPrefixOf :: [x] -> [x] -> Bool
isPrefixOf = [x] -> [x] -> Bool
forall x. Eq x => [x] -> [x] -> Bool
List.isPrefixOf
instance Eq x => RightReductive [x] where
isSuffixOf :: [x] -> [x] -> Bool
isSuffixOf = [x] -> [x] -> Bool
forall x. Eq x => [x] -> [x] -> Bool
List.isSuffixOf
stripSuffix :: [x] -> [x] -> Maybe [x]
stripSuffix xs0 :: [x]
xs0 ys0 :: [x]
ys0 = [x] -> [x] -> Maybe [x]
forall a a. [a] -> [a] -> Maybe [x]
go1 [x]
xs0 [x]
ys0
where go1 :: [a] -> [a] -> Maybe [x]
go1 (_:xs :: [a]
xs) (_:ys :: [a]
ys) = [a] -> [a] -> Maybe [x]
go1 [a]
xs [a]
ys
go1 [] ys :: [a]
ys = ([x] -> [x]) -> [a] -> [x] -> Maybe [x]
forall a a. ([x] -> a) -> [a] -> [x] -> Maybe a
go2 [x] -> [x]
forall a. a -> a
id [a]
ys [x]
ys0
go1 _ [] = Maybe [x]
forall a. Maybe a
Nothing
go2 :: ([x] -> a) -> [a] -> [x] -> Maybe a
go2 fy :: [x] -> a
fy (_:zs :: [a]
zs) (y :: x
y:ys :: [x]
ys) = ([x] -> a) -> [a] -> [x] -> Maybe a
go2 ([x] -> a
fy ([x] -> a) -> ([x] -> [x]) -> [x] -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (x
yx -> [x] -> [x]
forall a. a -> [a] -> [a]
:)) [a]
zs [x]
ys
go2 fy :: [x] -> a
fy [] ys :: [x]
ys
| [x]
xs0 [x] -> [x] -> Bool
forall a. Eq a => a -> a -> Bool
== [x]
ys = a -> Maybe a
forall a. a -> Maybe a
Just ([x] -> a
fy [])
| Bool
otherwise = Maybe a
forall a. Maybe a
Nothing
go2 _ _ _ = [Char] -> Maybe a
forall a. HasCallStack => [Char] -> a
error "impossible"
instance Eq x => LeftCancellative [x]
instance Eq x => RightCancellative [x]
instance Eq a => LeftReductive (Sequence.Seq a) where
stripPrefix :: Seq a -> Seq a -> Maybe (Seq a)
stripPrefix p :: Seq a
p s :: Seq a
s | Seq a
p Seq a -> Seq a -> Bool
forall a. Eq a => a -> a -> Bool
== Seq a
s1 = Seq a -> Maybe (Seq a)
forall a. a -> Maybe a
Just Seq a
s2
| Bool
otherwise = Maybe (Seq a)
forall a. Maybe a
Nothing
where (s1 :: Seq a
s1, s2 :: Seq a
s2) = Int -> Seq a -> (Seq a, Seq a)
forall a. Int -> Seq a -> (Seq a, Seq a)
Sequence.splitAt (Seq a -> Int
forall a. Seq a -> Int
Sequence.length Seq a
p) Seq a
s
instance Eq a => RightReductive (Sequence.Seq a) where
stripSuffix :: Seq a -> Seq a -> Maybe (Seq a)
stripSuffix p :: Seq a
p s :: Seq a
s | Seq a
p Seq a -> Seq a -> Bool
forall a. Eq a => a -> a -> Bool
== Seq a
s2 = Seq a -> Maybe (Seq a)
forall a. a -> Maybe a
Just Seq a
s1
| Bool
otherwise = Maybe (Seq a)
forall a. Maybe a
Nothing
where (s1 :: Seq a
s1, s2 :: Seq a
s2) = Int -> Seq a -> (Seq a, Seq a)
forall a. Int -> Seq a -> (Seq a, Seq a)
Sequence.splitAt (Seq a -> Int
forall a. Seq a -> Int
Sequence.length Seq a
s Int -> Int -> Int
forall a. Num a => a -> a -> a
- Seq a -> Int
forall a. Seq a -> Int
Sequence.length Seq a
p) Seq a
s
instance Eq a => LeftCancellative (Sequence.Seq a)
instance Eq a => RightCancellative (Sequence.Seq a)
instance Eq a => LeftReductive (Vector.Vector a) where
stripPrefix :: Vector a -> Vector a -> Maybe (Vector a)
stripPrefix p :: Vector a
p l :: Vector a
l | Int
prefixLength Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Vector a -> Int
forall a. Vector a -> Int
Vector.length Vector a
l = Maybe (Vector a)
forall a. Maybe a
Nothing
| Bool
otherwise = Int -> Maybe (Vector a)
strip 0
where strip :: Int -> Maybe (Vector a)
strip i :: Int
i | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
prefixLength = Vector a -> Maybe (Vector a)
forall a. a -> Maybe a
Just (Int -> Vector a -> Vector a
forall a. Int -> Vector a -> Vector a
Vector.drop Int
prefixLength Vector a
l)
| Vector a
l Vector a -> Int -> a
forall a. Vector a -> Int -> a
Vector.! Int
i a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== Vector a
p Vector a -> Int -> a
forall a. Vector a -> Int -> a
Vector.! Int
i = Int -> Maybe (Vector a)
strip (Int -> Int
forall a. Enum a => a -> a
succ Int
i)
| Bool
otherwise = Maybe (Vector a)
forall a. Maybe a
Nothing
prefixLength :: Int
prefixLength = Vector a -> Int
forall a. Vector a -> Int
Vector.length Vector a
p
isPrefixOf :: Vector a -> Vector a -> Bool
isPrefixOf p :: Vector a
p l :: Vector a
l | Int
prefixLength Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Vector a -> Int
forall a. Vector a -> Int
Vector.length Vector a
l = Bool
False
| Bool
otherwise = Int -> Bool
test 0
where test :: Int -> Bool
test i :: Int
i | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
prefixLength = Bool
True
| Vector a
l Vector a -> Int -> a
forall a. Vector a -> Int -> a
Vector.! Int
i a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== Vector a
p Vector a -> Int -> a
forall a. Vector a -> Int -> a
Vector.! Int
i = Int -> Bool
test (Int -> Int
forall a. Enum a => a -> a
succ Int
i)
| Bool
otherwise = Bool
False
prefixLength :: Int
prefixLength = Vector a -> Int
forall a. Vector a -> Int
Vector.length Vector a
p
instance Eq a => RightReductive (Vector.Vector a) where
stripSuffix :: Vector a -> Vector a -> Maybe (Vector a)
stripSuffix s :: Vector a
s l :: Vector a
l | Int
suffixLength Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Vector a -> Int
forall a. Vector a -> Int
Vector.length Vector a
l = Maybe (Vector a)
forall a. Maybe a
Nothing
| Bool
otherwise = Int -> Maybe (Vector a)
strip (Int -> Int
forall a. Enum a => a -> a
pred Int
suffixLength)
where strip :: Int -> Maybe (Vector a)
strip i :: Int
i | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== -1 = Vector a -> Maybe (Vector a)
forall a. a -> Maybe a
Just (Int -> Vector a -> Vector a
forall a. Int -> Vector a -> Vector a
Vector.take Int
lengthDifference Vector a
l)
| Vector a
l Vector a -> Int -> a
forall a. Vector a -> Int -> a
Vector.! (Int
lengthDifference Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== Vector a
s Vector a -> Int -> a
forall a. Vector a -> Int -> a
Vector.! Int
i = Int -> Maybe (Vector a)
strip (Int -> Int
forall a. Enum a => a -> a
pred Int
i)
| Bool
otherwise = Maybe (Vector a)
forall a. Maybe a
Nothing
suffixLength :: Int
suffixLength = Vector a -> Int
forall a. Vector a -> Int
Vector.length Vector a
s
lengthDifference :: Int
lengthDifference = Vector a -> Int
forall a. Vector a -> Int
Vector.length Vector a
l Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
suffixLength
isSuffixOf :: Vector a -> Vector a -> Bool
isSuffixOf s :: Vector a
s l :: Vector a
l | Int
suffixLength Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Vector a -> Int
forall a. Vector a -> Int
Vector.length Vector a
l = Bool
False
| Bool
otherwise = Int -> Bool
test (Int -> Int
forall a. Enum a => a -> a
pred Int
suffixLength)
where test :: Int -> Bool
test i :: Int
i | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== -1 = Bool
True
| Vector a
l Vector a -> Int -> a
forall a. Vector a -> Int -> a
Vector.! (Int
lengthDifference Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== Vector a
s Vector a -> Int -> a
forall a. Vector a -> Int -> a
Vector.! Int
i = Int -> Bool
test (Int -> Int
forall a. Enum a => a -> a
pred Int
i)
| Bool
otherwise = Bool
False
suffixLength :: Int
suffixLength = Vector a -> Int
forall a. Vector a -> Int
Vector.length Vector a
s
lengthDifference :: Int
lengthDifference = Vector a -> Int
forall a. Vector a -> Int
Vector.length Vector a
l Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
suffixLength
instance Eq a => LeftCancellative (Vector.Vector a)
instance Eq a => RightCancellative (Vector.Vector a)
instance LeftReductive ByteString.ByteString where
stripPrefix :: ByteString -> ByteString -> Maybe ByteString
stripPrefix p :: ByteString
p l :: ByteString
l = if ByteString -> ByteString -> Bool
ByteString.isPrefixOf ByteString
p ByteString
l
then ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Int -> ByteString -> ByteString
ByteString.unsafeDrop (ByteString -> Int
ByteString.length ByteString
p) ByteString
l)
else Maybe ByteString
forall a. Maybe a
Nothing
isPrefixOf :: ByteString -> ByteString -> Bool
isPrefixOf = ByteString -> ByteString -> Bool
ByteString.isPrefixOf
instance RightReductive ByteString.ByteString where
stripSuffix :: ByteString -> ByteString -> Maybe ByteString
stripSuffix s :: ByteString
s l :: ByteString
l = if ByteString -> ByteString -> Bool
ByteString.isSuffixOf ByteString
s ByteString
l
then ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Int -> ByteString -> ByteString
ByteString.unsafeTake (ByteString -> Int
ByteString.length ByteString
l Int -> Int -> Int
forall a. Num a => a -> a -> a
- ByteString -> Int
ByteString.length ByteString
s) ByteString
l)
else Maybe ByteString
forall a. Maybe a
Nothing
isSuffixOf :: ByteString -> ByteString -> Bool
isSuffixOf = ByteString -> ByteString -> Bool
ByteString.isSuffixOf
instance LeftCancellative ByteString.ByteString
instance RightCancellative ByteString.ByteString
instance LeftReductive LazyByteString.ByteString where
stripPrefix :: ByteString -> ByteString -> Maybe ByteString
stripPrefix p :: ByteString
p l :: ByteString
l = if ByteString -> ByteString -> Bool
LazyByteString.isPrefixOf ByteString
p ByteString
l
then ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Int64 -> ByteString -> ByteString
LazyByteString.drop (ByteString -> Int64
LazyByteString.length ByteString
p) ByteString
l)
else Maybe ByteString
forall a. Maybe a
Nothing
isPrefixOf :: ByteString -> ByteString -> Bool
isPrefixOf = ByteString -> ByteString -> Bool
LazyByteString.isPrefixOf
instance RightReductive LazyByteString.ByteString where
stripSuffix :: ByteString -> ByteString -> Maybe ByteString
stripSuffix s :: ByteString
s l :: ByteString
l = if ByteString -> ByteString -> Bool
LazyByteString.isSuffixOf ByteString
s ByteString
l
then ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Int64 -> ByteString -> ByteString
LazyByteString.take (ByteString -> Int64
LazyByteString.length ByteString
l Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
- ByteString -> Int64
LazyByteString.length ByteString
s) ByteString
l)
else Maybe ByteString
forall a. Maybe a
Nothing
isSuffixOf :: ByteString -> ByteString -> Bool
isSuffixOf = ByteString -> ByteString -> Bool
LazyByteString.isSuffixOf
instance LeftCancellative LazyByteString.ByteString
instance RightCancellative LazyByteString.ByteString
instance LeftReductive Text.Text where
stripPrefix :: Text -> Text -> Maybe Text
stripPrefix = Text -> Text -> Maybe Text
Text.stripPrefix
isPrefixOf :: Text -> Text -> Bool
isPrefixOf = Text -> Text -> Bool
Text.isPrefixOf
instance RightReductive Text.Text where
stripSuffix :: Text -> Text -> Maybe Text
stripSuffix = Text -> Text -> Maybe Text
Text.stripSuffix
isSuffixOf :: Text -> Text -> Bool
isSuffixOf = Text -> Text -> Bool
Text.isSuffixOf
instance LeftCancellative Text.Text
instance RightCancellative Text.Text
instance LeftReductive LazyText.Text where
stripPrefix :: Text -> Text -> Maybe Text
stripPrefix = Text -> Text -> Maybe Text
LazyText.stripPrefix
isPrefixOf :: Text -> Text -> Bool
isPrefixOf = Text -> Text -> Bool
LazyText.isPrefixOf
instance RightReductive LazyText.Text where
stripSuffix :: Text -> Text -> Maybe Text
stripSuffix = Text -> Text -> Maybe Text
LazyText.stripSuffix
isSuffixOf :: Text -> Text -> Bool
isSuffixOf = Text -> Text -> Bool
LazyText.isSuffixOf
instance LeftCancellative LazyText.Text
instance RightCancellative LazyText.Text