0bd94d9 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Remove parselMx'

0bd94d9Harendra Kumar6 years ago

src/Streamly/Internal/Data/Stream/Prelude.hs−14

compare with master

unifiedsplit

@@ -34,7 +34,6 @@ module Streamly.Internal.Data.Stream.Prelude

34 , foldlMx'

35 , foldl'

36 , foldOnce

37− , parselMx'

39 -- Lazy left folds are useful only for reversing the stream

38 -- Lazy left folds are useful only for reversing the stream

40 , foldlS

39 , foldlS

@@ -66,13 +65,11 @@ module Streamly.Internal.Data.Stream.Prelude

66 )

65 )

67where

66where

69−import Control.Monad.Catch (MonadThrow)

70import Control.Monad.Trans.Class (MonadTrans(..))

68import Control.Monad.Trans.Class (MonadTrans(..))

71import Prelude hiding (foldr, minimum, maximum)

69import Prelude hiding (foldr, minimum, maximum)

72import qualified Prelude

70import qualified Prelude

74import Streamly.Internal.Data.Fold.Types (Fold (..))

72import Streamly.Internal.Data.Fold.Types (Fold (..))

75−import Streamly.Internal.Data.Parser (Step)

77#ifdef USE_STREAMK_ONLY

74#ifdef USE_STREAMK_ONLY

78import qualified Streamly.Internal.Data.Stream.StreamK as S

75import qualified Streamly.Internal.Data.Stream.StreamK as S

@@ -158,17 +155,6 @@ foldlMx' :: (IsStream t, Monad m)

158 => (x -> a -> m x) -> m x -> (x -> m b) -> t m a -> m b

155 => (x -> a -> m x) -> m x -> (x -> m b) -> t m a -> m b

159foldlMx' step begin done m = S.foldlMx' step begin done $ toStreamS m

156foldlMx' step begin done m = S.foldlMx' step begin done $ toStreamS m

160

157

161−{-# INLINE parselMx' #-}

162−parselMx'

163− :: (IsStream t, MonadThrow m)

164− => (s -> a -> m (Step s b))

165− -> m s

166− -> (s -> m b)

167− -> t m a

168− -> m b

169−parselMx' step initial extract m =

170− D.parselMx' step initial extract $ D.toStreamD m

171−

172-- | Strict left fold with an extraction function. Like the standard strict

158-- | Strict left fold with an extraction function. Like the standard strict

173-- left fold, but applies a user supplied extraction function (the third

159-- left fold, but applies a user supplied extraction function (the third

174-- argument) to the folded value at the end. This is designed to work with the

160-- argument) to the folded value at the end. This is designed to work with the

src/Streamly/Internal/Data/Stream/StreamD/Eliminate.hs−64

@@ -32,7 +32,6 @@ module Streamly.Internal.Data.Stream.StreamD.Eliminate

32 , foldl'

33 , foldlMx'

34 , foldlx'

35− , parselMx'

37 -- * Specific Fold Functions

36 -- * Specific Fold Functions

38 , drain

37 , drain

@@ -132,68 +131,6 @@ splitAt n ls

132{-# ANN type List NoSpecConstr #-}

131{-# ANN type List NoSpecConstr #-}

133newtype List a = List {getList :: [a]}

132newtype List a = List {getList :: [a]}

134

133

135−-- | Run a 'Parse' over a stream.

136−{-# INLINE_NORMAL parselMx' #-}

137−parselMx'

138− :: MonadThrow m

139− => (s -> a -> m (PR.Step s b))

140− -> m s

141− -> (s -> m b)

142− -> Stream m a

143− -> m b

144−parselMx' pstep initial extract (Stream step state) = do

145− initial >>= go SPEC state (List [])

146−

147− where

148−

149− -- XXX currently we are using a dumb list based approach for backtracking

150− -- buffer. This can be replaced by a sliding/ring buffer using Data.Array.

151− -- That will allow us more efficient random back and forth movement.

152− {-# INLINE go #-}

153− go !_ st buf !pst = do

154− r <- step defState st

155− case r of

156− Yield x s -> do

157− pRes <- pstep pst x

158− case pRes of

159− PR.Partial 0 pst1 -> go SPEC s (List []) pst1

160− PR.Partial n pst1 -> do

161− assert (n <= length (x:getList buf)) (return ())

162− let src0 = Prelude.take n (x:getList buf)

163− src = Prelude.reverse src0

164− gobuf SPEC s (List []) (List src) pst1

165− PR.Continue 0 pst1 -> go SPEC s (List (x:getList buf)) pst1

166− PR.Continue n pst1 -> do

167− assert (n <= length (x:getList buf)) (return ())

168− let (src0, buf1) = splitAt n (x:getList buf)

169− src = Prelude.reverse src0

170− gobuf SPEC s (List buf1) (List src) pst1

171− PR.Done _ b -> return b

172− PR.Error err -> throwM $ ParseError err

173− Skip s -> go SPEC s buf pst

174− Stop -> extract pst

175−

176− gobuf !_ s buf (List []) !pst = go SPEC s buf pst

177− gobuf !_ s buf (List (x:xs)) !pst = do

178− pRes <- pstep pst x

179− case pRes of

180− PR.Partial 0 pst1 ->

181− gobuf SPEC s (List []) (List xs) pst1

182− PR.Partial n pst1 -> do

183− assert (n <= length (x:getList buf)) (return ())

184− let src0 = Prelude.take n (x:getList buf)

185− src = Prelude.reverse src0 ++ xs

186− gobuf SPEC s (List []) (List src) pst1

187− PR.Continue 0 pst1 ->

188− gobuf SPEC s (List (x:getList buf)) (List xs) pst1

189− PR.Continue n pst1 -> do

190− assert (n <= length (x:getList buf)) (return ())

191− let (src0, buf1) = splitAt n (x:getList buf)

192− src = Prelude.reverse src0 ++ xs

193− gobuf SPEC s (List buf1) (List src) pst1

194− PR.Done _ b -> return b

195− PR.Error err -> throwM $ ParseError err

196−

197-- | Run a 'Parse' over a stream.

134-- | Run a 'Parse' over a stream.

198{-# INLINE_NORMAL parse #-}

135{-# INLINE_NORMAL parse #-}

199parse :: MonadThrow m => PRD.Parser m a b -> Stream m a -> m b

136parse :: MonadThrow m => PRD.Parser m a b -> Stream m a -> m b

@@ -228,7 +165,6 @@ parse (PRD.Parser pstep initial extract) (Stream step state) = do

228 let (src0, buf1) = splitAt n (x:getList buf)

165 let (src0, buf1) = splitAt n (x:getList buf)

229 src = Prelude.reverse src0

166 src = Prelude.reverse src0

230 gobuf SPEC s (List buf1) (List src) pst1

167 gobuf SPEC s (List buf1) (List src) pst1

231− -- Specialcase the Done 1 case

232 PR.Done _ b -> return b

168 PR.Done _ b -> return b

233 PR.Error err -> throwM $ ParseError err

169 PR.Error err -> throwM $ ParseError err

234 Skip s -> go SPEC s buf pst

170 Skip s -> go SPEC s buf pst