uvector-0.1: tests/Properties/Monomorphic/UVector.hs
{-# 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
-}