Changelog of @haskell/bytestring 0.12.1.0

0.12.1.0 — February 2024

• Provisional support has been added for using bytestring with GHC's JavaScript back-end.
  • This support is relatively un-tested and un-optimised. There may be bugs! Please report any you discover to bytestring's issue tracker.
  • The JavaScript back-end's limited support for the Haskell-C foreign function interface would previously result in many operations failing with errors like ReferenceError: h$fps_count is not defined.
  • The new pure-haskell package flag allows the new fallback Haskell implementations (used to support the JavaScript backend) to be used on most other platforms as well.
• Bug fixes:
  • stimes 0 sbs :: ShortByteString now returns the empty ShortByteString instead of throwing an exception
  • stimes 0 b :: Builder now returns the empty Builder instead of throwing an exception
  • Several alignment-related bug fixes
  • Fix a bug in isValidUtf8
  • sconcat @ShortByteString is no longer terribly inefficient
  • Fix the type on the foreign import used for Data.ByteString.Short.elemIndex
  • Ensure that the result of fromShort is protected by mkDeferredByteString
• Behavior changes:
  • The Data.Data.Data instances for StrictByteString and LazyByteString have been changed:
    • toConstr now returns the a pack pseudo-constructor instead of throwing an exception.
    • Due to this pseudo-constructor, gunfold can now be meaningfully used at these types. (Previously, it would always raise an exception.)
    • These changes allow syb:Data.Generics.Text.gshow to be meaningfully used at types containing ByteStrings.
  • A derived instance Generic ShortByteString has been added.
  • sconcat @Builder is now lazy in the tail of its input
• Deprecations:
  • Data.ByteString.Builder.Prim.Internal.storableToF
• Performance improvements:
  • Various raw-binary Builder primitives like intHost or word32BE are much less inefficient on architectures not known to support unaligned writes. (1, 2)
  • Hexadecimal encoding suffers one indirection fewer
  • Data.ByteString.Lazy.takeEnd is somewhat faster
  • Data.ByteString.Lazy.dropEnd is much faster
• Miscellaneous:
  • Various documentation improvements (1, 2, 3, 4, 5)
  • Eta-expand Data.ByteString.Builder.Internal.empty
    • This can variously help or hurt performance; it undoes the performance changes caused by CLC proposal 132 with ghc-9.8 and restores the baseline performance seen with older GHCs.

0.12.0.2 — August 2023

• Bug fixes:
  • Fix clockid_t-related build failures on some platforms

0.12.0.1 — August 2023

• Bug fixes:
  • Work around a GHC runtime linker issue on i386/PowerPC

0.12.0.0 — July 2023

• Breaking Changes:
  • readInt returns Nothing, if the sequence of digits cannot be represented by an Int, instead of overflowing silently
  • Remove zipWith rewrite rule
  • ShortByteString is now a wrapper around Data.Array.Byte.ByteArray instead of ByteArray# directly
    • As a compatibility measure, SBS remains available as a pattern synonym.
    • The compatibility package data-array-byte is used when base does not provide Data.Array.Byte.
  • fromListN from instance IsList ShortByteString now throws an exception if the first argument does not match the length of the second
    • Previously, it would ignore the first argument entirely.
• Bug fixes:
  • Size-related calculations are more resistant to Int overflow in the following places:
    • Data.ByteString.intercalate
    • stimes @StrictByteString
    • Data.ByteString.Short.concat
    • Data.ByteString.Short.append
    • Data.ByteString.Short.snoc
    • Data.ByteString.Short.cons
• API additions:
  • New sized and/or unsigned variants of readInt and readInteger
  • Data.ByteString.Internal now provides SizeOverflowException, overflowError, and checkedMultiply
• Deprecations:
  • Data.ByteString.getLine: prefer Data.ByteString.Char8.getLine
  • Data.ByteString.hGetLine: prefer Data.ByteString.Char8.hGetLine

0.11.5.3 — October 2023

• Bug fixes:
  • Fix a bug in isValidUtf8

0.11.5.2 — August 2023

• Bug fixes:
  • Fix clockid_t-related build failures on some platforms

0.11.5.1 — August 2023

• Bug fixes:
  • Work around a GHC runtime linker issue on i386/PowerPC

0.11.5.0 — July 2023

• Bug fixes:
  • Fix multiple bugs with ASCII blocks in the SIMD implementations for isValidUtf8
  • Prevent unsound optimizations with the Data.ByteString.Internal.create* family of functions
• API additions:
  • Data.ByteString.Internal now provides mkDeferredByteString and deferForeignPtrAvailability
• Deprecations:
  • Data.ByteString.Internal.memcpy: prefer Foreign.Marshal.Utils.copyBytes
  • Data.ByteString.Internal.memset: prefer Foreign.Marshal.Utils.fillBytes
