2f9709b · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Implement satisfy and maybe in terms of either

2f9709bHarendra Kumar4 years ago

core/src/Streamly/Internal/Data/Parser.hs+9

compare with master

unifiedsplit

@@ -255,6 +255,7 @@ import qualified Streamly.Internal.Data.Parser.ParserK.Type as K

255-- >>> import Prelude hiding (any, all, dropWhile, take, takeWhile, sequence, concatMap, maybe, either, filter)

256-- >>> import Control.Applicative ((<|>))

257-- >>> import Data.Char (isSpace)

258+-- >>> import qualified Data.Maybe as Maybe

258-- >>> import qualified Streamly.Prelude as Stream

259-- >>> import qualified Streamly.Prelude as Stream

259-- >>> import qualified Streamly.Internal.Data.Stream.IsStream as Stream (parse, parseMany)

260-- >>> import qualified Streamly.Internal.Data.Stream.IsStream as Stream (parse, parseMany)

260-- >>> import qualified Streamly.Internal.Data.Fold as Fold

261-- >>> import qualified Streamly.Internal.Data.Fold as Fold

@@ -409,12 +410,17 @@ eof = D.toParserK D.eof

409-- >>> Stream.parse (Parser.satisfy (== 1)) $ Stream.fromList [1,0,1]

410-- >>> Stream.parse (Parser.satisfy (== 1)) $ Stream.fromList [1,0,1]

410-- 1

411-- 1

411--

412--

413+-- >>> toMaybe f x = if f x then Just x else Nothing

414+-- >>> satisfy f = Parser.maybe (toMaybe f)

415+--

412-- /Pre-release/

416-- /Pre-release/

413--

417--

