mirror of
https://github.com/composewell/streamly.git
synced 2024-08-16 15:00:25 +03:00
Repurpose the streamk build flag
Fix review comments Fix review comments Rename stramk CI to no-fusion
This commit is contained in:
Ranjeet Kumar Ranjan
Harendra Kumar
parent
9cce0ebeed
commit
ca76876369
4
.github/workflows/haskell.yml
vendored
4
.github/workflows/haskell.yml
vendored
@ -132,13 +132,13 @@ jobs:
|
||||
cabal_project: cabal.project
|
||||
cabal_build_options: "--flag fusion-plugin"
|
||||
ignore_error: false
|
||||
- name: 8.6.5-sdist-streamk-unoptimized
|
||||
- name: 8.6.5-sdist-no-fusion-unoptimized
|
||||
ghc_version: 8.6.5
|
||||
runner: ubuntu-latest
|
||||
build: cabal
|
||||
cabal_version: 3.6
|
||||
cabal_project: cabal.project
|
||||
cabal_build_options: "--flag streamk --flag -opt"
|
||||
cabal_build_options: "--flag no-fusion --flag -opt"
|
||||
ignore_error: false
|
||||
- name: 8.6.5-sdist-debug-unoptimized
|
||||
ghc_version: 8.6.5
|
||||
|
||||
@ -33,13 +33,6 @@ where
|
||||
|
||||
import Streamly.Internal.Data.Fold.Type (Fold (..))
|
||||
|
||||
#ifdef USE_STREAMK_ONLY
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK as S
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK.Type as S
|
||||
#else
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD.Type as S
|
||||
#endif
|
||||
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD.Type as D
|
||||
|
||||
@ -59,15 +52,15 @@ import Prelude hiding (foldr, repeat)
|
||||
--
|
||||
{-# INLINE_EARLY fromList #-}
|
||||
fromList :: Monad m => [a] -> K.Stream m a
|
||||
fromList = S.toStreamK . S.fromList
|
||||
fromList = D.toStreamK . D.fromList
|
||||
{-# RULES "fromList fallback to StreamK" [1]
|
||||
forall a. S.toStreamK (S.fromList a) = K.fromFoldable a #-}
|
||||
forall a. D.toStreamK (D.fromList a) = K.fromFoldable a #-}
|
||||
|
||||
-- | Convert a stream into a list in the underlying monad.
|
||||
--
|
||||
{-# INLINE toList #-}
|
||||
toList :: Monad m => K.Stream m a -> m [a]
|
||||
toList m = S.toList $ S.fromStreamK m
|
||||
toList m = D.toList $ D.fromStreamK m
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Folds
|
||||
@ -75,7 +68,7 @@ toList m = S.toList $ S.fromStreamK m
|
||||
|
||||
{-# INLINE foldrM #-}
|
||||
foldrM :: Monad m => (a -> m b -> m b) -> m b -> K.Stream m a -> m b
|
||||
foldrM step acc m = S.foldrM step acc $ S.fromStreamK m
|
||||
foldrM step acc m = D.foldrM step acc $ D.fromStreamK m
|
||||
|
||||
{-# INLINE foldr #-}
|
||||
foldr :: Monad m => (a -> b -> b) -> b -> K.Stream m a -> m b
|
||||
@ -86,12 +79,12 @@ foldr f z = foldrM (\a b -> f a <$> b) (return z)
|
||||
{-# INLINE foldl' #-}
|
||||
foldl' ::
|
||||
Monad m => (b -> a -> b) -> b -> K.Stream m a -> m b
|
||||
foldl' step begin m = S.foldl' step begin $ S.fromStreamK m
|
||||
foldl' step begin m = D.foldl' step begin $ D.fromStreamK m
|
||||
|
||||
|
||||
{-# INLINE fold #-}
|
||||
fold :: Monad m => Fold m a b -> K.Stream m a -> m b
|
||||
fold fld m = S.fold fld $ S.fromStreamK m
|
||||
fold fld m = D.fold fld $ D.fromStreamK m
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Comparison
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
--
|
||||
-- {-# INLINE_EARLY unfoldr #-}
|
||||
-- unfoldr :: (Monad m, IsStream t) => (b -> Maybe (a, b)) -> b -> t m a
|
||||
-- unfoldr step seed = fromStreamS (S.unfoldr step seed)
|
||||
-- unfoldr step seed = fromStreamD (S.unfoldr step seed)
|
||||
-- {-# RULES "unfoldr fallback to StreamK" [1]
|
||||
-- forall a b. S.toStreamK (S.unfoldr a b) = K.unfoldr a b #-}```
|
||||
--
|
||||
|
||||
@ -57,11 +57,6 @@ flag no-fusion
|
||||
manual: True
|
||||
default: False
|
||||
|
||||
flag streamk
|
||||
description: Use CPS style streams when possible
|
||||
manual: True
|
||||
default: False
|
||||
|
||||
flag use-c-malloc
|
||||
description: Use C malloc instead of GHC malloc
|
||||
manual: True
|
||||
@ -99,9 +94,6 @@ flag use-folds
|
||||
common compile-options
|
||||
default-language: Haskell2010
|
||||
|
||||
if flag(streamk)
|
||||
cpp-options: -DUSE_STREAMK_ONLY
|
||||
|
||||
if flag(no-fusion)
|
||||
cpp-options: -DDISABLE_FUSION
|
||||
|
||||
|
||||
@ -75,7 +75,7 @@ import Streamly.Internal.Data.Array.Unboxed.Type (Array)
|
||||
import Streamly.Internal.Data.Fold.Type (Fold (..))
|
||||
import Streamly.Internal.Data.Stream.IsStream.Combinators (maxYields)
|
||||
import Streamly.Internal.Data.Stream.IsStream.Type
|
||||
(IsStream(..), fromStreamD, toStreamD, fromStreamS, toStreamS)
|
||||
(IsStream(..), fromStreamD, toStreamD)
|
||||
import Streamly.Internal.Data.Stream.Serial (SerialT)
|
||||
import Streamly.Internal.Data.Time.Units (AbsTime, RelTime64, addToAbsTime64)
|
||||
import Streamly.Internal.System.IO (defaultChunkSize)
|
||||
@ -87,11 +87,6 @@ import qualified Streamly.Internal.Data.Stream.IsStream.Type as IsStream
|
||||
import qualified Streamly.Internal.Data.Stream.Parallel as Par
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD as D
|
||||
#ifdef USE_STREAMK_ONLY
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK as S
|
||||
#else
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD as S
|
||||
#endif
|
||||
import qualified Streamly.Internal.Data.Stream as Stream
|
||||
|
||||
import Prelude hiding (take, takeWhile, drop, reverse, concatMap, map, zipWith)
|
||||
@ -202,7 +197,7 @@ repeatM = K.repeatMWith IsStream.consM
|
||||
{-# RULES "repeatM serial" repeatM = repeatMSerial #-}
|
||||
{-# INLINE repeatMSerial #-}
|
||||
repeatMSerial :: MonadAsync m => m a -> SerialT m a
|
||||
repeatMSerial = fromStreamS . S.repeatM
|
||||
repeatMSerial = fromStreamD . D.repeatM
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Generation - Time related
|
||||
@ -298,7 +293,7 @@ foldContinue f s = D.foldContinue f $ IsStream.toStreamD s
|
||||
-- Same as 'fmap'.
|
||||
--
|
||||
-- @
|
||||
-- > S.toList $ S.map (+1) $ S.fromList [1,2,3]
|
||||
-- > D.toList $ D.map (+1) $ D.fromList [1,2,3]
|
||||
-- [2,3,4]
|
||||
-- @
|
||||
--
|
||||
@ -397,7 +392,7 @@ smapM step initial stream =
|
||||
-- @since 0.1.0
|
||||
{-# INLINE take #-}
|
||||
take :: (IsStream t, Monad m) => Int -> t m a -> t m a
|
||||
take n m = fromStreamS $ S.take n $ toStreamS
|
||||
take n m = fromStreamD $ D.take n $ toStreamD
|
||||
(maxYields (Just (fromIntegral n)) m)
|
||||
|
||||
-- | End the stream as soon as the predicate fails on an element.
|
||||
@ -405,7 +400,7 @@ take n m = fromStreamS $ S.take n $ toStreamS
|
||||
-- @since 0.1.0
|
||||
{-# INLINE takeWhile #-}
|
||||
takeWhile :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> t m a
|
||||
takeWhile p m = fromStreamS $ S.takeWhile p $ toStreamS m
|
||||
takeWhile p m = fromStreamD $ D.takeWhile p $ toStreamD m
|
||||
|
||||
{-# INLINE takeEndBy #-}
|
||||
takeEndBy :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> t m a
|
||||
@ -416,7 +411,7 @@ takeEndBy p m = fromStreamD $ D.takeEndBy p $ toStreamD m
|
||||
-- @since 0.1.0
|
||||
{-# INLINE drop #-}
|
||||
drop :: (IsStream t, Monad m) => Int -> t m a -> t m a
|
||||
drop n m = fromStreamS $ S.drop n $ toStreamS m
|
||||
drop n m = fromStreamD $ D.drop n $ toStreamD m
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Searching
|
||||
@ -430,7 +425,7 @@ drop n m = fromStreamS $ S.drop n $ toStreamS m
|
||||
-- @since 0.5.0
|
||||
{-# INLINE findIndices #-}
|
||||
findIndices :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> t m Int
|
||||
findIndices p m = fromStreamS $ S.findIndices p (toStreamS m)
|
||||
findIndices p m = fromStreamD $ D.findIndices p (toStreamD m)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Transformation by Inserting
|
||||
@ -454,7 +449,7 @@ findIndices p m = fromStreamS $ S.findIndices p (toStreamS m)
|
||||
-- @since 0.5.0
|
||||
{-# INLINE intersperseM #-}
|
||||
intersperseM :: (IsStream t, MonadAsync m) => m a -> t m a -> t m a
|
||||
intersperseM m = fromStreamS . S.intersperseM m . toStreamS
|
||||
intersperseM m = fromStreamD . D.intersperseM m . toStreamD
|
||||
|
||||
-- | Intersperse a monadic action into the input stream after every @n@
|
||||
-- seconds.
|
||||
@ -493,7 +488,7 @@ interjectSuffix n f xs = xs `parallelFst` repeatM timed
|
||||
-- /Since: 0.1.1/
|
||||
{-# INLINE reverse #-}
|
||||
reverse :: (IsStream t, Monad m) => t m a -> t m a
|
||||
reverse s = fromStreamS $ S.reverse $ toStreamS s
|
||||
reverse s = fromStreamD $ D.reverse $ toStreamD s
|
||||
|
||||
-- | Like 'reverse' but several times faster, requires a 'Storable' instance.
|
||||
--
|
||||
@ -699,8 +694,8 @@ splitOnSeq patt f m =
|
||||
{-# INLINE zipWithM #-}
|
||||
zipWithM :: (IsStream t, Monad m) => (a -> b -> m c) -> t m a -> t m b -> t m c
|
||||
zipWithM f m1 m2 =
|
||||
IsStream.fromStreamS
|
||||
$ S.zipWithM f (IsStream.toStreamS m1) (IsStream.toStreamS m2)
|
||||
IsStream.fromStreamD
|
||||
$ D.zipWithM f (IsStream.toStreamD m1) (IsStream.toStreamD m2)
|
||||
|
||||
-- | Stream @a@ is evaluated first, followed by stream @b@, the resulting
|
||||
-- elements @a@ and @b@ are then zipped using the supplied zip function and the
|
||||
@ -710,7 +705,7 @@ zipWithM f m1 m2 =
|
||||
-- first, the element @a@ from previous evaluation of stream @a@ is discarded.
|
||||
--
|
||||
-- @
|
||||
-- > S.toList $ S.zipWith (+) (S.fromList [1,2,3]) (S.fromList [4,5,6])
|
||||
-- > D.toList $ D.zipWith (+) (D.fromList [1,2,3]) (D.fromList [4,5,6])
|
||||
-- [5,7,9]
|
||||
-- @
|
||||
--
|
||||
@ -718,5 +713,5 @@ zipWithM f m1 m2 =
|
||||
{-# INLINE zipWith #-}
|
||||
zipWith :: (IsStream t, Monad m) => (a -> b -> c) -> t m a -> t m b -> t m c
|
||||
zipWith f m1 m2 =
|
||||
IsStream.fromStreamS
|
||||
$ S.zipWith f (IsStream.toStreamS m1) (IsStream.toStreamS m2)
|
||||
IsStream.fromStreamD
|
||||
$ D.zipWith f (IsStream.toStreamD m1) (IsStream.toStreamD m2)
|
||||
|
||||
@ -163,7 +163,7 @@ import Streamly.Internal.Data.Stream.IsStream.Common
|
||||
( fold, foldBreak, foldContinue, drop, findIndices, reverse, splitOnSeq
|
||||
, take , takeWhile, mkParallel)
|
||||
import Streamly.Internal.Data.Stream.IsStream.Type
|
||||
(IsStream, toStreamS, fromStreamD, toStreamD)
|
||||
(IsStream, toStreamD, fromStreamD, toStreamD)
|
||||
import Streamly.Internal.Data.Stream.Serial (SerialT)
|
||||
import Streamly.Internal.Data.Unboxed (Unboxed)
|
||||
|
||||
@ -172,11 +172,6 @@ import qualified Streamly.Internal.Data.Fold as FL
|
||||
import qualified Streamly.Internal.Data.Stream.IsStream.Type as IsStream
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD as D
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
|
||||
#ifdef USE_STREAMK_ONLY
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK as S
|
||||
#else
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD as S
|
||||
#endif
|
||||
import qualified Streamly.Internal.Data.Stream as Stream
|
||||
import qualified System.IO as IO
|
||||
|
||||
@ -240,7 +235,7 @@ uncons = fmap (fmap (fmap IsStream.fromStream)) . K.uncons . Stream.toStreamK
|
||||
{-# INLINE foldr1 #-}
|
||||
{-# DEPRECATED foldr1 "Use foldrM instead." #-}
|
||||
foldr1 :: Monad m => (a -> a -> a) -> SerialT m a -> m (Maybe a)
|
||||
foldr1 f m = S.foldr1 f (toStreamS m)
|
||||
foldr1 f m = D.foldr1 f (toStreamD m)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Left Folds
|
||||
@ -260,12 +255,12 @@ foldlS f z =
|
||||
--
|
||||
-- For example, to reverse a stream:
|
||||
--
|
||||
-- > S.toList $ S.foldlT (flip S.cons) S.nil $ (S.fromList [1..5] :: SerialT IO Int)
|
||||
-- > D.toList $ D.foldlT (flip D.cons) D.nil $ (D.fromList [1..5] :: SerialT IO Int)
|
||||
--
|
||||
{-# INLINE foldlT #-}
|
||||
foldlT :: (Monad m, IsStream t, Monad (s m), MonadTrans s)
|
||||
=> (s m b -> a -> s m b) -> s m b -> t m a -> s m b
|
||||
foldlT f z s = S.foldlT f z (toStreamS s)
|
||||
foldlT f z s = D.foldlT f z (toStreamD s)
|
||||
|
||||
-- | Strict left fold with an extraction function. Like the standard strict
|
||||
-- left fold, but applies a user supplied extraction function (the third
|
||||
@ -320,7 +315,7 @@ foldxM = IsStream.foldlMx'
|
||||
-- /Since: 0.8.0 (signature change)/
|
||||
{-# INLINE foldlM' #-}
|
||||
foldlM' :: Monad m => (b -> a -> m b) -> m b -> SerialT m a -> m b
|
||||
foldlM' step begin = S.foldlM' step begin . IsStream.toStreamS
|
||||
foldlM' step begin = D.foldlM' step begin . IsStream.toStreamD
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Running a sink
|
||||
@ -347,7 +342,7 @@ runSink = fold . toFold
|
||||
-- @since 0.1.0
|
||||
{-# INLINE mapM_ #-}
|
||||
mapM_ :: Monad m => (a -> m b) -> SerialT m a -> m ()
|
||||
mapM_ f = S.mapM_ f . IsStream.toStreamS
|
||||
mapM_ f = D.mapM_ f . IsStream.toStreamD
|
||||
|
||||
-- |
|
||||
-- > drain = mapM_ (\_ -> return ())
|
||||
@ -422,7 +417,7 @@ runStream = drain
|
||||
-- @since 0.1.1
|
||||
{-# INLINE null #-}
|
||||
null :: Monad m => SerialT m a -> m Bool
|
||||
null = S.null . toStreamS
|
||||
null = D.null . toStreamD
|
||||
|
||||
-- | Extract the first element of the stream, if any.
|
||||
--
|
||||
@ -432,7 +427,7 @@ null = S.null . toStreamS
|
||||
-- @since 0.1.0
|
||||
{-# INLINE head #-}
|
||||
head :: Monad m => SerialT m a -> m (Maybe a)
|
||||
head = S.head . toStreamS
|
||||
head = D.head . toStreamD
|
||||
|
||||
-- | Extract the first element of the stream, if any, otherwise use the
|
||||
-- supplied default value. It can help avoid one branch in high performance
|
||||
@ -468,7 +463,7 @@ init m = fmap (fmap IsStream.fromStream) $ K.init $ Stream.toStreamK m
|
||||
-- @since 0.1.1
|
||||
{-# INLINE last #-}
|
||||
last :: Monad m => SerialT m a -> m (Maybe a)
|
||||
last m = S.last $ toStreamS m
|
||||
last m = D.last $ toStreamD m
|
||||
|
||||
-- | Determine whether an element is present in the stream.
|
||||
--
|
||||
@ -477,7 +472,7 @@ last m = S.last $ toStreamS m
|
||||
-- @since 0.1.0
|
||||
{-# INLINE elem #-}
|
||||
elem :: (Monad m, Eq a) => a -> SerialT m a -> m Bool
|
||||
elem e m = S.elem e (toStreamS m)
|
||||
elem e m = D.elem e (toStreamD m)
|
||||
|
||||
-- | Determine whether an element is not present in the stream.
|
||||
--
|
||||
@ -486,7 +481,7 @@ elem e m = S.elem e (toStreamS m)
|
||||
-- @since 0.1.0
|
||||
{-# INLINE notElem #-}
|
||||
notElem :: (Monad m, Eq a) => a -> SerialT m a -> m Bool
|
||||
notElem e m = S.notElem e (toStreamS m)
|
||||
notElem e m = D.notElem e (toStreamD m)
|
||||
|
||||
-- | Determine the length of the stream.
|
||||
--
|
||||
@ -502,7 +497,7 @@ length = foldl' (\n _ -> n + 1) 0
|
||||
-- @since 0.1.0
|
||||
{-# INLINE all #-}
|
||||
all :: Monad m => (a -> Bool) -> SerialT m a -> m Bool
|
||||
all p m = S.all p (toStreamS m)
|
||||
all p m = D.all p (toStreamD m)
|
||||
|
||||
-- | Determine whether any of the elements of a stream satisfy a predicate.
|
||||
--
|
||||
@ -511,7 +506,7 @@ all p m = S.all p (toStreamS m)
|
||||
-- @since 0.1.0
|
||||
{-# INLINE any #-}
|
||||
any :: Monad m => (a -> Bool) -> SerialT m a -> m Bool
|
||||
any p m = S.any p (toStreamS m)
|
||||
any p m = D.any p (toStreamD m)
|
||||
|
||||
-- | Determines if all elements of a boolean stream are True.
|
||||
--
|
||||
@ -572,7 +567,7 @@ mconcat = Stream.foldr mappend mempty
|
||||
-- @since 0.1.0
|
||||
{-# INLINE minimum #-}
|
||||
minimum :: (Monad m, Ord a) => SerialT m a -> m (Maybe a)
|
||||
minimum m = S.minimum (toStreamS m)
|
||||
minimum m = D.minimum (toStreamD m)
|
||||
|
||||
-- | Determine the minimum element in a stream using the supplied comparison
|
||||
-- function.
|
||||
@ -582,7 +577,7 @@ minimum m = S.minimum (toStreamS m)
|
||||
-- @since 0.6.0
|
||||
{-# INLINE minimumBy #-}
|
||||
minimumBy :: Monad m => (a -> a -> Ordering) -> SerialT m a -> m (Maybe a)
|
||||
minimumBy cmp m = S.minimumBy cmp (toStreamS m)
|
||||
minimumBy cmp m = D.minimumBy cmp (toStreamD m)
|
||||
|
||||
-- |
|
||||
-- @
|
||||
@ -595,7 +590,7 @@ minimumBy cmp m = S.minimumBy cmp (toStreamS m)
|
||||
-- @since 0.1.0
|
||||
{-# INLINE maximum #-}
|
||||
maximum :: (Monad m, Ord a) => SerialT m a -> m (Maybe a)
|
||||
maximum m = S.maximum (toStreamS m)
|
||||
maximum m = D.maximum (toStreamD m)
|
||||
|
||||
-- | Determine the maximum element in a stream using the supplied comparison
|
||||
-- function.
|
||||
@ -605,7 +600,7 @@ maximum m = S.maximum (toStreamS m)
|
||||
-- @since 0.6.0
|
||||
{-# INLINE maximumBy #-}
|
||||
maximumBy :: Monad m => (a -> a -> Ordering) -> SerialT m a -> m (Maybe a)
|
||||
maximumBy cmp m = S.maximumBy cmp (toStreamS m)
|
||||
maximumBy cmp m = D.maximumBy cmp (toStreamD m)
|
||||
|
||||
-- | Ensures that all the elements of the stream are identical and then returns
|
||||
-- that unique element.
|
||||
@ -613,7 +608,7 @@ maximumBy cmp m = S.maximumBy cmp (toStreamS m)
|
||||
-- @since 0.6.0
|
||||
{-# INLINE the #-}
|
||||
the :: (Eq a, Monad m) => SerialT m a -> m (Maybe a)
|
||||
the m = S.the (toStreamS m)
|
||||
the m = D.the (toStreamD m)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Searching
|
||||
@ -624,7 +619,7 @@ the m = S.the (toStreamS m)
|
||||
-- @since 0.6.0
|
||||
{-# INLINE (!!) #-}
|
||||
(!!) :: Monad m => SerialT m a -> Int -> m (Maybe a)
|
||||
m !! i = toStreamS m S.!! i
|
||||
m !! i = toStreamD m D.!! i
|
||||
|
||||
-- | In a stream of (key-value) pairs @(a, b)@, return the value @b@ of the
|
||||
-- first pair where the key equals the given value @a@.
|
||||
@ -635,7 +630,7 @@ m !! i = toStreamS m S.!! i
|
||||
-- @since 0.5.0
|
||||
{-# INLINE lookup #-}
|
||||
lookup :: (Monad m, Eq a) => a -> SerialT m (a, b) -> m (Maybe b)
|
||||
lookup a m = S.lookup a (toStreamS m)
|
||||
lookup a m = D.lookup a (toStreamD m)
|
||||
|
||||
-- | Like 'findM' but with a non-monadic predicate.
|
||||
--
|
||||
@ -645,7 +640,7 @@ lookup a m = S.lookup a (toStreamS m)
|
||||
-- @since 0.5.0
|
||||
{-# INLINE find #-}
|
||||
find :: Monad m => (a -> Bool) -> SerialT m a -> m (Maybe a)
|
||||
find p m = S.find p (toStreamS m)
|
||||
find p m = D.find p (toStreamD m)
|
||||
|
||||
-- | Returns the first element that satisfies the given predicate.
|
||||
--
|
||||
@ -654,7 +649,7 @@ find p m = S.find p (toStreamS m)
|
||||
-- @since 0.6.0
|
||||
{-# INLINE findM #-}
|
||||
findM :: Monad m => (a -> m Bool) -> SerialT m a -> m (Maybe a)
|
||||
findM p m = S.findM p (toStreamS m)
|
||||
findM p m = D.findM p (toStreamD m)
|
||||
|
||||
-- | Returns the first index that satisfies the given predicate.
|
||||
--
|
||||
@ -712,7 +707,7 @@ toListRev = D.toListRev . toStreamD
|
||||
|
||||
-- |
|
||||
-- @
|
||||
-- toHandle h = S.mapM_ $ hPutStrLn h
|
||||
-- toHandle h = D.mapM_ $ hPutStrLn h
|
||||
-- @
|
||||
--
|
||||
-- Write a stream of Strings to an IO Handle.
|
||||
|
||||
@ -763,7 +763,7 @@ mergeMinBy _f _m1 _m2 = undefined
|
||||
mergeFstBy :: -- (IsStream t, Monad m) =>
|
||||
(a -> a -> m Ordering) -> t m a -> t m a -> t m a
|
||||
mergeFstBy _f _m1 _m2 = undefined
|
||||
-- fromStreamS $ D.mergeFstBy f (toStreamD m1) (toStreamD m2)
|
||||
-- fromStreamD $ D.mergeFstBy f (toStreamD m1) (toStreamD m2)
|
||||
|
||||
-- XXX we may want to use the name "merge" differently
|
||||
-- | Same as @'mergeBy' 'compare'@.
|
||||
|
||||
@ -99,7 +99,7 @@ import Streamly.Internal.Data.Stream.IsStream.Common
|
||||
( absTimesWith, concatM, relTimesWith, timesWith, fromPure, fromEffect
|
||||
, yield, yieldM, repeatM)
|
||||
import Streamly.Internal.Data.Stream.IsStream.Type
|
||||
(IsStream (..), fromSerial, consM, fromStreamD, fromStreamS)
|
||||
(IsStream (..), fromSerial, consM, fromStreamD)
|
||||
import Streamly.Internal.Data.Stream.Serial (SerialT)
|
||||
import Streamly.Internal.Data.Stream.WSerial (WSerialT)
|
||||
import Streamly.Internal.Data.Stream.Zip (ZipSerialM)
|
||||
@ -112,12 +112,6 @@ import qualified Streamly.Internal.Data.Stream.Parallel as Par
|
||||
import qualified Streamly.Internal.Data.Stream.Serial as Serial
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD.Generate as D
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
|
||||
#ifdef USE_STREAMK_ONLY
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK as S
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK.Type as S
|
||||
#else
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD.Generate as S
|
||||
#endif
|
||||
import qualified Streamly.Internal.Data.Stream.Type as Stream
|
||||
import qualified System.IO as IO
|
||||
|
||||
@ -187,9 +181,9 @@ unfold0 unf = unfold unf (error "unfold0: unexpected void evaluation")
|
||||
-- @since 0.1.0
|
||||
{-# INLINE_EARLY unfoldr #-}
|
||||
unfoldr :: (Monad m, IsStream t) => (b -> Maybe (a, b)) -> b -> t m a
|
||||
unfoldr step seed = fromStreamS (S.unfoldr step seed)
|
||||
unfoldr step seed = fromStreamD (D.unfoldr step seed)
|
||||
{-# RULES "unfoldr fallback to StreamK" [1]
|
||||
forall a b. S.toStreamK (S.unfoldr a b) = K.unfoldr a b #-}
|
||||
forall a b. D.toStreamK (D.unfoldr a b) = K.unfoldr a b #-}
|
||||
|
||||
-- | Build a stream by unfolding a /monadic/ step function starting from a
|
||||
-- seed. The step function returns the next element in the stream and the next
|
||||
@ -253,7 +247,7 @@ unfoldrMZipSerial f = fromSerial . Serial.unfoldrM f
|
||||
-- @since 0.4.0
|
||||
{-# INLINE_NORMAL repeat #-}
|
||||
repeat :: (IsStream t, Monad m) => a -> t m a
|
||||
repeat = fromStreamS . S.repeat
|
||||
repeat = fromStreamD . D.repeat
|
||||
|
||||
-- |
|
||||
-- >>> replicate n = Stream.take n . Stream.repeat
|
||||
@ -263,7 +257,7 @@ repeat = fromStreamS . S.repeat
|
||||
-- @since 0.6.0
|
||||
{-# INLINE_NORMAL replicate #-}
|
||||
replicate :: (IsStream t, Monad m) => Int -> a -> t m a
|
||||
replicate n = fromStreamS . S.replicate n
|
||||
replicate n = fromStreamD . D.replicate n
|
||||
|
||||
-- |
|
||||
-- >>> replicateM n = Stream.take n . Stream.repeatM
|
||||
@ -297,7 +291,7 @@ replicateM count =
|
||||
{-# RULES "replicateM serial" replicateM = replicateMSerial #-}
|
||||
{-# INLINE replicateMSerial #-}
|
||||
replicateMSerial :: MonadAsync m => Int -> m a -> SerialT m a
|
||||
replicateMSerial n = fromStreamS . S.replicateM n
|
||||
replicateMSerial n = fromStreamD . D.replicateM n
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Time Enumeration
|
||||
@ -420,7 +414,7 @@ timeout = undefined
|
||||
-- @since 0.6.0
|
||||
{-# INLINE fromIndices #-}
|
||||
fromIndices :: (IsStream t, Monad m) => (Int -> a) -> t m a
|
||||
fromIndices = fromStreamS . S.fromIndices
|
||||
fromIndices = fromStreamD . D.fromIndices
|
||||
|
||||
--
|
||||
-- |
|
||||
@ -441,7 +435,7 @@ fromIndicesM = fromStream . K.fromIndicesMWith (IsStream.toConsK (consM @t))
|
||||
{-# RULES "fromIndicesM serial" fromIndicesM = fromIndicesMSerial #-}
|
||||
{-# INLINE fromIndicesMSerial #-}
|
||||
fromIndicesMSerial :: MonadAsync m => (Int -> m a) -> SerialT m a
|
||||
fromIndicesMSerial = fromStreamS . S.fromIndicesM
|
||||
fromIndicesMSerial = fromStreamD . D.fromIndicesM
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Iterating functions
|
||||
@ -460,7 +454,7 @@ fromIndicesMSerial = fromStreamS . S.fromIndicesM
|
||||
-- @since 0.1.2
|
||||
{-# INLINE_NORMAL iterate #-}
|
||||
iterate :: (IsStream t, Monad m) => (a -> a) -> a -> t m a
|
||||
iterate step = fromStreamS . S.iterate step
|
||||
iterate step = fromStreamD . D.iterate step
|
||||
|
||||
-- |
|
||||
-- >>> iterateM f m = m >>= \a -> return a `Stream.consM` iterateM f (f a)
|
||||
@ -509,7 +503,7 @@ iterateM f = fromStream . K.iterateMWith (IsStream.toConsK (consM @t)) f
|
||||
{-# RULES "iterateM serial" iterateM = iterateMSerial #-}
|
||||
{-# INLINE iterateMSerial #-}
|
||||
iterateMSerial :: MonadAsync m => (a -> m a) -> m a -> SerialT m a
|
||||
iterateMSerial step = fromStreamS . S.iterateM step
|
||||
iterateMSerial step = fromStreamD . D.iterateM step
|
||||
|
||||
-- | We can define cyclic structures using @let@:
|
||||
--
|
||||
|
||||
@ -29,15 +29,10 @@ import Control.Monad.Trans.State.Strict (StateT)
|
||||
import Control.Monad.Trans.Class (MonadTrans(..))
|
||||
import Data.Functor.Identity (Identity (..))
|
||||
import Streamly.Internal.Data.Stream.IsStream.Type
|
||||
(IsStream(..), fromStreamS, toStreamS, fromStreamD, toStreamD)
|
||||
(IsStream(..), fromStreamD, toStreamD)
|
||||
import Streamly.Internal.Data.Stream.Serial (SerialT)
|
||||
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD as D
|
||||
#ifdef USE_STREAMK_ONLY
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK as S
|
||||
#else
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD as S
|
||||
#endif
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Generalize the underlying monad
|
||||
@ -50,7 +45,7 @@ import qualified Streamly.Internal.Data.Stream.StreamD as S
|
||||
{-# INLINE hoist #-}
|
||||
hoist :: (Monad m, Monad n)
|
||||
=> (forall x. m x -> n x) -> SerialT m a -> SerialT n a
|
||||
hoist f xs = fromStreamS $ S.hoist f (toStreamS xs)
|
||||
hoist f xs = fromStreamD $ D.hoist f (toStreamD xs)
|
||||
|
||||
-- | Generalize the inner monad of the stream from 'Identity' to any monad.
|
||||
--
|
||||
@ -58,7 +53,7 @@ hoist f xs = fromStreamS $ S.hoist f (toStreamS xs)
|
||||
--
|
||||
{-# INLINE generally #-}
|
||||
generally :: (IsStream t, Monad m) => t Identity a -> t m a
|
||||
generally xs = fromStreamS $ S.hoist (return . runIdentity) (toStreamS xs)
|
||||
generally xs = fromStreamD $ D.hoist (return . runIdentity) (toStreamD xs)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Add and remove a monad transformer
|
||||
|
||||
@ -247,7 +247,7 @@ import Streamly.Internal.Data.Stream.IsStream.Common
|
||||
)
|
||||
import Streamly.Internal.Control.Concurrent (MonadAsync)
|
||||
import Streamly.Internal.Data.Stream.IsStream.Type
|
||||
(IsStream(..), fromStreamS, toStreamS, fromStreamD, toStreamD, toConsK)
|
||||
(IsStream(..), fromStreamD, toStreamD, toConsK)
|
||||
import Streamly.Internal.Data.Stream.Serial (SerialT)
|
||||
import Streamly.Internal.Data.SVar (Rate(..))
|
||||
import Streamly.Internal.Data.Time.Units (TimeUnit64, AbsTime, RelTime64)
|
||||
@ -257,11 +257,6 @@ import qualified Streamly.Internal.Data.Stream.Parallel as Par
|
||||
import qualified Streamly.Internal.Data.Stream.Serial as Serial
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD as D
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
|
||||
#ifdef USE_STREAMK_ONLY
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK as S
|
||||
#else
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD as S
|
||||
#endif
|
||||
import qualified Prelude
|
||||
|
||||
import Prelude hiding
|
||||
@ -359,7 +354,7 @@ foldrSShared f z xs =
|
||||
{-# INLINE foldrT #-}
|
||||
foldrT :: (IsStream t, Monad m, Monad (s m), MonadTrans s)
|
||||
=> (a -> s m b -> s m b) -> s m b -> t m a -> s m b
|
||||
foldrT f z s = S.foldrT f z (toStreamS s)
|
||||
foldrT f z s = D.foldrT f z (toStreamD s)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Transformation by Mapping
|
||||
@ -681,7 +676,7 @@ postscan fld = fromStreamD . D.postscanOnce fld . toStreamD
|
||||
{-# DEPRECATED scanx "Please use scanl followed by map instead." #-}
|
||||
{-# INLINE scanx #-}
|
||||
scanx :: (IsStream t, Monad m) => (x -> a -> x) -> x -> (x -> b) -> t m a -> t m b
|
||||
scanx step begin done = fromStreamS . S.scanlx' step begin done . toStreamS
|
||||
scanx step begin done = fromStreamD . D.scanlx' step begin done . toStreamD
|
||||
|
||||
-- XXX this needs to be concurrent
|
||||
-- XXX because of the use of D.cons for appending, scanlM' has quadratic
|
||||
@ -760,7 +755,7 @@ scanlM' step begin m = fromStreamD $ D.scanlM' step begin $ toStreamD m
|
||||
-- @since 0.2.0
|
||||
{-# INLINE scanl' #-}
|
||||
scanl' :: (IsStream t, Monad m) => (b -> a -> b) -> b -> t m a -> t m b
|
||||
scanl' step z m = fromStreamS $ S.scanl' step z $ toStreamS m
|
||||
scanl' step z m = fromStreamD $ D.scanl' step z $ toStreamD m
|
||||
|
||||
-- | Like 'scanl'' but does not stream the initial value of the accumulator.
|
||||
--
|
||||
@ -841,7 +836,7 @@ with f comb g = fmap snd . comb g . f
|
||||
-- @since 0.1.0
|
||||
{-# INLINE filter #-}
|
||||
filter :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> t m a
|
||||
filter p m = fromStreamS $ S.filter p $ toStreamS m
|
||||
filter p m = fromStreamD $ D.filter p $ toStreamD m
|
||||
|
||||
-- | Same as 'filter' but with a monadic predicate.
|
||||
--
|
||||
@ -953,7 +948,7 @@ nubBy = undefined -- fromStreamD . D.nubBy . toStreamD
|
||||
-- @since 0.6.0
|
||||
{-# INLINE deleteBy #-}
|
||||
deleteBy :: (IsStream t, Monad m) => (a -> a -> Bool) -> a -> t m a -> t m a
|
||||
deleteBy cmp x m = fromStreamS $ S.deleteBy cmp x (toStreamS m)
|
||||
deleteBy cmp x m = fromStreamD $ D.deleteBy cmp x (toStreamD m)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Lossy Buffering
|
||||
@ -1082,7 +1077,7 @@ takeInterval d = fromStreamD . D.takeByTime d . toStreamD
|
||||
-- @since 0.1.0
|
||||
{-# INLINE dropWhile #-}
|
||||
dropWhile :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> t m a
|
||||
dropWhile p m = fromStreamS $ S.dropWhile p $ toStreamS m
|
||||
dropWhile p m = fromStreamD $ D.dropWhile p $ toStreamD m
|
||||
|
||||
-- | Same as 'dropWhile' but with a monadic predicate.
|
||||
--
|
||||
@ -1171,7 +1166,7 @@ dropWhileAround = undefined -- fromStreamD $ D.dropWhileAround n $ toStreamD m
|
||||
{-# INLINE insertBy #-}
|
||||
insertBy ::
|
||||
(IsStream t, Monad m) => (a -> a -> Ordering) -> a -> t m a -> t m a
|
||||
insertBy cmp x m = fromStreamS $ S.insertBy cmp x (toStreamS m)
|
||||
insertBy cmp x m = fromStreamD $ D.insertBy cmp x (toStreamD m)
|
||||
|
||||
-- | Insert a pure value between successive elements of a stream.
|
||||
--
|
||||
@ -1181,7 +1176,7 @@ insertBy cmp x m = fromStreamS $ S.insertBy cmp x (toStreamS m)
|
||||
-- @since 0.7.0
|
||||
{-# INLINE intersperse #-}
|
||||
intersperse :: (IsStream t, MonadAsync m) => a -> t m a -> t m a
|
||||
intersperse a = fromStreamS . S.intersperse a . toStreamS
|
||||
intersperse a = fromStreamD . D.intersperse a . toStreamD
|
||||
|
||||
-- | Insert a side effect before consuming an element of a stream except the
|
||||
-- first one.
|
||||
@ -1503,7 +1498,7 @@ rollingMap2 f m = fromStreamD $ D.rollingMap2 f $ toStreamD m
|
||||
-- @since 0.3.0
|
||||
{-# INLINE mapMaybe #-}
|
||||
mapMaybe :: (IsStream t, Monad m) => (a -> Maybe b) -> t m a -> t m b
|
||||
mapMaybe f m = fromStreamS $ S.mapMaybe f $ toStreamS m
|
||||
mapMaybe f m = fromStreamD $ D.mapMaybe f $ toStreamD m
|
||||
|
||||
-- | Like 'mapMaybe' but maps a monadic function.
|
||||
--
|
||||
|
||||
@ -17,8 +17,6 @@ module Streamly.Internal.Data.Stream.IsStream.Type
|
||||
, K.Stream (..)
|
||||
|
||||
-- * Type Conversion
|
||||
, fromStreamS
|
||||
, toStreamS
|
||||
, fromStreamD
|
||||
, toStreamD
|
||||
, adapt
|
||||
@ -121,12 +119,6 @@ import qualified Streamly.Internal.Data.Stream.Serial as Serial
|
||||
import qualified Streamly.Internal.Data.Stream.WSerial as WSerial
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD.Type as D
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
|
||||
#ifdef USE_STREAMK_ONLY
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK as S
|
||||
import qualified Streamly.Internal.Data.Stream.StreamK.Type as S
|
||||
#else
|
||||
import qualified Streamly.Internal.Data.Stream.StreamD.Type as S
|
||||
#endif
|
||||
import qualified Streamly.Internal.Data.Stream.Type as Stream
|
||||
import qualified Streamly.Internal.Data.Stream.Zip as Zip
|
||||
import qualified Streamly.Internal.Data.Stream.ZipAsync as ZipAsync
|
||||
@ -230,15 +222,6 @@ toConsK cns x xs = toStream $ x `cns` fromStream xs
|
||||
-- Conversion to and from direct style stream
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
-- These definitions are dependent on what is imported as S
|
||||
{-# INLINE fromStreamS #-}
|
||||
fromStreamS :: (IsStream t, Monad m) => S.Stream m a -> t m a
|
||||
fromStreamS = fromStream . S.toStreamK
|
||||
|
||||
{-# INLINE toStreamS #-}
|
||||
toStreamS :: (IsStream t, Monad m) => t m a -> S.Stream m a
|
||||
toStreamS = S.fromStreamK . toStream
|
||||
|
||||
{-# INLINE toStreamD #-}
|
||||
toStreamD :: (IsStream t, Monad m) => t m a -> D.Stream m a
|
||||
toStreamD = D.fromStreamK . toStream
|
||||
@ -289,16 +272,16 @@ cmpBy f m1 m2 = D.cmpBy f (toStreamD m1) (toStreamD m2)
|
||||
-- @since 0.4.0
|
||||
{-# INLINE_EARLY fromList #-}
|
||||
fromList :: (Monad m, IsStream t) => [a] -> t m a
|
||||
fromList = fromStreamS . S.fromList
|
||||
fromList = fromStreamD . D.fromList
|
||||
{-# RULES "fromList fallback to StreamK" [1]
|
||||
forall a. S.toStreamK (S.fromList a) = K.fromFoldable a #-}
|
||||
forall a. D.toStreamK (D.fromList a) = K.fromFoldable a #-}
|
||||
|
||||
-- | Convert a stream into a list in the underlying monad.
|
||||
--
|
||||
-- @since 0.1.0
|
||||
{-# INLINE toList #-}
|
||||
toList :: (IsStream t, Monad m) => t m a -> m [a]
|
||||
toList m = S.toList $ toStreamS m
|
||||
toList m = D.toList $ toStreamD m
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Building a stream
|
||||
@ -364,7 +347,7 @@ foldrMx step final project m = D.foldrMx step final project $ toStreamD m
|
||||
foldlMx' ::
|
||||
(IsStream t, Monad m)
|
||||
=> (x -> a -> m x) -> m x -> (x -> m b) -> t m a -> m b
|
||||
foldlMx' step begin done m = S.foldlMx' step begin done $ toStreamS m
|
||||
foldlMx' step begin done m = D.foldlMx' step begin done $ toStreamD m
|
||||
|
||||
-- | Strict left fold with an extraction function. Like the standard strict
|
||||
-- left fold, but applies a user supplied extraction function (the third
|
||||
@ -375,7 +358,7 @@ foldlMx' step begin done m = S.foldlMx' step begin done $ toStreamS m
|
||||
{-# INLINE foldlx' #-}
|
||||
foldlx' ::
|
||||
(IsStream t, Monad m) => (x -> a -> x) -> x -> (x -> b) -> t m a -> m b
|
||||
foldlx' step begin done m = S.foldlx' step begin done $ toStreamS m
|
||||
foldlx' step begin done m = D.foldlx' step begin done $ toStreamD m
|
||||
|
||||
-- | Strict left associative fold.
|
||||
--
|
||||
@ -383,12 +366,12 @@ foldlx' step begin done m = S.foldlx' step begin done $ toStreamS m
|
||||
{-# INLINE foldl' #-}
|
||||
foldl' ::
|
||||
(IsStream t, Monad m) => (b -> a -> b) -> b -> t m a -> m b
|
||||
foldl' step begin m = S.foldl' step begin $ toStreamS m
|
||||
foldl' step begin m = D.foldl' step begin $ toStreamD m
|
||||
|
||||
|
||||
{-# INLINE fold #-}
|
||||
fold :: (IsStream t, Monad m) => Fold m a b -> t m a -> m b
|
||||
fold fld m = S.fold fld $ toStreamS m
|
||||
fold fld m = D.fold fld $ toStreamD m
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
-- Folding a stream
|
||||
@ -746,8 +729,8 @@ concatMapFoldableWith f g = Prelude.foldr (f . g) nil
|
||||
-- Equivalent to:
|
||||
--
|
||||
-- @
|
||||
-- concatForFoldableWith f xs g = Prelude.foldr (f . g) S.nil xs
|
||||
-- concatForFoldableWith f = flip (S.concatMapFoldableWith f)
|
||||
-- concatForFoldableWith f xs g = Prelude.foldr (f . g) D.nil xs
|
||||
-- concatForFoldableWith f = flip (D.concatMapFoldableWith f)
|
||||
-- @
|
||||
--
|
||||
-- /Since: 0.8.0 (Renamed forEachWith to concatForFoldableWith)/
|
||||
@ -766,8 +749,8 @@ concatForFoldableWith f = flip (concatMapFoldableWith f)
|
||||
-- Equivalent to:
|
||||
--
|
||||
-- @
|
||||
-- concatFoldableWith f = Prelude.foldr f S.nil
|
||||
-- concatFoldableWith f = S.concatMapFoldableWith f id
|
||||
-- concatFoldableWith f = Prelude.foldr f D.nil
|
||||
-- concatFoldableWith f = D.concatMapFoldableWith f id
|
||||
-- @
|
||||
--
|
||||
-- /Since: 0.8.0 (Renamed foldWith to concatFoldableWith)/
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
--
|
||||
-- {-# INLINE_EARLY unfoldr #-}
|
||||
-- unfoldr :: (Monad m, IsStream t) => (b -> Maybe (a, b)) -> b -> t m a
|
||||
-- unfoldr step seed = fromStreamS (S.unfoldr step seed)
|
||||
-- unfoldr step seed = fromStreamD (S.unfoldr step seed)
|
||||
-- {-# RULES "unfoldr fallback to StreamK" [1]
|
||||
-- forall a b. S.toStreamK (S.unfoldr a b) = K.unfoldr a b #-}```
|
||||
--
|
||||
|
||||
@ -285,11 +285,6 @@ flag has-llvm
|
||||
manual: True
|
||||
default: False
|
||||
|
||||
flag streamk
|
||||
description: Use CPS style streams when possible
|
||||
manual: True
|
||||
default: False
|
||||
|
||||
flag use-c-malloc
|
||||
description: Use C malloc instead of GHC malloc
|
||||
manual: True
|
||||
@ -321,9 +316,6 @@ common compile-options
|
||||
if os(windows)
|
||||
cpp-options: -DCABAL_OS_WINDOWS
|
||||
|
||||
if flag(streamk)
|
||||
cpp-options: -DUSE_STREAMK_ONLY
|
||||
|
||||
if flag(dev)
|
||||
cpp-options: -DDEVBUILD
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user