• Performance improvements:
  • Many functions returning StrictByteString can now return their results unboxed
  • Dead branches removed from Lazy.toStrict
  • Builder.toLazyByteString re-uses under-filled buffers after copying their contents
• Miscellaneous:
  • Minor benchmarking improvements

0.11.4.0 — January 2023

• Bug fixes:
  • Prevent commoning-up of ShortByteString literals produced by TemplateHaskell
  • Make Builder literals demand a sane amount of memory at chunk boundaries
• API additions and behavior changes:
  • Export unsafeIndex for ShortByteString which had been accidentally removed in v0.11.3.0
  • Make Data.ByteString.Lazy.Char8.lines less strict
  • Add NonEmpty variants of inits and tails
• Performance improvements:
  • Speed up unpack and folds for ShortByteString
  • Speed up Builders for non-host endianness
  • Work around upstream keepAlive# performance regressions
  • Improve performance of uncons for LazyByteString
  • Simplify useAsCString
  • Remove redundant comparisons in Data.ByteString.Short.splitAt
• Miscellaneous:
  • Document possible interleaving of hPutStrLn and friends
  • Documentation tweaks
  • Add lower bound for tasty-quickcheck

0.11.3.1 — May 2022

• Windows: Do not link against gcc_s
• Windows: Do not link against gcc when GHC >= 9.4
• Refine CPP for obsolete versions of gcc

0.11.3.0 — February 2022

Erratum: unsafeIndex was accidentally removed from the export list of Data.ByteString.Short.Internal in this release. This was corrected in 0.11.4.0.

• Enhance ShortByteString API
  • Add all, any, append, break, breakEnd, breakSubstring, concat, cons, count, drop, dropEnd, dropWhile, dropWhileEnd, elem, elemIndex, elemIndices, filter, find, findIndex, findIndices, foldl', foldl, foldl1', foldl1, foldr', foldr, foldr1', foldr1, head, init, intercalate, isInfixOf, isPrefixOf, isSuffixOf, last, map, partition, replicate, reverse, singleton, snoc, span, spanEnd, split, splitAt, splitWith, stripPrefix, stripSuffix, tail, take, takeEnd, takeWhile, takeWhileEnd, uncons, unfoldr, unfoldrN, unsnoc to Data.ByteString.Short.
• Add Data.ByteString.Short.isValidUtf8
• Use safe isValidUtf8 for large inputs
• Make unlines lazier
• Improve performance of unlines
• Make singleton return a slice of a static buffer
• Improve performance of intercalate

0.11.2.0 — December 2021

• Add Data.ByteString.isValidUtf8
• Speed up floatDec and doubleDec using the Ryu algorithm
  • Data.ByteString.Builder.RealFloat offers additional custom formatters for floating point numbers.
• Add StrictByteString and LazyByteString type aliases
• Add foldr', foldr1', scanl1, scanr, scanr1 to Data.ByteString.Lazy{,.Char8}
• Add takeEnd, dropEnd, takeWhileEnd, dropWhileEnd, spanEnd, breakEnd to Data.ByteString.Lazy{,.Char8}
• Add Data.ByteString.Builder.writeFile to write Builder to file directly
• Add Data.ByteString.{from,to}FilePath for encoding-aware conversions
• Add Lift instances for all flavors of ByteString
• Add HasCallStack for partial functions
• Define foldl, foldl', foldr, foldr', mapAccumL, mapAccumR, scanl, scanr and filter with one argument less to allow more inlining
• Speed up internal loop in unfoldrN
• Speed up count with SSE and AVX instructions
• Improve performance of certain Builders by using a static table for Base16
• Use unsafeWithForeignPtr whenever possible
• Remove integer-simple flag
• Remove misleading mentions of fusion

0.11.1.0 — February 2021

• Add Data.ByteString.Char8.findIndexEnd and Data.ByteString.Lazy.Char8.{elemIndexEnd,findIndexEnd,unzip}
• Expose ShortByteString constructor from Data.ByteString.Short
• Add compareLength function, which is lazier than comparison of lengths
• Add strict takeEnd and dropEnd
• Expose packZipWith to zip two ByteString
• Add instance Show Builder
• Improve lazy pack to carry fewer arguments in the inner loop
• Improve map, findIndex and findIndexEnd to carry fewer arguments in the inner loop
• Improve lazy {take,drop}While, break and group{,By} to carry fewer arguments in the inner loop
• Speed up intersperse using SSE2 instructions
• fromShort does not reallocate its argument, if it is pinned
• Speed up words using a faster test for spaces
• Implement stimes more efficiently than default definition

0.10.12.1 – January 2021

• Replace withForeignPtr with unsafeWithForeignPtr where appropriate

0.11.0.0 — September 2020

