    {-# LANGUAGE MultiParamTypeClasses
                ,TypeFamilies
                ,FlexibleInstances #-}
    {-# OPTIONS -Wno-orphans #-}

    module Data.ListLike.Vector.Unboxed ()

    where

    import           Prelude as P
    import qualified Data.Vector.Unboxed as V
    import           Data.Vector.Unboxed (Unbox, (!))
    import           Data.ListLike.Base
    import           Data.ListLike.FoldableLL
    import           Data.ListLike.String
    import           Data.String (IsString)

    instance Unbox a => FoldableLL (V.Vector a) a where
        foldl :: forall a. (a -> a -> a) -> a -> Vector a -> a
    foldl = (a -> a -> a) -> a -> Vector a -> a
    forall b a. Unbox b => (a -> b -> a) -> a -> Vector b -> a
    V.foldl
        foldl' :: forall a. (a -> a -> a) -> a -> Vector a -> a
    foldl' = (a -> a -> a) -> a -> Vector a -> a
    forall b a. Unbox b => (a -> b -> a) -> a -> Vector b -> a
    V.foldl'
        foldl1 :: (a -> a -> a) -> Vector a -> a
    foldl1 = (a -> a -> a) -> Vector a -> a
    forall a. Unbox a => (a -> a -> a) -> Vector a -> a
    V.foldl1
        foldr :: forall b. (a -> b -> b) -> b -> Vector a -> b
    foldr = (a -> b -> b) -> b -> Vector a -> b
    forall a b. Unbox a => (a -> b -> b) -> b -> Vector a -> b
    V.foldr
        foldr' :: forall b. (a -> b -> b) -> b -> Vector a -> b
    foldr' = (a -> b -> b) -> b -> Vector a -> b
    forall a b. Unbox a => (a -> b -> b) -> b -> Vector a -> b
    V.foldr'
        foldr1 :: (a -> a -> a) -> Vector a -> a
    foldr1 = (a -> a -> a) -> Vector a -> a
    forall a. Unbox a => (a -> a -> a) -> Vector a -> a
    V.foldr1

    instance Unbox a => ListLike (V.Vector a) a where
        empty :: Vector a
    empty = Vector a
    forall a. Unbox a => Vector a
    V.empty
        singleton :: a -> Vector a
    singleton = a -> Vector a
    forall a. Unbox a => a -> Vector a
    V.singleton
        cons :: a -> Vector a -> Vector a
    cons = a -> Vector a -> Vector a
    forall a. Unbox a => a -> Vector a -> Vector a
    V.cons
        snoc :: Vector a -> a -> Vector a
    snoc = Vector a -> a -> Vector a
    forall a. Unbox a => Vector a -> a -> Vector a
    V.snoc
        append :: Vector a -> Vector a -> Vector a
    append = Vector a -> Vector a -> Vector a
    forall a. Monoid a => a -> a -> a
    mappend
        head :: Vector a -> a
    head = Vector a -> a
    forall a. Unbox a => Vector a -> a
    V.head
        last :: Vector a -> a
    last = Vector a -> a
    forall a. Unbox a => Vector a -> a
    V.last
        tail :: Vector a -> Vector a
    tail = Vector a -> Vector a
    forall a. Unbox a => Vector a -> Vector a
    V.tail
        init :: Vector a -> Vector a
    init = Vector a -> Vector a
    forall a. Unbox a => Vector a -> Vector a
    V.init
        null :: Vector a -> Bool
    null = Vector a -> Bool
    forall a. Unbox a => Vector a -> Bool
    V.null
        length :: Vector a -> Int
    length = Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length
        rigidMap :: (a -> a) -> Vector a -> Vector a
    rigidMap = (a -> a) -> Vector a -> Vector a
    forall a b. (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
    V.map
        reverse :: Vector a -> Vector a
    reverse = Vector a -> Vector a
    forall a. Unbox a => Vector a -> Vector a
    V.reverse
        --intersperse =
        concat :: forall full'. ListLike full' (Vector a) => full' -> Vector a
    concat = [Vector a] -> Vector a
    forall a. Unbox a => [Vector a] -> Vector a
    V.concat ([Vector a] -> Vector a)
    -> (full' -> [Vector a]) -> full' -> Vector a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . full' -> [Item full']
    full' -> [Vector a]
    forall l. IsList l => l -> [Item l]
    toList
        rigidConcatMap :: (a -> Vector a) -> Vector a -> Vector a
    rigidConcatMap = (a -> Vector a) -> Vector a -> Vector a
    forall a b.
    (Unbox a, Unbox b) =>
    (a -> Vector b) -> Vector a -> Vector b
    V.concatMap
        any :: (a -> Bool) -> Vector a -> Bool
    any = (a -> Bool) -> Vector a -> Bool
    forall a. Unbox a => (a -> Bool) -> Vector a -> Bool
    V.any
        all :: (a -> Bool) -> Vector a -> Bool
    all = (a -> Bool) -> Vector a -> Bool
    forall a. Unbox a => (a -> Bool) -> Vector a -> Bool
    V.all
        maximum :: Ord a => Vector a -> a
    maximum = Vector a -> a
    forall a. (Unbox a, Ord a) => Vector a -> a
    V.maximum
        minimum :: Ord a => Vector a -> a
    minimum = Vector a -> a
    forall a. (Unbox a, Ord a) => Vector a -> a
    V.minimum
        replicate :: Int -> a -> Vector a
    replicate = Int -> a -> Vector a
    forall a. Unbox a => Int -> a -> Vector a
    V.replicate
        take :: Int -> Vector a -> Vector a
    take = Int -> Vector a -> Vector a
    forall a. Unbox a => Int -> Vector a -> Vector a
    V.take
        drop :: Int -> Vector a -> Vector a
    drop = Int -> Vector a -> Vector a
    forall a. Unbox a => Int -> Vector a -> Vector a
    V.drop
        --splitAt =
        takeWhile :: (a -> Bool) -> Vector a -> Vector a
    takeWhile = (a -> Bool) -> Vector a -> Vector a
    forall a. Unbox a => (a -> Bool) -> Vector a -> Vector a
    V.takeWhile
        dropWhile :: (a -> Bool) -> Vector a -> Vector a
    dropWhile = (a -> Bool) -> Vector a -> Vector a
    forall a. Unbox a => (a -> Bool) -> Vector a -> Vector a
    V.dropWhile
        span :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
    span = (a -> Bool) -> Vector a -> (Vector a, Vector a)
    forall a.
    Unbox a =>
    (a -> Bool) -> Vector a -> (Vector a, Vector a)
    V.span
        break :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
    break = (a -> Bool) -> Vector a -> (Vector a, Vector a)
    forall a.
    Unbox a =>
    (a -> Bool) -> Vector a -> (Vector a, Vector a)
    V.break
        --group =
        --inits =
        --tails =
        isPrefixOf :: Eq a => Vector a -> Vector a -> Bool
    isPrefixOf = Vector a -> Vector a -> Bool
    forall a. (Unbox a, Eq a) => Vector a -> Vector a -> Bool
    isPrefixOf'
        isSuffixOf :: Eq a => Vector a -> Vector a -> Bool
    isSuffixOf = Vector a -> Vector a -> Bool
    forall a. (Unbox a, Eq a) => Vector a -> Vector a -> Bool
    isSuffixOf'
        elem :: Eq a => a -> Vector a -> Bool
    elem = a -> Vector a -> Bool
    forall a. (Unbox a, Eq a) => a -> Vector a -> Bool
    V.elem
        find :: (a -> Bool) -> Vector a -> Maybe a
    find = (a -> Bool) -> Vector a -> Maybe a
    forall a. Unbox a => (a -> Bool) -> Vector a -> Maybe a
    V.find
        filter :: (a -> Bool) -> Vector a -> Vector a
    filter = (a -> Bool) -> Vector a -> Vector a
    forall a. Unbox a => (a -> Bool) -> Vector a -> Vector a
    V.filter
        index :: Vector a -> Int -> a
    index = Vector a -> Int -> a
    forall a. Unbox a => Vector a -> Int -> a
    (!)
        findIndex :: (a -> Bool) -> Vector a -> Maybe Int
    findIndex = (a -> Bool) -> Vector a -> Maybe Int
    forall a. Unbox a => (a -> Bool) -> Vector a -> Maybe Int
    V.findIndex
        --toList = V.toList
        --fromList = V.fromList
        --fromListLike = fromList . toList
        --groupBy f =
        genericLength :: forall a. Num a => Vector a -> a
    genericLength = Integer -> a
    forall a. Num a => Integer -> a
    fromInteger (Integer -> a) -> (Vector a -> Integer) -> Vector a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Integer) -> (Vector a -> Int) -> Vector a -> Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length
        genericTake :: forall a. Integral a => a -> Vector a -> Vector a
    genericTake a
    i = Int -> Vector a -> Vector a
    forall a. Unbox a => Int -> Vector a -> Vector a
    V.take (a -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral a
    i)
        genericDrop :: forall a. Integral a => a -> Vector a -> Vector a
    genericDrop a
    i = Int -> Vector a -> Vector a
    forall a. Unbox a => Int -> Vector a -> Vector a
    V.drop (a -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral a
    i)
        --genericSplitAt i =
        genericReplicate :: forall a. Integral a => a -> a -> Vector a
    genericReplicate a
    i = Int -> a -> Vector a
    forall a. Unbox a => Int -> a -> Vector a
    V.replicate (a -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral a
    i)

        sequence :: forall (m :: * -> *) fullinp.
    (Applicative m, ListLike fullinp (m a)) =>
    fullinp -> m (Vector a)
    sequence  = ([a] -> Vector a) -> m [a] -> m (Vector a)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [a] -> Vector a
    [Item (Vector a)] -> Vector a
    forall l. IsList l => [Item l] -> l
    fromList (m [a] -> m (Vector a))
    -> (fullinp -> m [a]) -> fullinp -> m (Vector a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [m a] -> m [a]
    forall (t :: * -> *) (f :: * -> *) a.
    (Traversable t, Applicative f) =>
    t (f a) -> f (t a)
    forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
    P.sequenceA  ([m a] -> m [a]) -> (fullinp -> [m a]) -> fullinp -> m [a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . fullinp -> [m a]
    fullinp -> [Item fullinp]
    forall l. IsList l => l -> [Item l]
    toList
        mapM :: forall (m :: * -> *) full' item'.
    (Applicative m, ListLike full' item') =>
    (a -> m item') -> Vector a -> m full'
    mapM a -> m item'
    func = ([item'] -> full') -> m [item'] -> m full'
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [item'] -> full'
    [Item full'] -> full'
    forall l. IsList l => [Item l] -> l
    fromList (m [item'] -> m full')
    -> (Vector a -> m [item']) -> Vector a -> m full'
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> m item') -> [a] -> m [item']
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    P.traverse a -> m item'
    func ([a] -> m [item']) -> (Vector a -> [a]) -> Vector a -> m [item']
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Vector a -> [a]
    Vector a -> [Item (Vector a)]
    forall l. IsList l => l -> [Item l]
    toList

    instance IsString (V.Vector Char) where
        fromString :: String -> Vector Char
    fromString = String -> Vector Char
    [Item (Vector Char)] -> Vector Char
    forall l. IsList l => [Item l] -> l
    fromList

    instance StringLike (V.Vector Char) where
        toString :: Vector Char -> String
    toString = Vector Char -> String
    Vector Char -> [Item (Vector Char)]
    forall l. IsList l => l -> [Item l]
    toList
        --words =
        --lines =
        unwords :: forall full. ListLike full (Vector Char) => full -> Vector Char
    unwords = let sp :: Vector Char
    sp = Char -> Vector Char
    forall a. Unbox a => a -> Vector a
    V.singleton Char
    ' ' in [Vector Char] -> Vector Char
    forall a. Unbox a => [Vector a] -> Vector a
    V.concat ([Vector Char] -> Vector Char)
    -> (full -> [Vector Char]) -> full -> Vector Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Vector Char -> [Vector Char] -> [Vector Char]
    forall full item. ListLike full item => item -> full -> full
    intersperse Vector Char
    sp ([Vector Char] -> [Vector Char])
    -> (full -> [Vector Char]) -> full -> [Vector Char]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . full -> [Item full]
    full -> [Vector Char]
    forall l. IsList l => l -> [Item l]
    toList
        unlines :: forall full. ListLike full (Vector Char) => full -> Vector Char
    unlines = let eol :: Vector Char
    eol = Char -> Vector Char
    forall a. Unbox a => a -> Vector a
    V.singleton Char
    '\n' in [Vector Char] -> Vector Char
    forall a. Unbox a => [Vector a] -> Vector a
    V.concat ([Vector Char] -> Vector Char)
    -> (full -> [Vector Char]) -> full -> Vector Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Vector Char -> [Vector Char] -> [Vector Char]
    forall full item. ListLike full item => item -> full -> full
    intersperse Vector Char
    eol ([Vector Char] -> [Vector Char])
    -> (full -> [Vector Char]) -> full -> [Vector Char]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . full -> [Item full]
    full -> [Vector Char]
    forall l. IsList l => l -> [Item l]
    toList

    isPrefixOf' :: (Unbox a, Eq a) => V.Vector a -> V.Vector a -> Bool
    isPrefixOf' :: forall a. (Unbox a, Eq a) => Vector a -> Vector a -> Bool
    isPrefixOf' Vector a
    needle Vector a
    haystack
      | Vector a -> Bool
    forall a. Unbox a => Vector a -> Bool
    V.null Vector a
    needle = Bool
    True
      | Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    needle Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    haystack =
                Vector a
    needle Vector a -> Vector a -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int -> Int -> Vector a -> Vector a
    forall a. Unbox a => Int -> Int -> Vector a -> Vector a
    V.slice Int
    0 (Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    needle) Vector a
    haystack
      | Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    needle Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    haystack = Vector a
    needle Vector a -> Vector a -> Bool
    forall a. Eq a => a -> a -> Bool
    == Vector a
    haystack
      | Bool
    otherwise = Bool
    False
    isSuffixOf' :: (Unbox a, Eq a) => V.Vector a -> V.Vector a -> Bool
    isSuffixOf' :: forall a. (Unbox a, Eq a) => Vector a -> Vector a -> Bool
    isSuffixOf' Vector a
    needle Vector a
    haystack
      | Vector a -> Bool
    forall a. Unbox a => Vector a -> Bool
    V.null Vector a
    needle = Bool
    True
      | Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    needle Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    haystack =
            Vector a
    needle Vector a -> Vector a -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int -> Int -> Vector a -> Vector a
    forall a. Unbox a => Int -> Int -> Vector a -> Vector a
    V.slice (Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    haystack Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    needle)
                              (Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    needle)
                              Vector a
    haystack
      | Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    needle Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Vector a -> Int
    forall a. Unbox a => Vector a -> Int
    V.length Vector a
    haystack = Vector a
    needle Vector a -> Vector a -> Bool
    forall a. Eq a => a -> a -> Bool
    == Vector a
    haystack
      | Bool
    otherwise = Bool
    False