git.iko.soy/streamly
on master help sign in
Add a detailed API change log
commitfa7da7bf8b1a5d37e0f56e945dbc9d0e093440d3 authorHarendra Kumar <harendra@composewell.com> dateFri 4 Jun 2021, 18:31 (5 years ago) parent8757194
3 files changed+298−127
compare with master
unifiedsplit
Changelog.md+47−127 docs/API-changelog.txt+250 streamly.cabal+1
Changelog.md+47−127
@@ -1,130 +1,62 @@
1−## Unreleased
1+# Changelog
22
3−### Breaking behavior changes
4−
5−* `Streamly.Prelude.fold` may now terminate early without consuming the entire
6− stream. For example, `fold Fold.head stream` would now terminate immediately
7− after consuming the head element from `stream`. This may result in change of
8− behavior in existing programs if the program relies on the evaluation of the
9− full stream.
10−* Change the associativity of combinators `serial`, `wSerial`,
11− `ahead`, `async`, `wAsync`, `parallel` to be the same as `<>`.
12−* `encodeUtf8`, `decodeUtf8` now replace any invalid character encountered
13− during encoding/decoding with the Unicode replacement character. Use
14− `encodeUtf8'`, `decodeUtf8'` to recover the previous functionality.
15−* `encodeLatin1` now silently truncates any character beyond 255 to incorrect
16− characters in the input stream. Use `encodeLatin1'` to recover previous
17− functionality.
18−
19−### Breaking type changes
20−
21−* Change the signature of `foldlM'` to make the initial value of the
22− accumulator monadic.
23−* Change the signature of `scanlM'`, `postscanlM'` to make the initial value of
24− the accumulator monadic.
25−* Change the signature of `concatMapWith` to ensure that it can be
26− used with a wide variety of combining functions.
27−* Exception handling functions `bracket`, `handle`, `finally` now
28− require an additional `MonadAsync` constraint. Several other
29− functions that used these functions also now require the additional
30− constraint.
31−
32−Removed `Applicative` instance of folds. Please use `teeWith` or the `Tee`
33−type as an alternative to Fold applicative.
34−
35−To upgrade, the following code:
36−
37−```
38− avg = (/) <$> Fold.sum <*> Fold.length
39−```
40−
41−can be changed to:
42−
43−```
44− import Streamly.Internal.Data.Fold.Tee (Tee(..))
45− import qualified Streamly.Internal.Data.Fold.Tee as Tee
46− avg = Tee.toFold $ (/) <$> Tee Fold.sum <*> Tee Fold.length
47−```
48−
49−or alternatively to:
50−
51−```
52− avg = Fold.teeWith (/) Fold.sum Fold.length
53−```
3+<!-- See rendered changelog at https://streamly.composewell.com -->
544
55−### Enhancements
5+## Unreleased
566
57−New modules:
7+See [API Changelog](docs/API-changelog.txt) for a complete list of signature
8+changes and new APIs introduced.
589
59−* `Streamly.Console.Stdio`
60−* `Streamly.Data.Fold.Tee`
10+### Breaking changes
6111
62−New APIs:
63−
64−* `Streamly.Data.Fold`: Many APIs added.
65−* `Streamly.Data.Unfold`: Many APIs added.
66−* `Streamly.Prelude`:
67− * delay
68− * foldMany
69− * intercalate
70− * intercalateSuffix
71− * liftInner
72− * runReaderT
73− * runStateT
74− * unfoldMany
75−* `Streamly.Unicode.Stream`:
76− * encodeUtf8'
77− * encodeLatin1'
78− * decodeUtf8'
79−* `Streamly.Network.Socket`:
80− * readChunk
81− * writeChunk
82− * writeChunksWithBufferOf
83− * forSocketM
12+* `Streamly.Prelude`
13+ * `fold`: this function may now terminate early without consuming
14+ the entire stream. For example, `fold Fold.head stream` would
15+ now terminate immediately after consuming the head element from
16+ `stream`. This may result in change of behavior in existing programs
17+ if the program relies on the evaluation of the full stream.
18+* `Streamly.Data.Unicode.Stream`
19+ * The following APIs no longer throw errors on invalid input, use new
20+ APIs suffixed with a prime for strict behavior:
21+ * decodeUtf8
22+ * encodeLatin1
23+ * encodeUtf8
24+* `Streamly.Data.Fold`:
25+ * Several instances have been moved to the `Streamly.Data.Fold.Tee`
26+ module, please use the `Tee` type to adapt to the changes.
8427
8528### Bug Fixes
8629
87−* The monadic state for the stream is now propagated across threads. Please
88− refer to [#369](https://github.com/composewell/streamly/issues/369) for
89− more info.
90−* `accept*` and `connect` APIs in `Streamly.Network.Inet.TCP` and the `accept`
91− API in `Streamly.Network.Socket` now close the socket if an exception is
30+* Concurrent Streams: The monadic state for the stream is now propagated across
31+ threads. Please refer to
32+ [#369](https://github.com/composewell/streamly/issues/369) for more info.
33+* `Streamly.Prelude`:
34+ * `bracket`, `handle`, and `finally` now also work correctly on streams
35+ that aren't fully drained. Also, the resource acquisition and release is
36+ atomic with respect to async exceptions.
37+ * `iterate`, `iterateM` now consume O(1) space instead of O(n).
38+ * `fromFoldableM` is fixed to be concurrent.
39+* `Streamly.Network.Inet.TCP`: `accept` and `connect` APIs now close the socket
40+ if an exception is thrown.
41+* `Streamly.Network.Socket`: `accept` now closes the socket if an exception is
9242 thrown.
93−* `bracket`, `handle`, and `finally` now work on streams that aren't
94− fully drained. Also, the resource acquisition and release is atomic with
95− respect to async exceptions.
96−* Fix a performance issue in `Streamly.Prelude.iterate/iterateM` that caused it
97− to consume O(n) space.
98−
99−### Deprecations
10043
101−Modules renamed:
102−
103−* `Streamly` => `Streamly.Prelude`
104−* `Streamly.Data.Unicode.Stream` => `Streamly.Unicode.Stream`
105−* `Streamly.Memory.Array` => `Streamly.Data.Array.Foreign`
106−
107−APIs renamed:
108−
109−* In `Streamly.Prelude` module (formerly in `Streamly` module):
110− * `foldWith` => `concatFoldableWith`
111− * `foldMapWith` => `concatMapFoldableWith`
112− * `forEachWith` => `concatForFoldableWith`
113− * `serially` => `fromSerial` and so on
114−* In `Streamly.Prelude`:
115− * `concatUnfold` => `unfoldMany`
116− * `yield` => `fromPure`
117− * `yieldM` => `fromEffect`
118−* In `Streamly.Unicode.Stream` (formerly `Streamly.Data.Unicode.Stream`):
119− * `encodeUtf8Lax` => `encodeUtf8`
120− * `encodeLatin1Lax` => `encodeLatin1`
121− * `decodeUtf8Lenient` => `decodeUtf8`
122−* In `Streamly.Data.Fold`:
123− * `mapM` => `rmapM`
44+### Enhancements
12445
125−APIs deprecated:
46+* See [API Changelog](docs/API-changelog.txt) for a complete list of new
47+ modules and APIs introduced.
48+* The Fold type is now more powerful, the new termination behavior allows
49+ to express basic parsing of streams using folds.
50+* Many new Fold and Unfold APIs are added.
51+* A new module for console IO APIs is added.
52+* Experimental modules for the following are added:
53+ * Parsing
54+ * Deserialization
55+ * File system event handling (fsnotify/inotify)
56+ * Folds for streams of arrays
57+* Experimental `use-c-malloc` build flag to use the c library `malloc` for
58+ array allocations. This could be useful to avoid pinned memory fragmentation.
12659
127−* In `Streamly.Data.Fold`, `sequence`: Please use `rmapM id` instead.
12860
12961### Notable Internal/Pre-release API Changes
13062
@@ -134,18 +66,6 @@ Breaking changes:
13466* Rename: `Streamly.Internal.Prelude` => `Streamly.Internal.Data.Stream.IsStream`
13567* Several other internal modules have been renamed and re-factored.
13668
137−New modules:
138−
139−* `Streamly.Internal.Data.Parser`: parser combinators
140−* `Streamly.Internal.Data.Binary.Decode`: decode Haskell values from binary data.
141−* `Streamly.Internal.FileSystem.Event.*`: fsnotify/inotify
142−* `Streamly.Internal.Data.Array.Stream.Fold.Foreign`: array stream folds
143−
144−New features:
145−
146−* `use-c-malloc` build flag to use the c library `malloc` for array
147− allocations. This could be useful to avoid pinned memory fragmentation.
148−
14969Bug fixes:
15070
15171* A bug was fixed in the conversion of `MicroSecond64` and `MilliSecond64`
docs/API-changelog.txtnew file+250
@@ -0,0 +1,250 @@
1+# Release 0.8.0 vs release 0.7.3
2+# API diff generated by cabal-diff with some edits.
3+# ~~~ deprecated module
4+# ~~ deprecated symbol
5+
6+# Deprecated, merged into Streamly.Prelude
7+~~~ Streamly
8+# Fixity changes
9+++ infixr 6 `ahead`
10+++ infixr 6 `async`
11+++ infixr 6 `parallel`
12+++ infixr 6 `serial`
13+++ infixr 6 `wAsync`
14+++ infixr 6 `wSerial`
15+
16+# Added
17+@@@ Streamly.Console.Stdio
18+
19+# Deprecated, renamed
20+~~~ Streamly.Memory.Array
21+@@@ Streamly.Data.Array.Foreign
22+
23+# Moved from Streamly.Memory.Array
24+++ data Array a
25+++ fromList :: Storable a => [a] -> Array a
26+++ fromListN :: Storable a => Int -> [a] -> Array a
27+++ length :: forall a. Storable a => Array a -> Int
28+++ read :: forall m a. (Monad m, Storable a) => Unfold m (Array a) a
29+++ toList :: Storable a => Array a -> [a]
30+++ write :: forall m a. (MonadIO m, Storable a) => Fold m a (Array a)
31+++ writeN :: forall m a. (MonadIO m, Storable a) => Int -> Fold m a (Array a)
32+
33+# Added
34+++ asBytes :: Array a -> Array Word8
35+++ cast :: forall a b. Storable b => Array a -> Maybe (Array b)
36+++ getIndex :: Storable a => Array a -> Int -> Maybe a
37+++ readRev :: forall m a. (Monad m, Storable a) => Unfold m (Array a) a
38+++ writeLastN :: (Storable a, MonadIO m) => Int -> Fold m a (Array a)
39+
40+@@@ Streamly.Data.Fold
41+# Signature changed
42+ - product :: (Monad m, Num a) => Fold m a a
43+ + product :: (Monad m, Num a, Eq a) => Fold m a a
44+
45+# Removed (Moved to the Streamly.Data.Fold.Tee module)
46+-- instance (Monad m, Floating b) => Floating (Fold m a b)
47+-- instance (Monad m, GHC.Num.Num b) => GHC.Num.Num (Fold m a b)
48+-- instance (Monad m, GHC.Real.Fractional b) => GHC.Real.Fractional (Fold m a b)
49+-- instance (Semigroup b, Monad m) => Semigroup (Fold m a b)
50+-- instance (Semigroup b, Monoid b, Monad m) => Monoid (Fold m a b)
51+-- instance Applicative m => Applicative (Fold m a)
52+
53+# Renamed
54+~~ mapM :: Monad m => (b -> m c) -> Fold m a b -> Fold m a c
55+++ rmapM :: Monad m => (b -> m c) -> Fold m a b -> Fold m a c
56+
57+# Deprecated
58+~~ sequence :: Monad m => Fold m a (m b) -> Fold m a b
59+
60+# Added
61+++ catMaybes :: Monad m => Fold m a b -> Fold m (Maybe a) b
62+++ chunksOf :: Monad m => Int -> Fold m a b -> Fold m b c -> Fold m a c
63+++ concatMap :: Monad m => (b -> Fold m a c) -> Fold m a b -> Fold m a c
64+++ filter :: Monad m => (a -> Bool) -> Fold m a r -> Fold m a r
65+++ filterM :: Monad m => (a -> m Bool) -> Fold m a r -> Fold m a r
66+++ foldl' :: Monad m => (b -> a -> b) -> b -> Fold m a b
67+++ foldlM' :: Monad m => (b -> a -> m b) -> m b -> Fold m a b
68+++ foldr :: Monad m => (a -> b -> b) -> b -> Fold m a b
69+++ lmap :: (a -> b) -> Fold m b r -> Fold m a r
70+++ lmapM :: Monad m => (a -> m b) -> Fold m b r -> Fold m a r
71+++ many :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
72+++ mapMaybe :: Monad m => (a -> Maybe b) -> Fold m b r -> Fold m a r
73+++ rollingHash :: (Monad m, Enum a) => Fold m a Int64
74+++ rollingHashWithSalt :: (Monad m, Enum a) => Int64 -> Fold m a Int64
75+++ sconcat :: (Monad m, Semigroup a) => a -> Fold m a a
76+++ serialWith :: Monad m => (a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
77+++ take :: Monad m => Int -> Fold m a b -> Fold m a b
78+++ takeEndBy :: Monad m => (a -> Bool) -> Fold m a b -> Fold m a b
79+++ takeEndBy_ :: Monad m => (a -> Bool) -> Fold m a b -> Fold m a b
80+++ teeWith :: Monad m => (a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
81+++ toListRev :: Monad m => Fold m a [a]
82+
83+# Added
84+@@@ Streamly.Data.Fold.Tee
85+
86+@@@ Streamly.Data.Unfold
87+# Added
88+++ crossWith :: Monad m => (b -> c -> d) -> Unfold m a b -> Unfold m a c -> Unfold m a d
89+++ drop :: Monad m => Int -> Unfold m a b -> Unfold m a b
90+++ dropWhile :: Monad m => (b -> Bool) -> Unfold m a b -> Unfold m a b
91+++ dropWhileM :: Monad m => (b -> m Bool) -> Unfold m a b -> Unfold m a b
92+++ filter :: Monad m => (b -> Bool) -> Unfold m a b -> Unfold m a b
93+++ filterM :: Monad m => (b -> m Bool) -> Unfold m a b -> Unfold m a b
94+++ fromList :: Monad m => Unfold m [a] a
95+++ fromListM :: Monad m => Unfold m [m a] a
96+++ fromStream :: (IsStream t, Monad m) => Unfold m (t m a) a
97+++ function :: Applicative m => (a -> b) -> Unfold m a b
98+++ functionM :: Applicative m => (a -> m b) -> Unfold m a b
99+++ iterateM :: Monad m => (a -> m a) -> Unfold m (m a) a
100+++ lmap :: (a -> c) -> Unfold m c b -> Unfold m a b
101+++ lmapM :: Monad m => (a -> m c) -> Unfold m c b -> Unfold m a b
102+++ many :: Monad m => Unfold m a b -> Unfold m b c -> Unfold m a c
103+++ mapM :: Monad m => (b -> m c) -> Unfold m a b -> Unfold m a c
104+++ repeatM :: Monad m => Unfold m (m a) a
105+++ replicateM :: Monad m => Int -> Unfold m (m a) a
106+++ take :: Monad m => Int -> Unfold m a b -> Unfold m a b
107+++ takeWhile :: Monad m => (b -> Bool) -> Unfold m a b -> Unfold m a b
108+++ takeWhileM :: Monad m => (b -> m Bool) -> Unfold m a b -> Unfold m a b
109+++ unfoldr :: Applicative m => (a -> Maybe (b, a)) -> Unfold m a b
110+++ unfoldrM :: Applicative m => (a -> m (Maybe (b, a))) -> Unfold m a b
111+++ zipWith :: Monad m => (b -> c -> d) -> Unfold m a b -> Unfold m a c -> Unfold m a d
112+
113+# Deprecated, renamed to Streamly.Unicode.Stream
114+~~~ Streamly.Data.Unicode.Stream
115+
116+@@@ Streamly.Network.Socket
117+# Added
118+++ forSocketM :: (MonadMask m, MonadIO m) => (Socket -> m ()) -> Socket -> m ()
119+++ readChunk :: Int -> Socket -> IO (Array Word8)
120+++ writeChunk :: Storable a => Socket -> Array a -> IO ()
121+++ writeChunksWithBufferOf :: (MonadIO m, Storable a) => Int -> Socket -> Fold m (Array a) ()
122+
123+@@@ Streamly.Prelude
124+# Signature changed
125+ - after :: (IsStream t, Monad m) => m b -> t m a -> t m a
126+ + after :: (IsStream t, MonadIO m, MonadBaseControl IO m) => m b -> t m a -> t m a
127+ - bracket :: (IsStream t, MonadCatch m) => m b -> (b -> m c) -> (b -> t m a) -> t m a
128+ + bracket :: (IsStream t, MonadAsync m, MonadCatch m) => m b -> (b -> m c) -> (b -> t m a) -> t m a
129+ - concatMapWith :: IsStream t => (forall c. t m c -> t m c -> t m c) -> (a -> t m b) -> t m a -> t m b
130+ + concatMapWith :: IsStream t => (t m b -> t m b -> t m b) -> (a -> t m b) -> t m a -> t m b
131+ - finally :: (IsStream t, MonadCatch m) => m b -> t m a -> t m a
132+ + finally :: (IsStream t, MonadAsync m, MonadCatch m) => m b -> t m a -> t m a
133+ - foldlM' :: Monad m => (b -> a -> m b) -> b -> SerialT m a -> m b
134+ + foldlM' :: Monad m => (b -> a -> m b) -> m b -> SerialT m a -> m b
135+ - postscanlM' :: (IsStream t, Monad m) => (b -> a -> m b) -> b -> t m a -> t m b
136+ + postscanlM' :: (IsStream t, Monad m) => (b -> a -> m b) -> m b -> t m a -> t m b
137+ - scanlM' :: (IsStream t, Monad m) => (b -> a -> m b) -> b -> t m a -> t m b
138+ + scanlM' :: (IsStream t, Monad m) => (b -> a -> m b) -> m b -> t m a -> t m b
139+
140+# Renamed
141+~~ yieldM :: (Monad m, IsStream t) => m a -> t m a
142+++ fromEffect :: (Monad m, IsStream t) => m a -> t m a
143+~~ yield :: IsStream t => a -> t m a
144+++ fromPure :: IsStream t => a -> t m a
145+~~ concatUnfold :: (IsStream t, Monad m) => Unfold m a b -> t m a -> t m b
146+++ unfoldMany :: (IsStream t, Monad m) => Unfold m a b -> t m a -> t m b
147+
148+# Moved from "Streamly" module
149+## Fixity change
150+++ infixr 6 `ahead`
151+++ infixr 6 `async`
152+++ infixr 6 `parallel`
153+++ infixr 6 `serial`
154+++ infixr 6 `wAsync`
155+++ infixr 6 `wSerial`
156+## Renamed
157+~~ foldWith :: (IsStream t, Foldable f) => (t m a -> t m a -> t m a) -> f (t m a) -> t m a
158+++ concatFoldableWith :: (IsStream t, Foldable f) => (t m a -> t m a -> t m a) -> f (t m a) -> t m a
159+~~ forEachWith :: (IsStream t, Foldable f) => (t m b -> t m b -> t m b) -> f a -> (a -> t m b) -> t m b
160+++ concatForFoldableWith :: (IsStream t, Foldable f) => (t m b -> t m b -> t m b) -> f a -> (a -> t m b) -> t m b
161+~~ foldMapWith :: (IsStream t, Foldable f) => (t m b -> t m b -> t m b) -> (a -> t m b) -> f a -> t m b
162+++ concatMapFoldableWith :: (IsStream t, Foldable f) => (t m b -> t m b -> t m b) -> (a -> t m b) -> f a -> t m b
163+~~ aheadly :: IsStream t => AheadT m a -> t m a
164+++ fromAhead :: IsStream t => AheadT m a -> t m a
165+~~ asyncly :: IsStream t => AsyncT m a -> t m a
166+++ fromAsync :: IsStream t => AsyncT m a -> t m a
167+~~ parallely :: IsStream t => ParallelT m a -> t m a
168+++ fromParallel :: IsStream t => ParallelT m a -> t m a
169+~~ serially :: IsStream t => SerialT m a -> t m a
170+++ fromSerial :: IsStream t => SerialT m a -> t m a
171+~~ wAsyncly :: IsStream t => WAsyncT m a -> t m a
172+++ fromWAsync :: IsStream t => WAsyncT m a -> t m a
173+~~ wSerially :: IsStream t => WSerialT m a -> t m a
174+++ fromWSerial :: IsStream t => WSerialT m a -> t m a
175+~~ zipAsyncly :: IsStream t => ZipAsyncM m a -> t m a
176+++ fromZipAsync :: IsStream t => ZipAsyncM m a -> t m a
177+~~ zipSerially :: IsStream t => ZipSerialM m a -> t m a
178+++ fromZipSerial :: IsStream t => ZipSerialM m a -> t m a
179+## unchanged
180+++ class (forall m a. MonadAsync m => Semigroup (t m a), forall m a. MonadAsync m => Monoid (t m a), forall m. Monad m => Functor (t m), forall m. MonadAsync m => Applicative (t m)) => IsStream t
181+++ data AheadT m a
182+++ data AsyncT m a
183+++ data ParallelT m a
184+++ data Rate Rate :: Double -> Double -> Double -> Int -> Rate
185+++ data SerialT m a
186+++ data WAsyncT m a
187+++ data WSerialT m a
188+++ data ZipAsyncM m a
189+++ data ZipSerialM m a
190+++ type Ahead = AheadT IO
191+++ type Async = AsyncT IO
192+++ type MonadAsync m = (MonadIO m, MonadBaseControl IO m, MonadThrow m)
193+++ type Parallel = ParallelT IO
194+++ type Serial = SerialT IO
195+++ type WAsync = WAsyncT IO
196+++ type WSerial = WSerialT IO
197+++ type ZipAsync = ZipAsyncM IO
198+++ type ZipSerial = ZipSerialM IO
199+++ (|$) :: (IsStream t, MonadAsync m) => (t m a -> t m b) -> t m a -> t m b
200+++ (|$.) :: (IsStream t, MonadAsync m) => (t m a -> m b) -> t m a -> m b
201+++ (|&) :: (IsStream t, MonadAsync m) => t m a -> (t m a -> t m b) -> t m b
202+++ (|&.) :: (IsStream t, MonadAsync m) => t m a -> (t m a -> m b) -> m b
203+++ [rateBuffer] :: Rate -> Int
204+++ [rateGoal] :: Rate -> Double
205+++ [rateHigh] :: Rate -> Double
206+++ [rateLow] :: Rate -> Double
207+++ adapt :: (IsStream t1, IsStream t2) => t1 m a -> t2 m a
208+++ ahead :: (IsStream t, MonadAsync m) => t m a -> t m a -> t m a
209+++ async :: (IsStream t, MonadAsync m) => t m a -> t m a -> t m a
210+++ avgRate :: IsStream t => Double -> t m a -> t m a
211+++ constRate :: IsStream t => Double -> t m a -> t m a
212+++ maxBuffer :: IsStream t => Int -> t m a -> t m a
213+++ maxRate :: IsStream t => Double -> t m a -> t m a
214+++ maxThreads :: IsStream t => Int -> t m a -> t m a
215+++ minRate :: IsStream t => Double -> t m a -> t m a
216+++ mkAsync :: (IsStream t, MonadAsync m) => t m a -> t m a
217+++ parallel :: (IsStream t, MonadAsync m) => t m a -> t m a -> t m a
218+++ rate :: IsStream t => Maybe Rate -> t m a -> t m a
219+++ serial :: IsStream t => t m a -> t m a -> t m a
220+++ wAsync :: (IsStream t, MonadAsync m) => t m a -> t m a -> t m a
221+++ wSerial :: IsStream t => t m a -> t m a -> t m a
222+
223+# Added
224+++ delay :: (IsStream t, MonadIO m) => Double -> t m a -> t m a
225+++ foldMany :: (IsStream t, Monad m) => Fold m a b -> t m a -> t m b
226+++ intercalate :: (IsStream t, Monad m) => Unfold m b c -> b -> t m b -> t m c
227+++ intercalateSuffix :: (IsStream t, Monad m) => Unfold m b c -> b -> t m b -> t m c
228+++ liftInner :: (Monad m, IsStream t, MonadTrans tr, Monad (tr m)) => t m a -> t (tr m) a
229+++ runReaderT :: (IsStream t, Monad m) => m s -> t (ReaderT s m) a -> t m a
230+++ runStateT :: Monad m => m s -> SerialT (StateT s m) a -> SerialT m (s, a)
231+
232+# Removed: documentation moved to streamly-docs module in docs dir
233+@@@ Streamly.Tutorial
234+
235+# Deprecated, renamed
236+~~~ Streamly.Data.Unicode.Stream
237+@@@ Streamly.Unicode.Stream
238+# Moved from Streamly.Data.Unicode.Stream
239+## Behavior changed
240+++ decodeUtf8 :: (Monad m, IsStream t) => t m Word8 -> t m Char
241+++ encodeLatin1 :: (IsStream t, Monad m) => t m Char -> t m Word8
242+++ encodeUtf8 :: (Monad m, IsStream t) => t m Char -> t m Word8
243+## Unchanged
244+++ decodeLatin1 :: (IsStream t, Monad m) => t m Word8 -> t m Char
245+
246+# Added
247+++ decodeUtf8' :: (Monad m, IsStream t) => t m Word8 -> t m Char
248+++ encodeLatin1' :: (IsStream t, Monad m) => t m Char -> t m Word8
249+++ encodeStrings :: (MonadIO m, IsStream t) => (SerialT m Char -> SerialT m Word8) -> t m String -> t m (Array Word8)
250+++ encodeUtf8' :: (Monad m, IsStream t) => t m Char -> t m Word8
streamly.cabal+1
@@ -106,6 +106,7 @@ extra-source-files:
106106 docs/*.md
107107 docs/*.hs
108108 docs/*.svg
109+ docs/API-changelog.txt
109110 docs/streamly-docs.cabal
110111 examples/README.md
111112 src/Streamly/Internal/Data/Stream/Instances.hs