All Versions
8
Latest Version
Avg Release Cycle
97 days
Latest Release
933 days ago

Changelog History

  • v0.3.1.3 Changes

    May 13, 2019
    • ⬆️ Bump/fix dependencies for:
      • stm
      • hspec
      • lifted-async
  • v0.3.1.2 Changes

    May 23, 2018
    • ⬆️ Bump lifted-async dependency.
  • v0.3.1.1 Changes

    March 23, 2018
    • ⬆️ Bump exceptions dependency.
  • v0.3.1.0 Changes

    March 14, 2018
    • 👍 Allow streaming-0.2.*

    • 👌 Improved performance for withStreamMap and withStreamMapM.

      • Previously used additional Streams within the concurrent buffers which isn't actually needed.
      • A benchmark is available to compare various implementations.
    • Primitives to help defining custom stream-mapping functions are now exported.

  • v0.3.0.1 Changes

    July 07, 2017
    • 👍 Allow streaming-with-0.2.*
  • v0.3.0.0 Changes

    July 05, 2017
    • ✂ Removed support for streaming ByteStrings.

      The ByteString-related functions which were previously implemented are broken conceptually and should not be used.

      A ByteString consists of a stream of bytes; the meaning of each byte is dependent upon its position in the overall stream.

      In terms of implementation, these bytes are accumulated into chunks, each of which may very well be of a different size.

      As such, if such a chunk is fed into a buffer with multiple readers, then there is no guarantee which reader will actually receive it or if it makes sense about what it is in isolation (e.g. it could be split mid-word, or possibly even in the middle of a Unicode character).

      If, however, multiple ByteStrings are fed into a buffer with a single reader, the order it has when coming out is similarly undeterministic: it isn't possible to coherently ensure the sanity of the resulting ByteString.

      As such, unless you really want to consider it as a stream of raw 8-bit numbers, trying to do any concurrency with a ByteString will only lead to trouble. If you do need such functionality, you can implement it yourself using buffers containing Word8 values (in which case you can use Data.ByteString.Streaming.unpack).

    • 🛠 Fix lower bound of lifted-async (replicateConcurrently_ was added in 0.9.3).

  • v0.2.0.0 Changes

    July 05, 2017
    • 📇 Rename functions to match the with... naming scheme:

      • merge{Streams,ByteStrings} to withMerged{Streams,ByteStrings}
      • read{Stream,ByteString}Basket to with{Stream,ByteString}Basket
    • ➕ Add the ability to use buffers to concurrently transform the stream; following functions added:

      • withBufferedTransform
      • withStreamMap
      • withStreamMapM
      • withStreamTransform

      (Note: it is not sound in the general case to transform a streaming ByteString; as such, functions for this are not implemented though it is possible to do yourself.)

  • v0.1.0.0 Changes

    July 04, 2017
    • First version.