module Data.Text.Fusion.Common
(
singleton
, streamList
, unstreamList
, cons
, snoc
, append
, head
, uncons
, last
, tail
, init
, null
, lengthI
, map
, intercalate
, intersperse
, foldl
, foldl'
, foldl1
, foldl1'
, foldr
, foldr1
, concat
, concatMap
, any
, all
, maximum
, minimum
, scanl
, mapAccumL
, replicate
, unfoldr
, unfoldrNI
, take
, drop
, takeWhile
, dropWhile
, isPrefixOf
, elem
, filter
, find
, indexI
, findIndexI
, findIndicesI
, elemIndexI
, elemIndicesI
, countI
, zipWith
) where
import Prelude (Bool(..), Char, Either(..), Eq(..), Int, Integral, Maybe(..),
Ord(..), String, (.), ($), (+), (), (*), (++), (&&),
fromIntegral, otherwise)
import qualified Data.List as L
import qualified Prelude as P
import Data.Text.Fusion.Internal
singleton :: Char -> Stream Char
singleton c = Stream next False 1
where next False = Yield c True
next True = Done
streamList :: [a] -> Stream a
streamList [] = empty
streamList s = Stream next s unknownLength
where next [] = Done
next (x:xs) = Yield x xs
unknownLength = 8
unstreamList :: Stream a -> [a]
unstreamList (Stream next s0 _len) = unfold s0
where unfold !s = case next s of
Done -> []
Skip s' -> unfold s'
Yield x s' -> x : unfold s'
cons :: Char -> Stream Char -> Stream Char
cons w (Stream next0 s0 len) = Stream next (S2 :!: s0) (len+2)
where
next (S2 :!: s) = Yield w (S1 :!: s)
next (S1 :!: s) = case next0 s of
Done -> Done
Skip s' -> Skip (S1 :!: s')
Yield x s' -> Yield x (S1 :!: s')
snoc :: Stream Char -> Char -> Stream Char
snoc (Stream next0 xs0 len) w = Stream next (J xs0) (len+2)
where
next (J xs) = case next0 xs of
Done -> Yield w N
Skip xs' -> Skip (J xs')
Yield x xs' -> Yield x (J xs')
next N = Done
append :: Stream Char -> Stream Char -> Stream Char
append (Stream next0 s01 len1) (Stream next1 s02 len2) =
Stream next (Left s01) (len1 + len2)
where
next (Left s1) = case next0 s1 of
Done -> Skip (Right s02)
Skip s1' -> Skip (Left s1')
Yield x s1' -> Yield x (Left s1')
next (Right s2) = case next1 s2 of
Done -> Done
Skip s2' -> Skip (Right s2')
Yield x s2' -> Yield x (Right s2')
head :: Stream Char -> Char
head (Stream next s0 _len) = loop_head s0
where
loop_head !s = case next s of
Yield x _ -> x
Skip s' -> loop_head s'
Done -> streamError "head" "Empty stream"
uncons :: Stream Char -> Maybe (Char, Stream Char)
uncons (Stream next s0 len) = loop_uncons s0
where
loop_uncons !s = case next s of
Yield x s1 -> Just (x, Stream next s1 (len1))
Skip s' -> loop_uncons s'
Done -> Nothing
last :: Stream Char -> Char
last (Stream next s0 _len) = loop0_last s0
where
loop0_last !s = case next s of
Done -> emptyError "last"
Skip s' -> loop0_last s'
Yield x s' -> loop_last x s'
loop_last !x !s = case next s of
Done -> x
Skip s' -> loop_last x s'
Yield x' s' -> loop_last x' s'
tail :: Stream Char -> Stream Char
tail (Stream next0 s0 len) = Stream next (False :!: s0) (len1)
where
next (False :!: s) = case next0 s of
Done -> emptyError "tail"
Skip s' -> Skip (False :!: s')
Yield _ s' -> Skip (True :!: s')
next (True :!: s) = case next0 s of
Done -> Done
Skip s' -> Skip (True :!: s')
Yield x s' -> Yield x (True :!: s')
init :: Stream Char -> Stream Char
init (Stream next0 s0 len) = Stream next (N :!: s0) (len1)
where
next (N :!: s) = case next0 s of
Done -> emptyError "init"
Skip s' -> Skip (N :!: s')
Yield x s' -> Skip (J x :!: s')
next (J x :!: s) = case next0 s of
Done -> Done
Skip s' -> Skip (J x :!: s')
Yield x' s' -> Yield x (J x' :!: s')
null :: Stream Char -> Bool
null (Stream next s0 _len) = loop_null s0
where
loop_null !s = case next s of
Done -> True
Yield _ _ -> False
Skip s' -> loop_null s'
lengthI :: Integral a => Stream Char -> a
lengthI (Stream next s0 _len) = loop_length 0 s0
where
loop_length !z s = case next s of
Done -> z
Skip s' -> loop_length z s'
Yield _ s' -> loop_length (z + 1) s'
map :: (Char -> Char) -> Stream Char -> Stream Char
map f (Stream next0 s0 len) = Stream next s0 len
where
next !s = case next0 s of
Done -> Done
Skip s' -> Skip s'
Yield x s' -> Yield (f x) s'
intersperse :: Char -> Stream Char -> Stream Char
intersperse c (Stream next0 s0 len) = Stream next (s0 :!: N :!: S1) len
where
next (s :!: N :!: S1) = case next0 s of
Done -> Done
Skip s' -> Skip (s' :!: N :!: S1)
Yield x s' -> Skip (s' :!: J x :!: S1)
next (s :!: J x :!: S1) = Yield x (s :!: N :!: S2)
next (s :!: N :!: S2) = case next0 s of
Done -> Done
Skip s' -> Skip (s' :!: N :!: S2)
Yield x s' -> Yield c (s' :!: J x :!: S1)
next _ = internalError "intersperse"
foldl :: (b -> Char -> b) -> b -> Stream Char -> b
foldl f z0 (Stream next s0 _len) = loop_foldl z0 s0
where
loop_foldl z !s = case next s of
Done -> z
Skip s' -> loop_foldl z s'
Yield x s' -> loop_foldl (f z x) s'
foldl' :: (b -> Char -> b) -> b -> Stream Char -> b
foldl' f z0 (Stream next s0 _len) = loop_foldl' z0 s0
where
loop_foldl' !z !s = case next s of
Done -> z
Skip s' -> loop_foldl' z s'
Yield x s' -> loop_foldl' (f z x) s'
foldl1 :: (Char -> Char -> Char) -> Stream Char -> Char
foldl1 f (Stream next s0 _len) = loop0_foldl1 s0
where
loop0_foldl1 !s = case next s of
Skip s' -> loop0_foldl1 s'
Yield x s' -> loop_foldl1 x s'
Done -> emptyError "foldl1"
loop_foldl1 z !s = case next s of
Done -> z
Skip s' -> loop_foldl1 z s'
Yield x s' -> loop_foldl1 (f z x) s'
foldl1' :: (Char -> Char -> Char) -> Stream Char -> Char
foldl1' f (Stream next s0 _len) = loop0_foldl1' s0
where
loop0_foldl1' !s = case next s of
Skip s' -> loop0_foldl1' s'
Yield x s' -> loop_foldl1' x s'
Done -> emptyError "foldl1"
loop_foldl1' !z !s = case next s of
Done -> z
Skip s' -> loop_foldl1' z s'
Yield x s' -> loop_foldl1' (f z x) s'
foldr :: (Char -> b -> b) -> b -> Stream Char -> b
foldr f z (Stream next s0 _len) = loop_foldr s0
where
loop_foldr !s = case next s of
Done -> z
Skip s' -> loop_foldr s'
Yield x s' -> f x (loop_foldr s')
foldr1 :: (Char -> Char -> Char) -> Stream Char -> Char
foldr1 f (Stream next s0 _len) = loop0_foldr1 s0
where
loop0_foldr1 !s = case next s of
Done -> emptyError "foldr1"
Skip s' -> loop0_foldr1 s'
Yield x s' -> loop_foldr1 x s'
loop_foldr1 x !s = case next s of
Done -> x
Skip s' -> loop_foldr1 x s'
Yield x' s' -> f x (loop_foldr1 x' s')
intercalate :: Stream Char -> [Stream Char] -> Stream Char
intercalate s = concat . (L.intersperse s)
concat :: [Stream Char] -> Stream Char
concat = L.foldr append empty
concatMap :: (Char -> Stream Char) -> Stream Char -> Stream Char
concatMap f = foldr (append . f) empty
any :: (Char -> Bool) -> Stream Char -> Bool
any p (Stream next0 s0 _len) = loop_any s0
where
loop_any !s = case next0 s of
Done -> False
Skip s' -> loop_any s'
Yield x s' | p x -> True
| otherwise -> loop_any s'
all :: (Char -> Bool) -> Stream Char -> Bool
all p (Stream next0 s0 _len) = loop_all s0
where
loop_all !s = case next0 s of
Done -> True
Skip s' -> loop_all s'
Yield x s' | p x -> loop_all s'
| otherwise -> False
maximum :: Stream Char -> Char
maximum (Stream next0 s0 _len) = loop0_maximum s0
where
loop0_maximum !s = case next0 s of
Done -> emptyError "maximum"
Skip s' -> loop0_maximum s'
Yield x s' -> loop_maximum x s'
loop_maximum !z !s = case next0 s of
Done -> z
Skip s' -> loop_maximum z s'
Yield x s'
| x > z -> loop_maximum x s'
| otherwise -> loop_maximum z s'
minimum :: Stream Char -> Char
minimum (Stream next0 s0 _len) = loop0_minimum s0
where
loop0_minimum !s = case next0 s of
Done -> emptyError "minimum"
Skip s' -> loop0_minimum s'
Yield x s' -> loop_minimum x s'
loop_minimum !z !s = case next0 s of
Done -> z
Skip s' -> loop_minimum z s'
Yield x s'
| x < z -> loop_minimum x s'
| otherwise -> loop_minimum z s'
scanl :: (Char -> Char -> Char) -> Char -> Stream Char -> Stream Char
scanl f z0 (Stream next0 s0 len) = Stream next (S1 :!: z0 :!: s0) (len+1)
where
next (S1 :!: z :!: s) = Yield z (S2 :!: z :!: s)
next (S2 :!: z :!: s) = case next0 s of
Yield x s' -> let !x' = f z x
in Yield x' (S2 :!: x' :!: s')
Skip s' -> Skip (S2 :!: z :!: s')
Done -> Done
mapAccumL :: (a -> b -> (a,b)) -> a -> Stream b -> Stream b
mapAccumL f z0 (Stream next0 s0 len) = Stream next (s0 :!: z0) len
where
next (s :!: z) = case next0 s of
Yield x s' -> let (z',y) = f z x
in Yield y (s' :!: z')
Skip s' -> Skip (s' :!: z)
Done -> Done
replicate :: Int -> Char -> Stream Char
replicate n c
| n < 0 = empty
| otherwise = Stream next 0 n
where
next i | i >= n = Done
| otherwise = Yield c (i + 1)
unfoldr :: (a -> Maybe (Char,a)) -> a -> Stream Char
unfoldr f s0 = Stream next s0 1
where
next !s = case f s of
Nothing -> Done
Just (w, s') -> Yield w s'
unfoldrNI :: Integral a => a -> (b -> Maybe (Char,b)) -> b -> Stream Char
unfoldrNI n f s0 | n < 0 = empty
| otherwise = Stream next (0 :!: s0) (fromIntegral (n*2))
where
next (z :!: s) = case f s of
Nothing -> Done
Just (w, s') | z >= n -> Done
| otherwise -> Yield w ((z + 1) :!: s')
take :: Integral a => a -> Stream Char -> Stream Char
take n0 (Stream next0 s0 len) = Stream next (n0 :!: s0) (min 0 (len fromIntegral n0))
where
next (n :!: s) | n <= 0 = Done
| otherwise = case next0 s of
Done -> Done
Skip s' -> Skip (n :!: s')
Yield x s' -> Yield x ((n1) :!: s')
drop :: Integral a => a -> Stream Char -> Stream Char
drop n0 (Stream next0 s0 len) =
Stream next (J (max 0 n0) :!: s0) (len fromIntegral n0)
where
next (J n :!: s)
| n == 0 = Skip (N :!: s)
| otherwise = case next0 s of
Done -> Done
Skip s' -> Skip (J n :!: s')
Yield _ s' -> Skip (J (n1) :!: s')
next (N :!: s) = case next0 s of
Done -> Done
Skip s' -> Skip (N :!: s')
Yield x s' -> Yield x (N :!: s')
takeWhile :: (Char -> Bool) -> Stream Char -> Stream Char
takeWhile p (Stream next0 s0 len) = Stream next s0 len
where
next !s = case next0 s of
Done -> Done
Skip s' -> Skip s'
Yield x s' | p x -> Yield x s'
| otherwise -> Done
dropWhile :: (Char -> Bool) -> Stream Char -> Stream Char
dropWhile p (Stream next0 s0 len) = Stream next (S1 :!: s0) len
where
next (S1 :!: s) = case next0 s of
Done -> Done
Skip s' -> Skip (S1 :!: s')
Yield x s' | p x -> Skip (S1 :!: s')
| otherwise -> Yield x (S2 :!: s')
next (S2 :!: s) = case next0 s of
Done -> Done
Skip s' -> Skip (S2 :!: s')
Yield x s' -> Yield x (S2 :!: s')
isPrefixOf :: (Eq a) => Stream a -> Stream a -> Bool
isPrefixOf (Stream next1 s1 _) (Stream next2 s2 _) = loop (next1 s1) (next2 s2)
where
loop Done _ = True
loop _ Done = False
loop (Skip s1') (Skip s2') = loop (next1 s1') (next2 s2')
loop (Skip s1') x2 = loop (next1 s1') x2
loop x1 (Skip s2') = loop x1 (next2 s2')
loop (Yield x1 s1') (Yield x2 s2') = x1 == x2 &&
loop (next1 s1') (next2 s2')
elem :: Char -> Stream Char -> Bool
elem w (Stream next s0 _len) = loop_elem s0
where
loop_elem !s = case next s of
Done -> False
Skip s' -> loop_elem s'
Yield x s' | x == w -> True
| otherwise -> loop_elem s'
find :: (Char -> Bool) -> Stream Char -> Maybe Char
find p (Stream next s0 _len) = loop_find s0
where
loop_find !s = case next s of
Done -> Nothing
Skip s' -> loop_find s'
Yield x s' | p x -> Just x
| otherwise -> loop_find s'
indexI :: Integral a => Stream Char -> a -> Char
indexI (Stream next s0 _len) n0
| n0 < 0 = streamError "index" "Negative index"
| otherwise = loop_index n0 s0
where
loop_index !n !s = case next s of
Done -> streamError "index" "Index too large"
Skip s' -> loop_index n s'
Yield x s' | n == 0 -> x
| otherwise -> loop_index (n1) s'
filter :: (Char -> Bool) -> Stream Char -> Stream Char
filter p (Stream next0 s0 len) = Stream next s0 len
where
next !s = case next0 s of
Done -> Done
Skip s' -> Skip s'
Yield x s' | p x -> Yield x s'
| otherwise -> Skip s'
findIndexI :: Integral a => (Char -> Bool) -> Stream Char -> Maybe a
findIndexI p s = case findIndicesI p s of
(i:_) -> Just i
_ -> Nothing
findIndicesI :: Integral a => (Char -> Bool) -> Stream Char -> [a]
findIndicesI p (Stream next s0 _len) = loop_findIndex 0 s0
where
loop_findIndex !i !s = case next s of
Done -> []
Skip s' -> loop_findIndex i s'
Yield x s' | p x -> i : loop_findIndex (i+1) s'
| otherwise -> loop_findIndex (i+1) s'
zipWith :: (a -> a -> b) -> Stream a -> Stream a -> Stream b
zipWith f (Stream next0 sa0 len1) (Stream next1 sb0 len2) = Stream next (sa0 :!: sb0 :!: N) (min len1 len2)
where
next (sa :!: sb :!: N) = case next0 sa of
Done -> Done
Skip sa' -> Skip (sa' :!: sb :!: N)
Yield a sa' -> Skip (sa' :!: sb :!: J a)
next (sa' :!: sb :!: J a) = case next1 sb of
Done -> Done
Skip sb' -> Skip (sa' :!: sb' :!: J a)
Yield b sb' -> Yield (f a b) (sa' :!: sb' :!: N)
elemIndexI :: Integral a => Char -> Stream Char -> Maybe a
elemIndexI a s = case elemIndicesI a s of
(i:_) -> Just i
_ -> Nothing
elemIndicesI :: Integral a => Char -> Stream Char -> [a]
elemIndicesI a (Stream next s0 _len) = loop 0 s0
where
loop !i !s = case next s of
Done -> []
Skip s' -> loop i s'
Yield x s' | a == x -> i : loop (i+1) s'
| otherwise -> loop (i+1) s'
countI :: Integral a => Char -> Stream Char -> a
countI a (Stream next s0 _len) = loop 0 s0
where
loop !i !s = case next s of
Done -> i
Skip s' -> loop i s'
Yield x s' | a == x -> loop (i+1) s'
| otherwise -> loop i s'
streamError :: String -> String -> a
streamError func msg = P.error $ "Data.Text.Fusion.Common." ++ func ++ ": " ++ msg
emptyError :: String -> a
emptyError func = internalError func "Empty input"
internalError :: String -> a
internalError func = streamError func "Internal error"