4115d58 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Remove MonadIO constraint

4115d58Harendra Kumar5 years ago

src/Streamly/Internal/Data/Array/Foreign/Type.hs+3

compare with master

unifiedsplit

@@ -120,6 +120,9 @@ import qualified Data.Foldable as F

120-- >>> import Prelude hiding (length, foldr, read, unlines, splitAt)

121-- >>> import Streamly.Internal.Data.Array.Foreign as Array

122

123+-- XXX Since these are immutable arrays MonadIO constraint can be removed from

124+-- most places.

125+

123-------------------------------------------------------------------------------

126-------------------------------------------------------------------------------

124-- Array Data Type

127-- Array Data Type

125-------------------------------------------------------------------------------

128-------------------------------------------------------------------------------

src/Streamly/Internal/Data/Array/Stream/Foreign.hs+13−7

@@ -90,6 +90,9 @@ import qualified Streamly.Internal.Data.Parser.ParserD as PRD

90import qualified Streamly.Internal.Data.Stream.IsStream as S

91import qualified Streamly.Internal.Data.Stream.StreamD as D

93+-- XXX Since these are immutable arrays MonadIO constraint can be removed from

94+-- most places.

95+

93-------------------------------------------------------------------------------

96-------------------------------------------------------------------------------

94-- Generation

97-- Generation

95-------------------------------------------------------------------------------

98-------------------------------------------------------------------------------

@@ -115,13 +118,13 @@ arraysOf n str = fromStreamD $ A.arraysOf n (toStreamD str)

115

118

116-- | Convert a stream of arrays into a stream of their elements.

119-- | Convert a stream of arrays into a stream of their elements.

117--

120--

118−-- Same as the following but more efficient:

121+-- Same as the following:

119--

122--

120-- > concat = Stream.unfoldMany Array.read

123-- > concat = Stream.unfoldMany Array.read

121--

124--

122-- @since 0.7.0

125-- @since 0.7.0

123{-# INLINE concat #-}

126{-# INLINE concat #-}

124−concat :: (IsStream t, MonadIO m, Storable a) => t m (Array a) -> t m a

127+concat :: (IsStream t, Monad m, Storable a) => t m (Array a) -> t m a

125-- concat m = fromStreamD $ A.flattenArrays (toStreamD m)

128-- concat m = fromStreamD $ A.flattenArrays (toStreamD m)

126-- concat m = fromStreamD $ D.concatMap A.toStreamD (toStreamD m)

129-- concat m = fromStreamD $ D.concatMap A.toStreamD (toStreamD m)

127concat m = fromStreamD $ D.unfoldMany A.read (toStreamD m)

130concat m = fromStreamD $ D.unfoldMany A.read (toStreamD m)

@@ -133,8 +136,9 @@ concat m = fromStreamD $ D.unfoldMany A.read (toStreamD m)

133--

136--

134-- @since 0.7.0

137-- @since 0.7.0

135{-# INLINE concatRev #-}

138{-# INLINE concatRev #-}

136−concatRev :: (IsStream t, MonadIO m, Storable a) => t m (Array a) -> t m a

139+concatRev :: (IsStream t, Monad m, Storable a) => t m (Array a) -> t m a

137−concatRev m = fromStreamD $ A.flattenArraysRev (toStreamD m)

140+-- concatRev m = fromStreamD $ A.flattenArraysRev (toStreamD m)

141+concatRev m = fromStreamD $ D.unfoldMany A.readRev (toStreamD m)

138

142

139-------------------------------------------------------------------------------

143-------------------------------------------------------------------------------

140-- Intersperse and append

144-- Intersperse and append

@@ -145,11 +149,11 @@ concatRev m = fromStreamD $ A.flattenArraysRev (toStreamD m)

145--

149--

146-- /Pre-release/

150-- /Pre-release/

147{-# INLINE interpose #-}

151{-# INLINE interpose #-}

148−interpose :: (MonadIO m, IsStream t, Storable a) => a -> t m (Array a) -> t m a

152+interpose :: (Monad m, IsStream t, Storable a) => a -> t m (Array a) -> t m a

149interpose x = S.interpose x A.read

153interpose x = S.interpose x A.read

150

154

151{-# INLINE intercalateSuffix #-}

155{-# INLINE intercalateSuffix #-}

152−intercalateSuffix :: (MonadIO m, IsStream t, Storable a)

156+intercalateSuffix :: (Monad m, IsStream t, Storable a)

153 => Array a -> t m (Array a) -> t m a

157 => Array a -> t m (Array a) -> t m a

154intercalateSuffix = S.intercalateSuffix A.read

158intercalateSuffix = S.intercalateSuffix A.read

155

159

@@ -158,7 +162,7 @@ intercalateSuffix = S.intercalateSuffix A.read

158--

162--

159-- @since 0.7.0

163-- @since 0.7.0

160{-# INLINE interposeSuffix #-}

164{-# INLINE interposeSuffix #-}

161−interposeSuffix :: (MonadIO m, IsStream t, Storable a)

165+interposeSuffix :: (Monad m, IsStream t, Storable a)

162 => a -> t m (Array a) -> t m a

166 => a -> t m (Array a) -> t m a

163-- interposeSuffix x = fromStreamD . A.unlines x . toStreamD

167-- interposeSuffix x = fromStreamD . A.unlines x . toStreamD

164interposeSuffix x = S.interposeSuffix x A.read

168interposeSuffix x = S.interposeSuffix x A.read

@@ -167,6 +171,7 @@ data FlattenState s a =

167 OuterLoop s

171 OuterLoop s

168 | InnerLoop s !MA.ArrayContents !(Ptr a) !(Ptr a)

172 | InnerLoop s !MA.ArrayContents !(Ptr a) !(Ptr a)

169

173

174+-- XXX Remove monadIO constraint

170{-# INLINE_NORMAL unlines #-}

175{-# INLINE_NORMAL unlines #-}

171unlines :: forall m a. (MonadIO m, Storable a)

176unlines :: forall m a. (MonadIO m, Storable a)

172 => a -> D.Stream m (Array a) -> D.Stream m a

177 => a -> D.Stream m (Array a) -> D.Stream m a

@@ -283,6 +288,7 @@ _splitOn byte (D.Stream step state) = D.Stream step' (Initial state)

283 step' _ (Yielding arr next) = return $ D.Yield arr next

288 step' _ (Yielding arr next) = return $ D.Yield arr next

284 step' _ Finishing = return D.Stop

289 step' _ Finishing = return D.Stop

285

290

291+-- XXX Remove MonadIO constraint.

286-- | Split a stream of arrays on a given separator byte, dropping the separator

292-- | Split a stream of arrays on a given separator byte, dropping the separator

287-- and coalescing all the arrays between two separators into a single array.

293-- and coalescing all the arrays between two separators into a single array.

288--

294--