9bd9756 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Implement parse in terms of parse_.

9bd9756Pranay Sashank6 years ago

src/Streamly/Internal/Data/Stream/IsStream/Common.hs−1

compare with master

unifiedsplit

@@ -62,7 +62,6 @@ import Streamly.Internal.Data.SVar (MonadAsync)

62import Streamly.Internal.Data.Time.Units (AbsTime, RelTime64, addToAbsTime64)

64import qualified Streamly.Internal.Data.Stream.Parallel as Par

65−import qualified Streamly.Internal.Data.Stream.Prelude as P

66import qualified Streamly.Internal.Data.Stream.Serial as Serial

65import qualified Streamly.Internal.Data.Stream.Serial as Serial

67import qualified Streamly.Internal.Data.Stream.StreamK as K (repeatM)

66import qualified Streamly.Internal.Data.Stream.StreamK as K (repeatM)

68import qualified Streamly.Internal.Data.Stream.StreamK.Type as K

67import qualified Streamly.Internal.Data.Stream.StreamK.Type as K

src/Streamly/Internal/Data/Stream/IsStream/Eliminate.hs+16

@@ -27,6 +27,8 @@ module Streamly.Internal.Data.Stream.IsStream.Eliminate

27 , parse

28 , parseK

29 , parseD

30+ , parse_

31+ , parseD_

31 -- * Stream Deconstruction

33 -- * Stream Deconstruction

32 -- | foldr and foldl do not provide the remaining stream. 'uncons' is more

34 -- | foldr and foldl do not provide the remaining stream. 'uncons' is more

@@ -371,6 +373,20 @@ parseK = parse

371parse :: MonadThrow m => Parser m a b -> SerialT m a -> m b

373parse :: MonadThrow m => Parser m a b -> SerialT m a -> m b

372parse = parseD . PRK.fromParserK

374parse = parseD . PRK.fromParserK

373

375

376+{-# INLINE_NORMAL parseD_ #-}

377+parseD_ :: MonadThrow m => PRD.Parser m a b -> SerialT m a -> m (b, SerialT m a)

378+parseD_ parser strm = do

379+ (b, strmD) <- D.parse_ parser (toStreamD strm)

380+ return $! (b, fromStreamD strmD)

381+

382+-- | Parse a stream using the supplied 'Parser'.

383+--

384+-- /Internal/

385+--

386+{-# INLINE [3] parse_ #-}

387+parse_ :: MonadThrow m => Parser m a b -> SerialT m a -> m (b, SerialT m a)

388+parse_ = parseD_ . PRK.fromParserK

389+

374------------------------------------------------------------------------------

390------------------------------------------------------------------------------

375-- Specific Fold Functions

391-- Specific Fold Functions

376------------------------------------------------------------------------------

392------------------------------------------------------------------------------

src/Streamly/Internal/Data/Stream/StreamD/Eliminate.hs+35−6

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

18 -- -- * Running a 'Parser'

19 , parse

20+ , parse_

21 -- * Stream Deconstruction

22 -- * Stream Deconstruction

22 , uncons

23 , uncons

@@ -133,12 +134,27 @@ newtype List a = List {getList :: [a]}

133

134

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

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

135{-# INLINE_NORMAL parse #-}

136{-# INLINE_NORMAL parse #-}

137+parse

138+ :: MonadThrow m

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

139+ => PRD.Parser m a b

140+ -> Stream m a

141+ -> m b

142+parse parser strm = do

143+ (b, _) <- parse_ parser strm

144+ return b

145+

146+-- | Run a 'Parse' over a stream and return rest of the Stream.

147+{-# INLINE_NORMAL parse_ #-}

148+parse_

149+ :: MonadThrow m

150+ => PRD.Parser m a b

151+ -> Stream m a

152+ -> m (b, Stream m a)

137−parse (PRD.Parser pstep initial extract) (Stream step state) = do

153+parse_ (PRD.Parser pstep initial extract) (Stream step state) = do

138 res <- initial

154 res <- initial

139 case res of

155 case res of

140 PRD.IPartial s -> go SPEC state (List []) s

156 PRD.IPartial s -> go SPEC state (List []) s

141− PRD.IDone b -> return b

157+ PRD.IDone b -> return (b, Stream (\_ _ -> return Stop) ())

142 PRD.IError err -> throwM $ ParseError err

158 PRD.IError err -> throwM $ ParseError err

143

159

144 where

160 where

@@ -165,10 +181,12 @@ parse (PRD.Parser pstep initial extract) (Stream step state) = do

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

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

166 src = Prelude.reverse src0

182 src = Prelude.reverse src0

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

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

168− PR.Done _ b -> return b

184+ PR.Done _ b -> return (b, Stream step_rest (Left (s, buf)))

169 PR.Error err -> throwM $ ParseError err

185 PR.Error err -> throwM $ ParseError err

170 Skip s -> go SPEC s buf pst

186 Skip s -> go SPEC s buf pst

187+ Stop -> do

171− Stop -> extract pst

188+ b <- extract pst

189+ return (b, let List buffer = buf in fromList buffer)

172

190

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

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

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

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

@@ -188,9 +206,20 @@ parse (PRD.Parser pstep initial extract) (Stream step state) = do

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

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

189 src = Prelude.reverse src0 ++ xs

207 src = Prelude.reverse src0 ++ xs

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

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

191− PR.Done _ b -> return b

209+ PR.Done _ b -> return (b, Stream step_rest (Left (s, buf)))

192 PR.Error err -> throwM $ ParseError err

210 PR.Error err -> throwM $ ParseError err

193

211

212+ {-# INLINE_LATE step_rest #-}

213+ step_rest _ (Left (st, List [])) = return $ Skip (Right st)

214+ step_rest _ (Left (st, List (x:[]))) = return $ Yield x (Right st)

215+ step_rest _ (Left (st, List (x:xs))) = return $ Yield x (Left (st, List xs))

216+ step_rest gst (Right st) = do

217+ r <- step gst st

218+ return $ case r of

219+ Yield x s -> Yield x (Right s)

220+ Skip s -> Skip (Right s)

221+ Stop -> Stop

222+

194------------------------------------------------------------------------------

223------------------------------------------------------------------------------

195-- Specialized Folds

224-- Specialized Folds

196------------------------------------------------------------------------------

225------------------------------------------------------------------------------