• Change internal representation of ByteString, removing offset
  • The old PS constructor has been turned into a pattern synonym that is available with GHC >= 8.0 for backwards compatibility. Consider adding if !impl(ghc >=8.0) { build-depends: bytestring < 0.11 } to packages, which use PS and still support GHC < 8.0.
• Fill ForeignPtrContents of nullForeignPtr with FinalPtr instead of a bottom
• Remove deprecated functions findSubstring and findSubstrings
• Speed up sorting of short strings
• Improve handling of literal strings in Data.ByteString.Builder
• Compute length at compile time for literal strings
  • This improves optimization opportunities for functions that scrutinize the length of a ByteString.
• Add indexMaybe and synonym (!?) for indexing that returns Maybe
• Add rewrite rules for {take,drop}While ({=,/}= x)
• Add rewrite rules for any (== x) and all (/= x)
• Add rewrite rules for findInd{ex,ices} (== x)
• Improve folds to pass fewer arguments on each recursive invocation
• Improve performance of findIndices
• Re-export Data.ByteString.Lazy.{from,to}Strict from Data.ByteString
• Remove deprecated modules and functions
  • Use Data.ByteString.Builder{,.Extra} instead of Data.ByteString.Lazy.Builder{,.ASCII,.Extras}.
  • Use Data.ByteString.Char8.{,h}putStrLn instead of Data.ByteString.{,h}putStrLn and Data.ByteString.Lazy.Char8.putStrLn instead of Data.ByteString.Char8.putStrLn.
  • Use Data.ByteString.break (== x) instead of Data.ByteString.breakByte x.
  • Use Data.ByteString.Internal.accursedUnutterablePerformIO instead of Data.ByteString.Internal.inlinePerformIO.

0.10.12.0 – August 2020

• Note: There are several breaking changes planned to be included in v0.11. Please ensure that your packages have appropriate upper bounds on bytestring, in order to minimize avoidable breakage.
• Add takeWhileEnd and dropWhileEnd to Data.ByteString and Data.ByteString.Char8, and add dropSpace and strip to Data.ByteString.Char8
• Add findIndexEnd to Data.ByteString and Data.ByteString.Lazy
• Add partition to Data.ByteString.Char8 and Data.ByteString.Lazy.Char8
• Add IsList instances for strict and lazy ByteString and for ShortByteString
• Add createUptoN' and unsafeCreateUptoN' to Data.ByteString.Internal
• Add boundedPrim to Data.ByteString.Builder.Prim.Internal and deprecate boudedPrim
• Deprecate the Data.ByteString.Lazy.Builder and Data.ByteString.Lazy.Builder.{ASCII,Extras} modules
• Fix documented complexity of Data.ByteString.Lazy.length
• Assorted documentation fixes

0.10.10.1 – June 2020

• Fix off-by-one infinite loop in primMapByteStringBounded (#203)
• Don't perform unaligned writes when it isn't known to be safe (#133)
• Improve the performance of sconcat for lazy and strict bytestrings (#142)
• Document inadvertent 0.10.6.0 behaviour change in findSubstrings
• Fix benchmark builds (#52)
• Documentation fixes
• Test fixes

0.10.10.0 July 2019 duncan+haskell@dcoutts.me.uk July 2019

• Build with GHC 8.8, and tests with QC 2.10+
• Add conversions between ShortByteString and CString (#126)
• Documentation fixes (#65, #118, #144, #150, #152, #172)
• Resolve potential copyright issue with test data (#165)

0.10.8.2 Duncan Coutts duncan@community.haskell.org Feb 2017

• Make readFile work for files with no size like /dev/null
• Extend the cases in which concat and toStrict can avoid copying data
• Fix building with ghc-7.0
• Minor documentation improvements
• Internal code cleanups

0.10.8.1 Duncan Coutts duncan@community.haskell.org May 2016

• Fix Builder output on big-endian architectures
• Fix building with ghc-7.6 and older

0.10.8.0 Duncan Coutts duncan@community.haskell.org May 2016

• Use Rabin-Karp substring search for breakSubstring and findSubstring
• Improve the performance of partition for lazy and strict bytestrings
• Added stripPrefix and stripSuffix for lazy and strict bytestrings
• Fix building with ghc 8.0 & base 4.9 (Semigroup etc)

0.10.6.0 Duncan Coutts duncan@community.haskell.org Mar 2015

• Rename inlinePerformIO so people don't misuse it
• Fix a corner case in unfoldrN
• Export isSuffixOf from D.B.Lazy.Char8
• Add D.B.Lazy.elemIndexEnd
• Fix readFile for files with incorrectly reported file size
• Fix for builder performance with ghc 7.10
• Fix building with ghc 6.12

0.10.4.1 Duncan Coutts duncan@community.haskell.org Nov 2014

• Fix integer overflow in concatenation functions
• Fix strictness of lazy bytestring foldl'
• Numerous minor documentation fixes
• Various testsuite improvements