95bd6c5 · streamly · git.iko.soy

2522

2523data DeintercalateState fs sp ss =

2524 DeintercalateL !fs !sp

2525− | DeintercalateR !fs !ss !Bool

2525+ | DeintercalateR !fs !ss

2526

2527-- XXX rename this to intercalate

2528

2530-- considered an interleaving of two patterns. The two parsers represent the

2531-- two patterns.

2532--

2533+-- >>> p1 = Parser.takeWhile1 (not . (== '+')) Fold.toList

2534+-- >>> p2 = Parser.satisfy (== '+')

2535+-- >>> p = Parser.deintercalate p1 p2 Fold.toList

2536+-- >>> Stream.parse p $ Stream.fromList "1+2+3"

2537+-- Right [Left "1",Right '+',Left "2",Right '+',Left "3"]

2538+--

2533{-# INLINE deintercalate #-}

2539{-# INLINE deintercalate #-}

2534deintercalate :: Monad m =>

2540deintercalate :: Monad m =>

2535 Parser a m x

2541 Parser a m x

2553 FL.Partial fs -> do

2559 FL.Partial fs -> do

2554 resL <- initialL

2560 resL <- initialL

2555 case resL of

2561 case resL of

2556− IPartial sL -> return $ IPartial $ DeintercalateL fs sL

2562+ IPartial sL -> return $ IPartial $ (DeintercalateL fs sL)

2557 IDone _ -> errMsg "left" "succeed"

2563 IDone _ -> errMsg "left" "succeed"

2558 IError _ -> errMsg "left" "fail"

2564 IError _ -> errMsg "left" "fail"

2559 FL.Done c -> return $ IDone c

2565 FL.Done c -> return $ IDone c

2560

2566

2567+ {-# INLINE process #-}

2568+ process foldAction initAction pid n nextState = do

2569+ fres <- foldAction

2570+ case fres of

2571+ FL.Partial fs1 -> do

2572+ res <- initAction

2573+ case res of

2574+ IPartial ps ->

2575+ return $ Partial n (nextState fs1 ps)

2576+ IDone _ -> errMsg pid "succeed"

2577+ IError _ -> errMsg pid "fail"

2578+ FL.Done c -> return $ Done n c

2579+

2561 step (DeintercalateL fs sL) a = do

2580 step (DeintercalateL fs sL) a = do

2562 r <- stepL sL a

2581 r <- stepL sL a

2563 case r of

2582 case r of

2564 Partial n s -> return $ Partial n (DeintercalateL fs s)

2583 Partial n s -> return $ Partial n (DeintercalateL fs s)

2565 Continue n s -> return $ Continue n (DeintercalateL fs s)

2584 Continue n s -> return $ Continue n (DeintercalateL fs s)

2566− Done n b -> do

2585+ Done n b ->

2567− fres <- fstep fs (Left b)

2586+ process (fstep fs (Left b)) initialR "right" n DeintercalateR

2568− case fres of

2569− FL.Partial fs1 -> do

2570− resR <- initialR

2571− case resR of

2572− IPartial sR ->

2573− return

2574− $ Partial n (DeintercalateR fs1 sR False)

2575− IDone _ -> errMsg "right" "succeed"

2576− IError _ -> errMsg "right" "fail"

2577− FL.Done c -> return $ Done n c

2578 Error err -> return $ Error err

2587 Error err -> return $ Error err

2579− step (DeintercalateR fs sR consumed) a = do

2588+ step (DeintercalateR fs sR) a = do

2580 r <- stepR sR a

2589 r <- stepR sR a

2581 case r of

2590 case r of

2582− Partial n s -> return $ Partial n (DeintercalateR fs s True)

2591+ Partial n s -> return $ Partial n (DeintercalateR fs s)

2583− Continue n s -> return $ Continue n (DeintercalateR fs s True)

2592+ Continue n s -> return $ Continue n (DeintercalateR fs s)

2584 Done n b ->

2593 Done n b ->

2585− if consumed

2586− then do

2587− fres <- fstep fs (Right b)

2594+ process (fstep fs (Right b)) initialL "left" n DeintercalateL

2588− case fres of

2589− FL.Partial fs1 -> do

2590− resL <- initialL

2591− case resL of

2592− IPartial sL ->

2593− return $ Partial n $ DeintercalateL fs1 sL

2594− IDone _ -> errMsg "left" "succeed"

2595− IError _ -> errMsg "left" "fail"

2596− FL.Done c -> return $ Done n c

2597− else error "deintercalate: infinite loop"

2598 Error err -> return $ Error err

2595 Error err -> return $ Error err

2599

2596

2600− {-# INLINE processResult #-}

2597+ {-# INLINE extractResult #-}

2601− processResult n fs r = do

2598+ extractResult n fs r = do

2602 res <- fstep fs r

2599 res <- fstep fs r

2603 case res of

2600 case res of

2604 FL.Partial fs1 -> fmap (Done n) $ fextract fs1

2601 FL.Partial fs1 -> fmap (Done n) $ fextract fs1

2607 extract (DeintercalateL fs sL) = do

2604 extract (DeintercalateL fs sL) = do

2608 r <- extractL sL

2605 r <- extractL sL

2609 case r of

2606 case r of

2610− Done n b -> processResult n fs (Left b)

2607+ Done n b -> extractResult n fs (Left b)

2611 Error err -> return $ Error err

2608 Error err -> return $ Error err

2612 Continue n s -> return $ Continue n (DeintercalateL fs s)

2609 Continue n s -> return $ Continue n (DeintercalateL fs s)

2613 Partial _ _ -> error "Partial in extract"

2610 Partial _ _ -> error "Partial in extract"

2614

2611

2615− extract (DeintercalateR fs sR consumed) = do

2612+ extract (DeintercalateR fs sR) = do

2616 r <- extractR sR

2613 r <- extractR sR

2617 case r of

2614 case r of

2618− Done n b -> processResult n fs (Right b)

2615+ Done n b -> extractResult n fs (Right b)

2619 Error err -> return $ Error err

2616 Error err -> return $ Error err

2620− -- XXX Review consumed

2621− Continue n s -> return $ Continue n (DeintercalateR fs s consumed)

2617+ Continue n s -> return $ Continue n (DeintercalateR fs s)

2622 Partial _ _ -> error "Partial in extract"

2618 Partial _ _ -> error "Partial in extract"

2623

2619

2624data SepByState fs sp ss =

2620data SepByState fs sp ss =