    {-
        Copyright 2017 Mario Blazevic

        License: BSD3 (see BSD3-LICENSE.txt file)
    -}

    -- | This module contains orphan 'IsString' and 'TextualMonoid' instances of @Vector Char@.
    --

    {-# LANGUAGE Haskell2010, FlexibleInstances, Trustworthy #-}
    {-# OPTIONS_GHC -Wno-orphans #-}

    module Data.Monoid.Instances.CharVector where

    import Data.String (IsString(fromString))
    import qualified Data.Vector as Vector

    import Data.Monoid.Textual (TextualMonoid(..))

    instance IsString (Vector.Vector Char) where
       fromString :: String -> Vector Char
    fromString = String -> Vector Char
    forall a. [a] -> Vector a
    Vector.fromList

    instance TextualMonoid (Vector.Vector Char) where
       singleton :: Char -> Vector Char
    singleton = Char -> Vector Char
    forall a. a -> Vector a
    Vector.singleton
       splitCharacterPrefix :: Vector Char -> Maybe (Char, Vector Char)
    splitCharacterPrefix Vector Char
    t = if Vector Char -> Bool
    forall a. Vector a -> Bool
    Vector.null Vector Char
    t then Maybe (Char, Vector Char)
    forall a. Maybe a
    Nothing else (Char, Vector Char) -> Maybe (Char, Vector Char)
    forall a. a -> Maybe a
    Just (Vector Char -> Char
    forall a. Vector a -> a
    Vector.unsafeHead Vector Char
    t, Vector Char -> Vector Char
    forall a. Vector a -> Vector a
    Vector.unsafeTail Vector Char
    t)
       characterPrefix :: Vector Char -> Maybe Char
    characterPrefix = (Vector Char -> Int -> Maybe Char
    forall a. Vector a -> Int -> Maybe a
    Vector.!? Int
    0)
       map :: (Char -> Char) -> Vector Char -> Vector Char
    map = (Char -> Char) -> Vector Char -> Vector Char
    forall a b. (a -> b) -> Vector a -> Vector b
    Vector.map
       concatMap :: (Char -> Vector Char) -> Vector Char -> Vector Char
    concatMap = (Char -> Vector Char) -> Vector Char -> Vector Char
    forall a b. (a -> Vector b) -> Vector a -> Vector b
    Vector.concatMap
       toString :: (Vector Char -> String) -> Vector Char -> String
    toString = (Vector Char -> String)
    -> (Vector Char -> String) -> Vector Char -> String
    forall a b. a -> b -> a
    const Vector Char -> String
    forall a. Vector a -> [a]
    Vector.toList
       any :: (Char -> Bool) -> Vector Char -> Bool
    any = (Char -> Bool) -> Vector Char -> Bool
    forall a. (a -> Bool) -> Vector a -> Bool
    Vector.any
       all :: (Char -> Bool) -> Vector Char -> Bool
    all = (Char -> Bool) -> Vector Char -> Bool
    forall a. (a -> Bool) -> Vector a -> Bool
    Vector.all

       foldl :: forall a.
    (a -> Vector Char -> a)
    -> (a -> Char -> a) -> a -> Vector Char -> a
    foldl   = ((a -> Char -> a) -> a -> Vector Char -> a)
    -> (a -> Vector Char -> a)
    -> (a -> Char -> a)
    -> a
    -> Vector Char
    -> a
    forall a b. a -> b -> a
    const (a -> Char -> a) -> a -> Vector Char -> a
    forall a b. (a -> b -> a) -> a -> Vector b -> a
    Vector.foldl
       foldl' :: forall a.
    (a -> Vector Char -> a)
    -> (a -> Char -> a) -> a -> Vector Char -> a
    foldl'  = ((a -> Char -> a) -> a -> Vector Char -> a)
    -> (a -> Vector Char -> a)
    -> (a -> Char -> a)
    -> a
    -> Vector Char
    -> a
    forall a b. a -> b -> a
    const (a -> Char -> a) -> a -> Vector Char -> a
    forall a b. (a -> b -> a) -> a -> Vector b -> a
    Vector.foldl'
       foldr :: forall a.
    (Vector Char -> a -> a)
    -> (Char -> a -> a) -> a -> Vector Char -> a
    foldr   = ((Char -> a -> a) -> a -> Vector Char -> a)
    -> (Vector Char -> a -> a)
    -> (Char -> a -> a)
    -> a
    -> Vector Char
    -> a
    forall a b. a -> b -> a
    const (Char -> a -> a) -> a -> Vector Char -> a
    forall a b. (a -> b -> b) -> b -> Vector a -> b
    Vector.foldr

       scanl :: (Char -> Char -> Char) -> Char -> Vector Char -> Vector Char
    scanl = (Char -> Char -> Char) -> Char -> Vector Char -> Vector Char
    forall a b. (a -> b -> a) -> a -> Vector b -> Vector a
    Vector.scanl
       scanl1 :: (Char -> Char -> Char) -> Vector Char -> Vector Char
    scanl1 Char -> Char -> Char
    f Vector Char
    v | Vector Char -> Bool
    forall a. Vector a -> Bool
    Vector.null Vector Char
    v = Vector Char
    forall a. Vector a
    Vector.empty
                  | Bool
    otherwise = (Char -> Char -> Char) -> Vector Char -> Vector Char
    forall a. (a -> a -> a) -> Vector a -> Vector a
    Vector.scanl1 Char -> Char -> Char
    f Vector Char
    v
       scanr :: (Char -> Char -> Char) -> Char -> Vector Char -> Vector Char
    scanr = (Char -> Char -> Char) -> Char -> Vector Char -> Vector Char
    forall a b. (a -> b -> b) -> b -> Vector a -> Vector b
    Vector.scanr
       scanr1 :: (Char -> Char -> Char) -> Vector Char -> Vector Char
    scanr1 Char -> Char -> Char
    f Vector Char
    v | Vector Char -> Bool
    forall a. Vector a -> Bool
    Vector.null Vector Char
    v = Vector Char
    forall a. Vector a
    Vector.empty
                  | Bool
    otherwise = (Char -> Char -> Char) -> Vector Char -> Vector Char
    forall a. (a -> a -> a) -> Vector a -> Vector a
    Vector.scanr1 Char -> Char -> Char
    f Vector Char
    v
       mapAccumL :: forall a.
    (a -> Char -> (a, Char)) -> a -> Vector Char -> (a, Vector Char)
    mapAccumL a -> Char -> (a, Char)
    f a
    a0 Vector Char
    t = (a
    a', Vector Char -> Vector Char
    forall a. Vector a -> Vector a
    Vector.reverse (Vector Char -> Vector Char) -> Vector Char -> Vector Char
    forall a b. (a -> b) -> a -> b
    $ String -> Vector Char
    forall a. [a] -> Vector a
    Vector.fromList String
    l')
          where (a
    a', String
    l') = ((a, String) -> Char -> (a, String))
    -> (a, String) -> Vector Char -> (a, String)
    forall a b. (a -> b -> a) -> a -> Vector b -> a
    Vector.foldl (a, String) -> Char -> (a, String)
    fc (a
    a0, []) Vector Char
    t
                fc :: (a, String) -> Char -> (a, String)
    fc (a
    a, String
    l) Char
    c = (Char -> String -> String
    forall a. a -> [a] -> [a]
    :String
    l) (Char -> String) -> (a, Char) -> (a, String)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> Char -> (a, Char)
    f a
    a Char
    c
       mapAccumR :: forall a.
    (a -> Char -> (a, Char)) -> a -> Vector Char -> (a, Vector Char)
    mapAccumR a -> Char -> (a, Char)
    f a
    a0 Vector Char
    t = (a
    a', String -> Vector Char
    forall a. [a] -> Vector a
    Vector.fromList String
    l')
          where (a
    a', String
    l') = (Char -> (a, String) -> (a, String))
    -> (a, String) -> Vector Char -> (a, String)
    forall a b. (a -> b -> b) -> b -> Vector a -> b
    Vector.foldr Char -> (a, String) -> (a, String)
    fc (a
    a0, []) Vector Char
    t
                fc :: Char -> (a, String) -> (a, String)
    fc Char
    c (a
    a, String
    l) = (Char -> String -> String
    forall a. a -> [a] -> [a]
    :String
    l) (Char -> String) -> (a, Char) -> (a, String)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> Char -> (a, Char)
    f a
    a Char
    c

       takeWhile :: (Vector Char -> Bool)
    -> (Char -> Bool) -> Vector Char -> Vector Char
    takeWhile Vector Char -> Bool
    _ = (Char -> Bool) -> Vector Char -> Vector Char
    forall a. (a -> Bool) -> Vector a -> Vector a
    Vector.takeWhile
       dropWhile :: (Vector Char -> Bool)
    -> (Char -> Bool) -> Vector Char -> Vector Char
    dropWhile Vector Char -> Bool
    _ = (Char -> Bool) -> Vector Char -> Vector Char
    forall a. (a -> Bool) -> Vector a -> Vector a
    Vector.dropWhile
       break :: (Vector Char -> Bool)
    -> (Char -> Bool) -> Vector Char -> (Vector Char, Vector Char)
    break Vector Char -> Bool
    _ = (Char -> Bool) -> Vector Char -> (Vector Char, Vector Char)
    forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
    Vector.break
       span :: (Vector Char -> Bool)
    -> (Char -> Bool) -> Vector Char -> (Vector Char, Vector Char)
    span Vector Char -> Bool
    _ = (Char -> Bool) -> Vector Char -> (Vector Char, Vector Char)
    forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
    Vector.span
       spanMaybe :: forall s.
    s
    -> (s -> Vector Char -> Maybe s)
    -> (s -> Char -> Maybe s)
    -> Vector Char
    -> (Vector Char, Vector Char, s)
    spanMaybe s
    s0 s -> Vector Char -> Maybe s
    _ft s -> Char -> Maybe s
    fc Vector Char
    v = case (Int -> Char -> (s -> Either s (Int, s)) -> s -> Either s (Int, s))
    -> (s -> Either s (Int, s))
    -> Vector Char
    -> s
    -> Either s (Int, s)
    forall a b. (Int -> a -> b -> b) -> b -> Vector a -> b
    Vector.ifoldr Int -> Char -> (s -> Either s (Int, s)) -> s -> Either s (Int, s)
    forall {a} {a}.
    a -> Char -> (s -> Either a (a, s)) -> s -> Either a (a, s)
    g s -> Either s (Int, s)
    forall a b. a -> Either a b
    Left Vector Char
    v s
    s0
                               of Left s
    s' -> (Vector Char
    v, Vector Char
    forall a. Vector a
    Vector.empty, s
    s')
                                  Right (Int
    i, s
    s') | (Vector Char
    prefix, Vector Char
    suffix) <- Int -> Vector Char -> (Vector Char, Vector Char)
    forall a. Int -> Vector a -> (Vector a, Vector a)
    Vector.splitAt Int
    i Vector Char
    v -> (Vector Char
    prefix, Vector Char
    suffix, s
    s')
          where g :: a -> Char -> (s -> Either a (a, s)) -> s -> Either a (a, s)
    g a
    i Char
    c s -> Either a (a, s)
    cont s
    s | Just s
    s' <- s -> Char -> Maybe s
    fc s
    s Char
    c = s -> Either a (a, s)
    cont s
    s'
                             | Bool
    otherwise = (a, s) -> Either a (a, s)
    forall a b. b -> Either a b
    Right (a
    i, s
    s)
       spanMaybe' :: forall s.
    s
    -> (s -> Vector Char -> Maybe s)
    -> (s -> Char -> Maybe s)
    -> Vector Char
    -> (Vector Char, Vector Char, s)
    spanMaybe' s
    s0 s -> Vector Char -> Maybe s
    _ft s -> Char -> Maybe s
    fc Vector Char
    v = case (Int -> Char -> (s -> Either s (Int, s)) -> s -> Either s (Int, s))
    -> (s -> Either s (Int, s))
    -> Vector Char
    -> s
    -> Either s (Int, s)
    forall a b. (Int -> a -> b -> b) -> b -> Vector a -> b
    Vector.ifoldr' Int -> Char -> (s -> Either s (Int, s)) -> s -> Either s (Int, s)
    forall {a} {a}.
    a -> Char -> (s -> Either a (a, s)) -> s -> Either a (a, s)
    g s -> Either s (Int, s)
    forall a b. a -> Either a b
    Left Vector Char
    v s
    s0
                                of Left s
    s' -> (Vector Char
    v, Vector Char
    forall a. Vector a
    Vector.empty, s
    s')
                                   Right (Int
    i, s
    s') | (Vector Char
    prefix, Vector Char
    suffix) <- Int -> Vector Char -> (Vector Char, Vector Char)
    forall a. Int -> Vector a -> (Vector a, Vector a)
    Vector.splitAt Int
    i Vector Char
    v -> (Vector Char
    prefix, Vector Char
    suffix, s
    s')
          where g :: a -> Char -> (s -> Either a (a, s)) -> s -> Either a (a, s)
    g a
    i Char
    c s -> Either a (a, s)
    cont s
    s | Just s
    s' <- s -> Char -> Maybe s
    fc s
    s Char
    c = s -> Either a (a, s) -> Either a (a, s)
    forall a b. a -> b -> b
    seq s
    s' (s -> Either a (a, s)
    cont s
    s')
                             | Bool
    otherwise = (a, s) -> Either a (a, s)
    forall a b. b -> Either a b
    Right (a
    i, s
    s)
       find :: (Char -> Bool) -> Vector Char -> Maybe Char
    find = (Char -> Bool) -> Vector Char -> Maybe Char
    forall a. (a -> Bool) -> Vector a -> Maybe a
    Vector.find
       elem :: Char -> Vector Char -> Bool
    elem = Char -> Vector Char -> Bool
    forall a. Eq a => a -> Vector a -> Bool
    Vector.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 mapAccumL #-}
       {-# INLINE mapAccumR #-}
       {-# INLINE scanl #-}
       {-# INLINE scanl1 #-}
       {-# INLINE scanr #-}
       {-# INLINE scanr1 #-}
       {-# INLINE singleton #-}
       {-# INLINE span #-}
       {-# INLINE spanMaybe #-}
       {-# INLINE spanMaybe' #-}
       {-# INLINE splitCharacterPrefix #-}
       {-# INLINE takeWhile #-}