{-# LANGUAGE TypeOperators #-}
module Properties.Monomorphic.UVector where

--
-- just test the List api
--

import Properties.Utils

import qualified Data.Array.Vector as List
import Data.Array.Vector (UArr, (:*:))

-- * Basic interface
cons            :: A   -> UArr A -> UArr A
snoc            :: UArr A -> A -> UArr A
empty           :: UArr A
singleton       :: A -> UArr A
head            :: UArr A -> A
length          :: UArr A -> Int
append          :: UArr A -> UArr A -> UArr A
tail            :: UArr A -> UArr A
null            :: UArr A -> Bool
init            :: UArr A -> UArr A
last            :: UArr A -> A

-- * List transformations
map            :: (A -> B) -> UArr A -> UArr B

{-
reverse         :: [A] -> [A]
intersperse     :: A -> [A] -> [A]
intercalate     :: [A] -> [[A]] -> [A]
transpose       :: [[A]] -> [[A]]

-- * Reducing lists (folds)
-}
foldl           :: (B -> A -> B) -> B -> UArr A -> B
foldl1          :: (A -> A -> A) -> UArr A -> A
{-
foldl'          :: (B -> A -> B) -> B -> [A] -> B
foldl1'         :: (A -> A -> A) -> [A] -> A
foldr           :: (A -> B -> B) -> B -> [A] -> B
foldr1          :: (A -> A -> A) -> [A] -> A

-- ** Special folds
concat          :: [[A]] -> [A]
concatMap       :: (A -> [B]) -> [A] -> [B]
-}
and             :: UArr Bool -> Bool
or              :: UArr Bool -> Bool
any             :: (A -> Bool) -> UArr A -> Bool
all             :: (A -> Bool) -> UArr A -> Bool
sum             :: UArr N -> N
product         :: UArr N -> N
maximum         :: UArr OrdA -> OrdA
minimum         :: UArr OrdA -> OrdA

-- * Building lists
-- ** Scans

scanl           :: (A -> B -> A) -> A -> UArr B -> UArr A
{-
scanl1          :: (A -> A -> A) -> [A] -> [A]
scanr           :: (A -> B -> B) -> B -> [A] -> [B]
scanr1          :: (A -> A -> A) -> [A] -> [A]
-}

-- ** Accumulating maps
{-
mapAccumL       :: (C -> A -> (C, B)) -> C -> UArr A -> UArr B
mapAccumR       :: (C -> A -> (C, B)) -> C -> [A] -> (C, [B])

-- ** Infinite lists
iterate         :: (A -> A) -> A -> [A]
repeat          :: A -> [A]
-}
replicate       :: Int -> A -> UArr A
{-
cycle           :: [A] -> [A]

-- ** Unfolding
unfoldr         :: (B -> Maybe (A, B)) -> B -> [A]

-}

-- * Sublists
-- ** Extracting sublists
take            :: Int -> UArr A -> UArr A
drop            :: Int -> UArr A -> UArr A
splitAt         :: Int -> UArr A -> (UArr A, UArr A)
takeWhile       :: (A -> Bool) -> UArr A -> UArr A
dropWhile       :: (A -> Bool) -> UArr A -> UArr A
{-
span            :: (A -> Bool) -> [A] -> ([A], [A])
break           :: (A -> Bool) -> [A] -> ([A], [A])
group           :: [A] -> [[A]]
inits           :: [A] -> [[A]]
tails           :: [A] -> [[A]]

-- * Predicates
isPrefixOf      :: [A] -> [A] -> Bool
isSuffixOf      :: [A] -> [A] -> Bool
isInfixOf       :: [A] -> [A] -> Bool

-}

-- * Searching lists
-- ** Searching by equality
elem            :: A -> UArr A -> Bool
notElem         :: A -> UArr A -> Bool
lookup          :: A -> UArr (A :*: B) -> Maybe B

-- ** Searching with A predicate
find            :: (A -> Bool) -> UArr A -> Maybe A
filter          :: (A -> Bool) -> UArr A -> UArr A
{-
partition       :: (A -> Bool) -> [A] -> ([A], [A])
-}

-- * Indexing lists
index           :: UArr A -> Int -> A
{-
elemIndex       :: A -> [A] -> Maybe Int
elemIndices     :: A -> [A] -> [Int]
findIndex       :: (A -> Bool) -> [A] -> Maybe Int
findIndices     :: (A -> Bool) -> [A] -> [Int]
-}

-- * Zipping and unzipping lists
zip             :: UArr A -> UArr B -> UArr (A :*: B)
zip3            :: UArr  A -> UArr B -> UArr C -> UArr (A :*: B :*: C)

{-
zip4            :: [A] -> [B] -> [C] -> [D] -> [(A, B, C, D)]
zip5            :: [A] -> [B] -> [C] -> [D] -> [E] -> [(A, B, C, D, E)]
zip6            :: [A] -> [B] -> [C] -> [D] -> [E] -> [F] -> [(A, B, C, D, E, F)]
zip7            :: [A] -> [B] -> [C] -> [D] -> [E] -> [F] -> [G] -> [(A, B, C, D, E, F, G)]
-}

zipWith         :: (A -> B -> C) -> UArr A -> UArr B -> UArr C
zipWith3        :: (A -> B -> C -> D) -> UArr A -> UArr B -> UArr C -> UArr D

{-
zipWith4        :: (A -> B -> C -> D -> E) -> [A] -> [B] -> [C] -> [D] -> [E]
zipWith5        :: (A -> B -> C -> D -> E -> F) -> [A] -> [B] -> [C] -> [D] -> [E] -> [F]
zipWith6        :: (A -> B -> C -> D -> E -> F -> G) -> [A] -> [B] -> [C] -> [D] -> [E] -> [F] -> [G]
zipWith7        :: (A -> B -> C -> D -> E -> F -> G -> H) -> [A] -> [B] -> [C] -> [D] -> [E] -> [F] -> [G] -> [H]
-}
-- unzip           :: [(A, B)] -> ([A], [B])
{-
unzip3          :: [(A, B, C)] -> ([A], [B], [C])
unzip4          :: [(A, B, C, D)] -> ([A], [B], [C], [D])
unzip5          :: [(A, B, C, D, E)] -> ([A], [B], [C], [D], [E])
unzip6          :: [(A, B, C, D, E, F)] -> ([A], [B], [C], [D], [E], [F])
unzip7          :: [(A, B, C, D, E, F, G)] -> ([A], [B], [C], [D], [E], [F], [G])
-}

{-
-- * Special lists
-- ** Functions on strings
lines           :: String -> [String]
words           :: String -> [String]
unlines         :: [String] -> String
unwords         :: [String] -> String

-- ** \"Set\" operations
nub             :: [A] -> [A]
delete          :: A -> [A] -> [A]
(\\)            :: [A] -> [A] -> [A]
union           :: [A] -> [A] -> [A]
intersect       :: [A] -> [A] -> [A]

-- ** Ordered lists 
sort            :: [OrdA] -> [OrdA]
insert          :: OrdA -> [OrdA] -> [OrdA]

-- * Generalized functions
-- ** The \"By\" operations
-- *** User-supplied equality (replacing an Eq context)
nubBy           :: (A -> A -> Bool) -> [A] -> [A]
deleteBy        :: (A -> A -> Bool) -> A -> [A] -> [A]
deleteFirstsBy  :: (A -> A -> Bool) -> [A] -> [A] -> [A]
unionBy         :: (A -> A -> Bool) -> [A] -> [A] -> [A]
intersectBy     :: (A -> A -> Bool) -> [A] -> [A] -> [A]
groupBy         :: (A -> A -> Bool) -> [A] -> [[A]]

-- *** User-supplied comparison (replacing an Ord context)
sortBy          :: (A -> A -> Ordering) -> [A] -> [A]
insertBy        :: (A -> A -> Ordering) -> A -> [A] -> [A]
-}
maximumBy       :: (A -> A -> Ordering) -> UArr A -> A
minimumBy       :: (A -> A -> Ordering) -> UArr A -> A

{-
-- * The \"generic\" operations
genericLength           :: [A] -> I
genericTake             :: I -> [A] -> [A]
genericDrop             :: I -> [A] -> [A]
genericSplitAt          :: I -> [A] -> ([A], [A])
genericIndex            :: [A] -> I -> A
genericReplicate        :: I -> A -> [A]
-}


-- * Basic interface
cons            = List.consU
empty           = List.emptyU
snoc            = List.snocU
singleton       = List.singletonU
head            = List.headU
length          = List.lengthU
append          = List.appendU
tail            = List.tailU
null            = List.nullU
init            = List.initU
last            = List.lastU

-- * List transformations
map             = List.mapU

{-
reverse         = List.reverse
intersperse     = List.intersperse
intercalate     = List.intercalate
transpose       = List.transpose
-}

-- * Reducing lists (folds)
foldl           = List.foldlU
foldl1          = List.foldl1U

{-
foldl'          = List.foldl'
foldl1'         = List.foldl1'
foldr           = List.foldr
foldr1          = List.foldr1
-}

-- ** Special folds
{-
concat          = List.concat
concatMap       = List.concatMap
-}
and             = List.andU
or              = List.orU
any             = List.anyU
all             = List.allU
sum             = List.sumU
product         = List.productU
maximum         = List.maximumU
minimum         = List.minimumU

-- * Building lists
-- ** Scans

scanl           = List.scanlU
{-
scanl1          = List.scanl1
scanr           = List.scanr
scanr1          = List.scanr1

-- ** Accumulating maps
mapAccumL       = List.mapAccumL
mapAccumR       = List.mapAccumR

-- ** Infinite lists
iterate         = List.iterate
repeat          = List.repeat
-}
replicate       = List.replicateU
{-
cycle           = List.cycle

-- ** Unfolding
unfoldr         = List.unfoldr

-}
-- * Sublists
-- ** Extracting sublists
take            = List.takeU
drop            = List.dropU
splitAt         = List.splitAtU
takeWhile       = List.takeWhileU
dropWhile       = List.dropWhileU
{-
span            = List.span
break           = List.break
group           = List.group
inits           = List.inits
tails           = List.tails

-- * Predicates
isPrefixOf      = List.isPrefixOf
isSuffixOf      = List.isSuffixOf
isInfixOf       = List.isInfixOf
-}

-- * Searching lists
-- ** Searching by equality
elem            = List.elemU
notElem         = List.notElemU
lookup          = List.lookupU

-- ** Searching with a predicate
find            = List.findU
filter          = List.filterU
{-
partition       = List.partition
-}

-- * Indexing lists
index           = List.indexU
{-
elemIndex       = List.elemIndex
elemIndices     = List.elemIndices
findIndex       = List.findIndex
findIndices     = List.findIndices
-}

-- * Zipping and unzipping lists
zip             = List.zipU
zip3            = List.zip3U
{-
zip4            = List.zip4
zip5            = List.zip5
zip6            = List.zip6
zip7            = List.zip7
-}
zipWith         = List.zipWithU
zipWith3        = List.zipWith3U
{-
zipWith4        = List.zipWith4
zipWith5        = List.zipWith5
zipWith6        = List.zipWith6
zipWith7        = List.zipWith7
-}
--unzip           = List.unzipU
{-
unzip3          = List.unzip3
unzip4          = List.unzip4
unzip5          = List.unzip5
unzip6          = List.unzip6
unzip7          = List.unzip7
-}

{-
-- * Special lists
-- ** Functions on strings
lines           = List.lines
words           = List.words
unlines         = List.unlines
unwords         = List.unwords

-- ** \"Set\" operations
nub             = List.nub
delete          = List.delete
(\\)            = (List.\\)
union           = List.union
intersect       = List.intersect

-- ** Ordered lists 
sort            = List.sort
insert          = List.insert

-- * Generalized functions
-- ** The \"By\" operations
-- *** User-supplied equality (replacing an Eq context)
nubBy           = List.nubBy
deleteBy        = List.deleteBy
deleteFirstsBy  = List.deleteFirstsBy
unionBy         = List.unionBy
intersectBy     = List.intersectBy
groupBy         = List.groupBy

-- *** User-supplied comparison (replacing an Ord context)
sortBy          = List.sortBy
insertBy        = List.insertBy
-}
maximumBy       = List.maximumByU
minimumBy       = List.minimumByU

{-
-- * The \"generic\" operations
genericLength           = List.genericLength
genericTake             = List.genericTake
genericDrop             = List.genericDrop
genericSplitAt          = List.genericSplitAt
genericIndex            = List.genericIndex
genericReplicate        = List.genericReplicate
-}