master..5d096df · streamly

git.iko.soy/streamly

on 5d096df help sign in

core/src/Streamly/Internal/Data/Stream/Type.hs−4

@@ -572,12 +572,8 @@ foldAdd f =

572-- >>> Stream.foldrM step (return False) s

573-- True

574--

575−-- >>> import Control.Monad (join)

576−-- >>> foldrM f z = join $ Stream.foldr f z

577−--

578{-# INLINE_NORMAL foldrM #-}

575{-# INLINE_NORMAL foldrM #-}

579foldrM :: Monad m => (a -> m b -> m b) -> m b -> Stream m a -> m b

576foldrM :: Monad m => (a -> m b -> m b) -> m b -> Stream m a -> m b

580−-- foldrM f z = join . Streamly.Internal.Data.Stream.StreamD.Type.foldr f z

581foldrM f z (Stream step state) = go SPEC state

577foldrM f z (Stream step state) = go SPEC state

582 where

578 where

583 {-# INLINE_LATE go #-}

579 {-# INLINE_LATE go #-}

docs/Developer/optimization-guidelines.md−12

@@ -191,18 +191,6 @@ the stages of a loop, it is often not useful to inline the whole loop

191itself, in fact we may have to occasionally use a `NOINLINE` so that the

192compiler does not inline it.

193

194−We need to be careful about NOINLINE on polymorphic functions. When

195−NOINLINE is used, the function cannot be specialized causing huge

196−performance degradation. To avoid that we can either make the

197−function monomorphic or sometimes using `NOINLINE [0]` can do the

198−trick. `NOINLINE [0]` blocks inlining in earlier phases but lets it

199−specialize in the last phase, inlining in the last phase is left to

200−the compiler. `INLINE [0]` may sound the same as `NOINLINE [0]`,

201−however, it behaves differently because we ask the compiler to INLINE

202−it compulsorily and it may not give us the desired results. The

203−Data.Fold.writeLastN benchmark is one such case where `NOINLINE [0]`

204−provides much better performance than `INLINE [0]`.

205−

206### NoSpecConstr

194### NoSpecConstr

207

195

208It is not always useful to specialize function calls for all constructors, some

196It is not always useful to specialize function calls for all constructors, some