module Foundation.Collection.Sequential
( Sequential(..)
) where
import Foundation.Internal.Base
import Foundation.Collection.Element
import qualified Foundation.Collection.List as ListExtra
import qualified Data.List
import qualified Foundation.Array.Unboxed as UV
class (IsList c, Item c ~ Element c, Monoid c) => Sequential c where
null :: c -> Bool
take :: Int -> c -> c
take n = fst . splitAt n
revTake :: Int -> c -> c
revTake n = fst . revSplitAt n
drop :: Int -> c -> c
drop n = snd . splitAt n
revDrop :: Int -> c -> c
revDrop n = snd . revSplitAt n
splitAt :: Int -> c -> (c,c)
splitAt n c = (take n c, drop n c)
revSplitAt :: Int -> c -> (c,c)
revSplitAt n c = (revTake n c, revDrop n c)
splitOn :: (Element c -> Bool) -> c -> [c]
break :: (Element c -> Bool) -> c -> (c,c)
break predicate = span (not . predicate)
breakElem :: Eq (Element c) => Element c -> c -> (c,c)
breakElem c = break (== c)
intersperse :: Element c -> c -> c
intercalate :: Monoid (Item c) => Element c -> c -> Element c
intercalate xs xss = mconcatCollection (intersperse xs xss)
span :: (Element c -> Bool) -> c -> (c,c)
span predicate = break (not . predicate)
filter :: (Element c -> Bool) -> c -> c
reverse :: c -> c
uncons :: c -> Maybe (Element c, c)
unsnoc :: c -> Maybe (c, Element c)
snoc :: c -> Element c -> c
cons :: Element c -> c -> c
find :: (Element c -> Bool) -> c -> Maybe (Element c)
sortBy :: (Element c -> Element c -> Ordering) -> c -> c
length :: c -> Int
singleton :: Element c -> c
mconcatCollection :: (Monoid (Item c), Sequential c) => c -> Element c
mconcatCollection c = mconcat (toList c)
instance Sequential [a] where
null = Data.List.null
take = Data.List.take
drop = Data.List.drop
revTake = ListExtra.revTake
revDrop = ListExtra.revDrop
splitAt = Data.List.splitAt
revSplitAt = ListExtra.revSplitAt
splitOn = ListExtra.wordsWhen
break = Data.List.break
intersperse = Data.List.intersperse
span = Data.List.span
filter = Data.List.filter
reverse = Data.List.reverse
uncons = ListExtra.uncons
unsnoc = ListExtra.unsnoc
snoc c e = c `mappend` [e]
cons e c = e : c
find = Data.List.find
sortBy = Data.List.sortBy
length = Data.List.length
singleton = (:[])
instance UV.PrimType ty => Sequential (UV.UArray ty) where
null = UV.null
take = UV.take
revTake = UV.revTake
drop = UV.drop
revDrop = UV.revDrop
splitAt = UV.splitAt
revSplitAt = UV.revSplitAt
splitOn = UV.splitOn
break = UV.break
breakElem = UV.breakElem
intersperse = UV.intersperse
span = UV.span
filter = UV.filter
reverse = UV.reverse
uncons = UV.uncons
unsnoc = UV.unsnoc
snoc = UV.snoc
cons = UV.cons
find = UV.find
sortBy = UV.sortBy
length = UV.length
singleton = fromList . (:[])