module Properties.Monomorphic.Spec where

import Properties.Utils

import qualified Spec.List as Spec
import qualified Spec.ListExts as Spec

-- * Basic interface
(++)            :: [A] -> [A] -> [A]
head            :: [A] -> A
last            :: [A] -> A
tail            :: [A] -> [A]
init            :: [A] -> [A]
null            :: [A] -> Bool
length          :: [A] -> Int

-- * List transformations
map             :: (A -> B) -> [A] -> [B]
reverse         :: [A] -> [A]
intersperse     :: A -> [A] -> [A]
intercalate     :: [A] -> [[A]] -> [A]
transpose       :: [[A]] -> [[A]]

-- * Reducing lists (folds)
foldl           :: (B -> A -> B) -> B -> [A] -> B
foldl'          :: (B -> A -> B) -> B -> [A] -> B
foldl1          :: (A -> A -> A) -> [A] -> A
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             :: [Bool] -> Bool
or              :: [Bool] -> Bool
any             :: (A -> Bool) -> [A] -> Bool
all             :: (A -> Bool) -> [A] -> Bool
sum             :: [N] -> N
product         :: [N] -> N
maximum         :: [OrdA] -> OrdA
minimum         :: [OrdA] -> OrdA

-- * Building lists
-- ** Scans
scanl           :: (A -> B -> A) -> A -> [B] -> [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 -> [A] -> (C, [B])
mapAccumR       :: (C -> A -> (C, B)) -> C -> [A] -> (C, [B])

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

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

-- * Sublists
-- ** Extracting sublists
take            :: Int -> [A] -> [A]
drop            :: Int -> [A] -> [A]
splitAt         :: Int -> [A] -> ([A], [A])
takeWhile       :: (A -> Bool) -> [A] -> [A]
dropWhile       :: (A -> Bool) -> [A] -> [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 -> [A] -> Bool
notElem         :: A -> [A] -> Bool
lookup          :: A -> [(A, B)] -> Maybe B

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

-- * Indexing lists
(!!)            :: [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             :: [A] -> [B] -> [(A, B)]
zip3            :: [A] -> [B] -> [C] -> [(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) -> [A] -> [B] -> [C]
zipWith3        :: (A -> B -> C -> D) -> [A] -> [B] -> [C] -> [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) -> [A] -> A
minimumBy       :: (A -> A -> Ordering) -> [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
(++)            = (Spec.++)
head            = Spec.head
last            = Spec.last
tail            = Spec.tail
init            = Spec.init
null            = Spec.null
length          = Spec.length

-- * List transformations
map             = Spec.map
reverse         = Spec.reverse
intersperse     = Spec.intersperse
intercalate     = Spec.intercalate
transpose       = Spec.transpose

-- * Reducing lists (folds)
foldl           = Spec.foldl
foldl'          = Spec.foldl'
foldl1          = Spec.foldl1
foldl1'         = Spec.foldl1'
foldr           = Spec.foldr
foldr1          = Spec.foldr1

-- ** Special folds
concat          = Spec.concat
concatMap       = Spec.concatMap
and             = Spec.and
or              = Spec.or
any             = Spec.any
all             = Spec.all
sum             = Spec.sum
product         = Spec.product
maximum         = Spec.maximum
minimum         = Spec.minimum

-- * Building lists
-- ** Scans
scanl           = Spec.scanl
scanl1          = Spec.scanl1
scanr           = Spec.scanr
scanr1          = Spec.scanr1

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

-- ** Infinite lists
iterate         = Spec.iterate
repeat          = Spec.repeat
replicate       = Spec.replicate
cycle           = Spec.cycle

-- ** Unfolding
unfoldr         = Spec.unfoldr

-- * Sublists
-- ** Extracting sublists
take            = Spec.take
drop            = Spec.drop
splitAt         = Spec.splitAt
takeWhile       = Spec.takeWhile
dropWhile       = Spec.dropWhile
span            = Spec.span
break           = Spec.break
group           = Spec.group
inits           = Spec.inits
tails           = Spec.tails

-- * Predicates
isPrefixOf      = Spec.isPrefixOf
isSuffixOf      = Spec.isSuffixOf
isInfixOf       = Spec.isInfixOf

-- * Searching lists
-- ** Searching by equality
elem            = Spec.elem
notElem         = Spec.notElem
lookup          = Spec.lookup

-- ** Searching with a predicate
find            = Spec.find
filter          = Spec.filter
partition       = Spec.partition

-- * Indexing lists
(!!)            = (Spec.!!)
elemIndex       = Spec.elemIndex
elemIndices     = Spec.elemIndices
findIndex       = Spec.findIndex
findIndices     = Spec.findIndices

-- * Zipping and unzipping lists
zip             = Spec.zip
zip3            = Spec.zip3
zip4            = Spec.zip4
zip5            = Spec.zip5
zip6            = Spec.zip6
zip7            = Spec.zip7
zipWith         = Spec.zipWith
zipWith3        = Spec.zipWith3
zipWith4        = Spec.zipWith4
zipWith5        = Spec.zipWith5
zipWith6        = Spec.zipWith6
zipWith7        = Spec.zipWith7
unzip           = Spec.unzip
unzip3          = Spec.unzip3
unzip4          = Spec.unzip4
unzip5          = Spec.unzip5
unzip6          = Spec.unzip6
unzip7          = Spec.unzip7

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

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

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

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

-- *** User-supplied comparison (replacing an Ord context)
sortBy          = Spec.sortBy
insertBy        = Spec.insertBy
maximumBy       = Spec.maximumBy
minimumBy       = Spec.minimumBy

-- * The \"generic\" operations
genericLength           = Spec.genericLength
genericTake             = Spec.genericTake
genericDrop             = Spec.genericDrop
genericSplitAt          = Spec.genericSplitAt
genericIndex            = Spec.genericIndex
genericReplicate        = Spec.genericReplicate