From 7d9256e283113f1169dd30cc50257fca103d273c Mon Sep 17 00:00:00 2001 From: Pranay Sashank Date: Sat, 29 May 2021 23:28:54 +0530 Subject: [PATCH] Rename Parser.yield, yieldM to fromPure, fromEffect. --- README.md | 2 +- .../Data/Array/Stream/Fold/Foreign.hs | 4 +-- src/Streamly/Internal/Data/Binary/Decode.hs | 2 +- src/Streamly/Internal/Data/Parser.hs | 24 +++++++------- src/Streamly/Internal/Data/Parser/ParserD.hs | 4 +-- .../Internal/Data/Parser/ParserD/Type.hs | 22 ++++++------- .../Internal/Data/Parser/ParserK/Type.hs | 22 ++++++------- .../Internal/FileSystem/Event/Linux.hs | 6 ++-- test/Streamly/Test/Data/Parser.hs | 28 ++++++++-------- test/Streamly/Test/Data/Parser/ParserD.hs | 32 +++++++++---------- 10 files changed, 73 insertions(+), 73 deletions(-) diff --git a/README.md b/README.md index 4daa7e677..a77188bab 100644 --- a/README.md +++ b/README.md @@ -388,7 +388,7 @@ listDir dir = main :: IO () main = do hSetBuffering stdout LineBuffering - let start = Stream.yield (Left ".") + let start = Stream.fromPure (Left ".") Stream.iterateMapLeftsWith Stream.ahead listDir start & Stream.mapM_ print ``` diff --git a/src/Streamly/Internal/Data/Array/Stream/Fold/Foreign.hs b/src/Streamly/Internal/Data/Array/Stream/Fold/Foreign.hs index 0ddf0c5f2..b62a095ed 100644 --- a/src/Streamly/Internal/Data/Array/Stream/Fold/Foreign.hs +++ b/src/Streamly/Internal/Data/Array/Stream/Fold/Foreign.hs @@ -206,7 +206,7 @@ rmapM f (Fold p) = Fold $ ParserD.rmapM f p -- {-# INLINE fromPure #-} fromPure :: Monad m => b -> Fold m a b -fromPure = Fold . ParserD.yield +fromPure = Fold . ParserD.fromPure -- | A fold that always yields the result of an effectful action without -- consuming any input. @@ -215,7 +215,7 @@ fromPure = Fold . ParserD.yield -- {-# INLINE fromEffect #-} fromEffect :: Monad m => m b -> Fold m a b -fromEffect = Fold . ParserD.yieldM +fromEffect = Fold . ParserD.fromEffect -- | Applies two folds sequentially on the input stream and combines their -- results using the supplied function. diff --git a/src/Streamly/Internal/Data/Binary/Decode.hs b/src/Streamly/Internal/Data/Binary/Decode.hs index 35f94c2fc..acbb85141 100644 --- a/src/Streamly/Internal/Data/Binary/Decode.hs +++ b/src/Streamly/Internal/Data/Binary/Decode.hs @@ -47,7 +47,7 @@ import qualified Streamly.Internal.Data.Parser.ParserK.Type as PRK -- {-# INLINE unit #-} unit :: MonadCatch m => Parser m Word8 () -unit = eqWord8 0 *> PR.yield () +unit = eqWord8 0 *> PR.fromPure () {-# INLINE word8ToBool #-} word8ToBool :: Word8 -> Either String Bool diff --git a/src/Streamly/Internal/Data/Parser.hs b/src/Streamly/Internal/Data/Parser.hs index 5538c56ff..bcd77b40a 100644 --- a/src/Streamly/Internal/Data/Parser.hs +++ b/src/Streamly/Internal/Data/Parser.hs @@ -54,8 +54,8 @@ module Streamly.Internal.Data.Parser -- First order parsers -- * Accumulators , fromFold - , yield - , yieldM + , fromPure + , fromEffect , die , dieM @@ -231,28 +231,28 @@ fromFold = K.toParserK . D.fromFold -- Terminating but not failing folds ------------------------------------------------------------------------------- -- --- This is the dual of stream "yield". +-- This is the dual of stream "fromPure". -- -- | A parser that always yields a pure value without consuming any input. -- -- /Pre-release/ -- -{-# INLINE [3] yield #-} -yield :: MonadCatch m => b -> Parser m a b -yield = K.toParserK . D.yield -{-# RULES "yield fallback to CPS" [2] - forall a. K.toParserK (D.yield a) = K.yield a #-} +{-# INLINE [3] fromPure #-} +fromPure :: MonadCatch m => b -> Parser m a b +fromPure = K.toParserK . D.fromPure +{-# RULES "fromPure fallback to CPS" [2] + forall a. K.toParserK (D.fromPure a) = K.fromPure a #-} --- This is the dual of stream "yieldM". +-- This is the dual of stream "fromEffect". -- -- | A parser that always yields the result of an effectful action without -- consuming any input. -- -- /Pre-release/ -- -{-# INLINE yieldM #-} -yieldM :: MonadCatch m => m b -> Parser m a b -yieldM = K.yieldM -- K.toParserK . D.yieldM +{-# INLINE fromEffect #-} +fromEffect :: MonadCatch m => m b -> Parser m a b +fromEffect = K.fromEffect -- K.toParserK . D.fromEffect -- This is the dual of "nil". -- diff --git a/src/Streamly/Internal/Data/Parser/ParserD.hs b/src/Streamly/Internal/Data/Parser/ParserD.hs index d6b535951..1f6452753 100644 --- a/src/Streamly/Internal/Data/Parser/ParserD.hs +++ b/src/Streamly/Internal/Data/Parser/ParserD.hs @@ -21,8 +21,8 @@ module Streamly.Internal.Data.Parser.ParserD -- First order parsers -- * Accumulators , fromFold - , yield - , yieldM + , fromPure + , fromEffect , die , dieM diff --git a/src/Streamly/Internal/Data/Parser/ParserD/Type.hs b/src/Streamly/Internal/Data/Parser/ParserD/Type.hs index a2dd2d9f9..39330933e 100644 --- a/src/Streamly/Internal/Data/Parser/ParserD/Type.hs +++ b/src/Streamly/Internal/Data/Parser/ParserD/Type.hs @@ -117,8 +117,8 @@ module Streamly.Internal.Data.Parser.ParserD.Type , ParseError (..) , rmapM - , yield - , yieldM + , fromPure + , fromEffect , serialWith , split_ @@ -339,21 +339,21 @@ rmapM f (Parser step initial extract) = Parser step1 initial1 (extract >=> f) IError err -> return $ IError err step1 s a = step s a >>= mapMStep f --- | See 'Streamly.Internal.Data.Parser.yield'. +-- | See 'Streamly.Internal.Data.Parser.fromPure'. -- -- /Pre-release/ -- -{-# INLINE_NORMAL yield #-} -yield :: Monad m => b -> Parser m a b -yield b = Parser undefined (pure $ IDone b) undefined +{-# INLINE_NORMAL fromPure #-} +fromPure :: Monad m => b -> Parser m a b +fromPure b = Parser undefined (pure $ IDone b) undefined --- | See 'Streamly.Internal.Data.Parser.yieldM'. +-- | See 'Streamly.Internal.Data.Parser.fromEffect'. -- -- /Pre-release/ -- -{-# INLINE yieldM #-} -yieldM :: Monad m => m b -> Parser m a b -yieldM b = Parser undefined (IDone <$> b) undefined +{-# INLINE fromEffect #-} +fromEffect :: Monad m => m b -> Parser m a b +fromEffect b = Parser undefined (IDone <$> b) undefined ------------------------------------------------------------------------------- -- Sequential applicative @@ -608,7 +608,7 @@ noErrorUnsafeSplit_ (Parser stepL initialL extractL) (Parser stepR initialR extr -- | 'Applicative' form of 'serialWith'. instance MonadThrow m => Applicative (Parser m a) where {-# INLINE pure #-} - pure = yield + pure = fromPure {-# INLINE (<*>) #-} (<*>) = serialWith id diff --git a/src/Streamly/Internal/Data/Parser/ParserK/Type.hs b/src/Streamly/Internal/Data/Parser/ParserK/Type.hs index fce9c7754..6a3b92770 100644 --- a/src/Streamly/Internal/Data/Parser/ParserK/Type.hs +++ b/src/Streamly/Internal/Data/Parser/ParserK/Type.hs @@ -21,8 +21,8 @@ module Streamly.Internal.Data.Parser.ParserK.Type ( Parser (..) - , yield - , yieldM + , fromPure + , fromEffect , die -- * Conversion @@ -279,23 +279,23 @@ instance Functor m => Functor (Parser m a) where -- Sequential applicative ------------------------------------------------------------------------------- --- This is the dual of stream "yield". +-- This is the dual of stream "fromPure". -- -- | A parser that always yields a pure value without consuming any input. -- -- /Pre-release/ -- -{-# INLINE yield #-} -yield :: b -> Parser m a b -yield b = MkParser $ \lo st yieldk -> yieldk st (Done lo b) +{-# INLINE fromPure #-} +fromPure :: b -> Parser m a b +fromPure b = MkParser $ \lo st yieldk -> yieldk st (Done lo b) --- | See 'Streamly.Internal.Data.Parser.yieldM'. +-- | See 'Streamly.Internal.Data.Parser.fromEffect'. -- -- /Pre-release/ -- -{-# INLINE yieldM #-} -yieldM :: Monad m => m b -> Parser m a b -yieldM eff = MkParser $ \lo st yieldk -> eff >>= \b -> yieldk st (Done lo b) +{-# INLINE fromEffect #-} +fromEffect :: Monad m => m b -> Parser m a b +fromEffect eff = MkParser $ \lo st yieldk -> eff >>= \b -> yieldk st (Done lo b) -- | 'Applicative' form of 'Streamly.Internal.Data.Parser.serialWith'. Note that -- this operation does not fuse, use 'Streamly.Internal.Data.Parser.serialWith' @@ -303,7 +303,7 @@ yieldM eff = MkParser $ \lo st yieldk -> eff >>= \b -> yieldk st (Done lo b) -- instance Monad m => Applicative (Parser m a) where {-# INLINE pure #-} - pure = yield + pure = fromPure {-# INLINE (<*>) #-} (<*>) = ap diff --git a/src/Streamly/Internal/FileSystem/Event/Linux.hs b/src/Streamly/Internal/FileSystem/Event/Linux.hs index 361678b68..4797a1a5b 100644 --- a/src/Streamly/Internal/FileSystem/Event/Linux.hs +++ b/src/Streamly/Internal/FileSystem/Event/Linux.hs @@ -774,7 +774,7 @@ readOneEvent :: Config -> Watch -> Parser IO Word8 Event readOneEvent cfg wt@(Watch _ wdMap) = do let headerLen = (sizeOf (undefined :: CInt)) + 12 arr <- PR.takeEQ headerLen (A.writeN headerLen) - (ewd, eflags, cookie, pathLen) <- PR.yieldM $ A.asPtr arr readHeader + (ewd, eflags, cookie, pathLen) <- PR.fromEffect $ A.asPtr arr readHeader -- XXX need the "initial" in parsers to return a step type so that "take 0" -- can return without an input. otherwise if pathLen is 0 we will keep -- waiting to read one more char before we return this event. @@ -792,7 +792,7 @@ readOneEvent cfg wt@(Watch _ wdMap) = do when (remaining /= 0) $ PR.takeEQ remaining FL.drain return pth else return $ A.fromList [] - wdm <- PR.yieldM $ readIORef wdMap + wdm <- PR.fromEffect $ readIORef wdMap let (root, sub) = case Map.lookup (fromIntegral ewd) wdm of Just pair -> pair @@ -805,7 +805,7 @@ readOneEvent cfg wt@(Watch _ wdMap) = do -- Check for "ISDIR" first because it is less likely isDirCreate = eflags .&. iN_ISDIR /= 0 && eflags .&. iN_CREATE /= 0 when (watchRec cfg && isDirCreate) - $ PR.yieldM $ addToWatch cfg wt root sub1 + $ PR.fromEffect $ addToWatch cfg wt root sub1 -- XXX Handle IN_DELETE, IN_DELETE_SELF, IN_MOVE_SELF, IN_MOVED_FROM, -- IN_MOVED_TO -- What if a large dir tree gets moved in to our hierarchy? Do we get a diff --git a/test/Streamly/Test/Data/Parser.hs b/test/Streamly/Test/Data/Parser.hs index 99de323ed..6195203d9 100644 --- a/test/Streamly/Test/Data/Parser.hs +++ b/test/Streamly/Test/Data/Parser.hs @@ -61,17 +61,17 @@ fromFold = Right is_equal -> is_equal Left _ -> False -yield :: Property -yield = +fromPure :: Property +fromPure = forAll (chooseInt (min_value, max_value)) $ \x -> - case S.parse (P.yield x) (S.fromList [1 :: Int]) of + case S.parse (P.fromPure x) (S.fromList [1 :: Int]) of Right r -> r == x Left _ -> False -yieldM :: Property -yieldM = +fromEffect :: Property +fromEffect = forAll (chooseInt (min_value, max_value)) $ \x -> - case S.parse (P.yieldM $ return x) (S.fromList [1 :: Int]) of + case S.parse (P.fromEffect $ return x) (S.fromList [1 :: Int]) of Right r -> r == x Left _ -> False @@ -418,13 +418,13 @@ wordBy = -- splitWithFailLeft :: Property -- splitWithFailLeft = --- property (case S.parse (P.serialWith (,) (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of +-- property (case S.parse (P.serialWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of -- Right _ -> False -- Left _ -> True) -- splitWithFailRight :: Property -- splitWithFailRight = --- property (case S.parse (P.serialWith (,) (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of +-- property (case S.parse (P.serialWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of -- Right _ -> False -- Left _ -> True) @@ -447,13 +447,13 @@ wordBy = -- teeWithFailLeft :: Property -- teeWithFailLeft = --- property (case S.parse (P.teeWith (,) (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of +-- property (case S.parse (P.teeWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of -- Right _ -> False -- Left _ -> True) -- teeWithFailRight :: Property -- teeWithFailRight = --- property (case S.parse (P.teeWith (,) (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of +-- property (case S.parse (P.teeWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of -- Right _ -> False -- Left _ -> True) @@ -489,13 +489,13 @@ wordBy = -- shortestFailLeft :: Property -- shortestFailLeft = --- property (case S.parse (P.shortest (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of +-- property (case S.parse (P.shortest (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of -- Right r -> r == 1 -- Left _ -> False) -- shortestFailRight :: Property -- shortestFailRight = --- property (case S.parse (P.shortest (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of +-- property (case S.parse (P.shortest (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of -- Right r -> r == 1 -- Left _ -> False) @@ -705,8 +705,8 @@ main = describe "test for accumulator" $ do prop "P.fromFold FL.sum = FL.sum" fromFold - prop "yield value provided" yield - prop "yield monadic value provided" yieldM + prop "fromPure value provided" fromPure + prop "fromPure monadic value provided" fromEffect prop "fail err = Left (SomeException (ParseError err))" parserFail prop "always fail" die prop "always fail but monadic" dieM diff --git a/test/Streamly/Test/Data/Parser/ParserD.hs b/test/Streamly/Test/Data/Parser/ParserD.hs index 1553acad9..2457db40d 100644 --- a/test/Streamly/Test/Data/Parser/ParserD.hs +++ b/test/Streamly/Test/Data/Parser/ParserD.hs @@ -64,17 +64,17 @@ fromFold = Right is_equal -> is_equal Left _ -> False -yield :: Property -yield = +fromPure :: Property +fromPure = forAll (chooseInt (min_value, max_value)) $ \x -> - case S.parseD (P.yield x) (S.fromList [1 :: Int]) of + case S.parseD (P.fromPure x) (S.fromList [1 :: Int]) of Right r -> r == x Left _ -> False -yieldM :: Property -yieldM = +fromEffect :: Property +fromEffect = forAll (chooseInt (min_value, max_value)) $ \x -> - case S.parseD (P.yieldM $ return x) (S.fromList [1 :: Int]) of + case S.parseD (P.fromEffect $ return x) (S.fromList [1 :: Int]) of Right r -> r == x Left _ -> False @@ -396,13 +396,13 @@ serialWith = splitWithFailLeft :: Property splitWithFailLeft = - property (case S.parseD (P.serialWith (,) (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of + property (case S.parseD (P.serialWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of Right _ -> False Left _ -> True) splitWithFailRight :: Property splitWithFailRight = - property (case S.parseD (P.serialWith (,) (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of + property (case S.parseD (P.serialWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of Right _ -> False Left _ -> True) @@ -425,13 +425,13 @@ teeWithPass = teeWithFailLeft :: Property teeWithFailLeft = - property (case S.parseD (P.teeWith (,) (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of + property (case S.parseD (P.teeWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of Right _ -> False Left _ -> True) teeWithFailRight :: Property teeWithFailRight = - property (case S.parseD (P.teeWith (,) (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of + property (case S.parseD (P.teeWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of Right _ -> False Left _ -> True) @@ -456,13 +456,13 @@ shortestPass = shortestPassLeft :: Property shortestPassLeft = - property (case S.parseD (P.shortest (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of + property (case S.parseD (P.shortest (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of Right r -> r == 1 Left _ -> False) shortestPassRight :: Property shortestPassRight = - property (case S.parseD (P.shortest (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of + property (case S.parseD (P.shortest (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of Right r -> r == 1 Left _ -> False) @@ -490,13 +490,13 @@ longestPass = longestPassLeft :: Property longestPassLeft = - property (case S.parseD (P.shortest (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of + property (case S.parseD (P.shortest (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of Right r -> r == 1 Left _ -> False) longestPassRight :: Property longestPassRight = - property (case S.parseD (P.shortest (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of + property (case S.parseD (P.shortest (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of Right r -> r == 1 Left _ -> False) @@ -723,8 +723,8 @@ main = describe "test for accumulator" $ do prop "P.fromFold FL.sum = FL.sum" fromFold - prop "yield value provided" yield - prop "yield monadic value provided" yieldM + prop "fromPure value provided" fromPure + prop "fromPure monadic value provided" fromEffect prop "always fail" die prop "always fail but monadic" dieM