414{-# INLINE satisfy #-}

418{-# INLINE satisfy #-}

415satisfy :: MonadCatch m => (a -> Bool) -> Parser m a a

419satisfy :: MonadCatch m => (a -> Bool) -> Parser m a a

416satisfy = D.toParserK . D.satisfy

420satisfy = D.toParserK . D.satisfy

417

421

422+-- XXX Change this to "next".

423+--

418-- | Consume one element from the head of the stream. Fails if it encounters

424-- | Consume one element from the head of the stream. Fails if it encounters

419-- end of input.

425-- end of input.

420--

426--

@@ -487,6 +493,9 @@ next = D.toParserK D.next

487-- parser fails if the function returns 'Nothing' otherwise returns the 'Just'

493-- parser fails if the function returns 'Nothing' otherwise returns the 'Just'

488-- value.

494-- value.

489--

495--

496+-- >>> toEither = Maybe.maybe (Left "maybe: predicate failed") Right

497+-- >>> maybe f = Parser.either (toEither . f)

498+--

490-- /Pre-release/

499-- /Pre-release/

491--

500--

492{-# INLINE maybe #-}

501{-# INLINE maybe #-}

core/src/Streamly/Internal/Data/Parser/ParserD.hs+36−27

@@ -221,6 +221,7 @@ import Streamly.Internal.Data.Parser.ParserD.Type

221-- >>> :m

222-- >>> :set -package streamly

223-- >>> import Prelude hiding ()

224+-- >>> import qualified Data.Maybe as Maybe

224-- >>> import qualified Streamly.Prelude as Stream

225-- >>> import qualified Streamly.Prelude as Stream

225-- >>> import qualified Streamly.Internal.Data.Stream.IsStream as Stream

226-- >>> import qualified Streamly.Internal.Data.Stream.IsStream as Stream

226-- >>> import qualified Streamly.Data.Fold as Fold

227-- >>> import qualified Streamly.Data.Fold as Fold

@@ -330,25 +331,6 @@ eof = Parser step initial return

330

331

331 step () _ = return $ Error "eof: not at end of input"

332 step () _ = return $ Error "eof: not at end of input"

332

333

333−-- | See 'Streamly.Internal.Data.Parser.satisfy'.

334−--

335−-- /Pre-release/

336−--

337−{-# INLINE satisfy #-}

338−satisfy :: MonadThrow m => (a -> Bool) -> Parser m a a

339−satisfy predicate = Parser step initial extract

340−

341− where

342−

343− initial = return $ IPartial ()

344−

345− step () a = return $

346− if predicate a

347− then Done 0 a

348− else Error "satisfy: predicate failed"

349−

350− extract _ = throwM $ ParseError "satisfy: end of input"

351−

352-- | See 'Streamly.Internal.Data.Parser.next'.

334-- | See 'Streamly.Internal.Data.Parser.next'.

353--

335--

354-- /Pre-release/

336-- /Pre-release/

@@ -361,12 +343,35 @@ next = Parser step initial extract

361 step _ a = pure $ Done 0 (Just a)

343 step _ a = pure $ Done 0 (Just a)

362 extract _ = pure Nothing

344 extract _ = pure Nothing

363

345

346+-- | See 'Streamly.Internal.Data.Parser.either'.

347+--

348+-- /Pre-release/

349+--

350+{-# INLINE either #-}

351+either :: MonadThrow m => (a -> Either String b) -> Parser m a b

352+either f = Parser step initial extract

353+

354+ where

355+

356+ initial = return $ IPartial ()

357+

358+ step () a = return $

359+ case f a of

360+ Right b -> Done 0 b

361+ Left err -> Error err

362+

363+ extract _ = throwM $ ParseError "end of input"

364+

364-- | See 'Streamly.Internal.Data.Parser.maybe'.

365-- | See 'Streamly.Internal.Data.Parser.maybe'.

365--

366--

367+-- >>> toEither = Maybe.maybe (Left "maybe: predicate failed") Right

368+-- >>> maybe f = Parser.either (toEither . f)

369+--

366-- /Pre-release/

370-- /Pre-release/

367--

371--

368{-# INLINE maybe #-}

372{-# INLINE maybe #-}

369maybe :: MonadThrow m => (a -> Maybe b) -> Parser m a b

373maybe :: MonadThrow m => (a -> Maybe b) -> Parser m a b

374+-- maybe f = either (Maybe.maybe (Left "maybe: predicate failed") Right . f)

370maybe parserF = Parser step initial extract

375maybe parserF = Parser step initial extract

371

376

372 where

377 where

@@ -380,24 +385,28 @@ maybe parserF = Parser step initial extract

380

385

381 extract _ = throwM $ ParseError "maybe: end of input"

386 extract _ = throwM $ ParseError "maybe: end of input"

382

387

383−-- | See 'Streamly.Internal.Data.Parser.either'.

388+-- | See 'Streamly.Internal.Data.Parser.satisfy'.

389+--

390+-- >>> toMaybe f x = if f x then Just x else Nothing

391+-- >>> satisfy f = Parser.maybe (toMaybe f)

384--

392--

385-- /Pre-release/

393-- /Pre-release/

386--

394--

387−{-# INLINE either #-}

395+{-# INLINE satisfy #-}

388−either :: MonadThrow m => (a -> Either String b) -> Parser m a b

396+satisfy :: MonadThrow m => (a -> Bool) -> Parser m a a

397+-- satisfy predicate = maybe (\a -> if predicate a then Just a else Nothing)

389−either parserF = Parser step initial extract

398+satisfy predicate = Parser step initial extract

390

399

391 where

400 where

392

401

393 initial = return $ IPartial ()

402 initial = return $ IPartial ()

394

403

395 step () a = return $

404 step () a = return $

396− case parserF a of

405+ if predicate a

397− Right b -> Done 0 b

406+ then Done 0 a

398− Left err -> Error $ "either: " ++ err

407+ else Error "satisfy: predicate failed"

399

408

400− extract _ = throwM $ ParseError "either: end of input"

409+ extract _ = throwM $ ParseError "satisfy: end of input"

401

410

402-------------------------------------------------------------------------------

411-------------------------------------------------------------------------------

403-- Taking elements

412-- Taking elements