Hello community,
here is the log from the commit of package ghc-text for openSUSE:Factory checked in at 2017-08-31 21:00:23
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-text (Old)
and /work/SRC/openSUSE:Factory/.ghc-text.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-text"
Thu Aug 31 21:00:23 2017 rev:13 rq:513512 version:1.2.2.2
Changes:
--------
--- /work/SRC/openSUSE:Factory/ghc-text/ghc-text.changes 2016-07-21 08:13:11.000000000 +0200
+++ /work/SRC/openSUSE:Factory/.ghc-text.new/ghc-text.changes 2017-08-31 21:00:24.778121789 +0200
@@ -1,0 +2,5 @@
+Thu Jul 27 14:06:08 UTC 2017 - psimons@suse.com
+
+- Update to version 1.2.2.2.
+
+-------------------------------------------------------------------
Old:
----
text-1.2.2.1.tar.gz
New:
----
text-1.2.2.2.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ ghc-text.spec ++++++
--- /var/tmp/diff_new_pack.xGrXXx/_old 2017-08-31 21:00:27.177784630 +0200
+++ /var/tmp/diff_new_pack.xGrXXx/_new 2017-08-31 21:00:27.205780696 +0200
@@ -1,7 +1,7 @@
#
# spec file for package ghc-text
#
-# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany.
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -19,15 +19,14 @@
%global pkg_name text
%bcond_with tests
Name: ghc-%{pkg_name}
-Version: 1.2.2.1
+Version: 1.2.2.2
Release: 0
Summary: An efficient packed Unicode text type
License: BSD-2-Clause
-Group: System/Libraries
+Group: Development/Languages/Other
Url: https://hackage.haskell.org/package/%{pkg_name}
Source0: https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz
BuildRequires: ghc-Cabal-devel
-# Begin cabal-rpm deps:
BuildRequires: ghc-array-devel
BuildRequires: ghc-binary-devel
BuildRequires: ghc-bytestring-devel
@@ -44,7 +43,6 @@
BuildRequires: ghc-test-framework-hunit-devel
BuildRequires: ghc-test-framework-quickcheck2-devel
%endif
-# End cabal-rpm deps
%description
An efficient packed, immutable Unicode text type (both strict and lazy), with a
@@ -86,20 +84,14 @@
%prep
%setup -q -n %{pkg_name}-%{version}
-
%build
%ghc_lib_build
-
%install
%ghc_lib_install
-
%check
-%if %{with tests}
-%{cabal} test
-%endif
-
+%cabal_test
%post devel
%ghc_pkg_recache
++++++ text-1.2.2.1.tar.gz -> text-1.2.2.2.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Array.hs new/text-1.2.2.2/Data/Text/Array.hs
--- old/text-1.2.2.1/Data/Text/Array.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Array.hs 2017-05-21 07:16:35.000000000 +0200
@@ -20,7 +20,7 @@
-- > import qualified Data.Text.Array as A
--
-- The names in this module resemble those in the 'Data.Array' family
--- of modules, but are shorter due to the assumption of qualifid
+-- of modules, but are shorter due to the assumption of qualified
-- naming.
module Data.Text.Array
(
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Encoding.hs new/text-1.2.2.2/Data/Text/Encoding.hs
--- old/text-1.2.2.1/Data/Text/Encoding.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Encoding.hs 2017-05-21 07:16:35.000000000 +0200
@@ -55,13 +55,9 @@
, encodeUtf32LE
, encodeUtf32BE
-#if MIN_VERSION_bytestring(0,10,4)
-- * Encoding Text using ByteString Builders
- -- | /Note/ that these functions are only available if built against
- -- @bytestring >= 0.10.4.0@.
, encodeUtf8Builder
, encodeUtf8BuilderEscaped
-#endif
) where
#if __GLASGOW_HASKELL__ >= 702
@@ -70,24 +66,15 @@
import Control.Monad.ST (unsafeIOToST, unsafeSTToIO)
#endif
-#if MIN_VERSION_bytestring(0,10,4)
-import Data.Bits ((.&.))
-import Data.Text.Internal.Unsafe.Char (ord)
-import qualified Data.ByteString.Builder as B
-import qualified Data.ByteString.Builder.Internal as B hiding (empty, append)
-import qualified Data.ByteString.Builder.Prim as BP
-import qualified Data.ByteString.Builder.Prim.Internal as BP
-import qualified Data.Text.Internal.Encoding.Utf16 as U16
-#endif
-
import Control.Exception (evaluate, try)
import Control.Monad.ST (runST)
+import Data.Bits ((.&.))
import Data.ByteString as B
import Data.ByteString.Internal as B hiding (c2w)
import Data.Text.Encoding.Error (OnDecodeError, UnicodeException, strictDecode)
import Data.Text.Internal (Text(..), safe, text)
import Data.Text.Internal.Private (runText)
-import Data.Text.Internal.Unsafe.Char (unsafeWrite)
+import Data.Text.Internal.Unsafe.Char (ord, unsafeWrite)
import Data.Text.Internal.Unsafe.Shift (shiftR)
import Data.Text.Show ()
import Data.Text.Unsafe (unsafeDupablePerformIO)
@@ -98,8 +85,13 @@
import Foreign.Ptr (Ptr, minusPtr, nullPtr, plusPtr)
import Foreign.Storable (Storable, peek, poke)
import GHC.Base (ByteArray#, MutableByteArray#)
+import qualified Data.ByteString.Builder as B
+import qualified Data.ByteString.Builder.Internal as B hiding (empty, append)
+import qualified Data.ByteString.Builder.Prim as BP
+import qualified Data.ByteString.Builder.Prim.Internal as BP
import qualified Data.Text.Array as A
import qualified Data.Text.Internal.Encoding.Fusion as E
+import qualified Data.Text.Internal.Encoding.Utf16 as U16
import qualified Data.Text.Internal.Fusion as F
#include "text_cbits.h"
@@ -315,8 +307,6 @@
decodeUtf8' = unsafeDupablePerformIO . try . evaluate . decodeUtf8With strictDecode
{-# INLINE decodeUtf8' #-}
-#if MIN_VERSION_bytestring(0,10,4)
-
-- | Encode text to a ByteString 'B.Builder' using UTF-8 encoding.
encodeUtf8Builder :: Text -> B.Builder
encodeUtf8Builder = encodeUtf8BuilderEscaped (BP.liftFixedToBounded BP.word8)
@@ -377,7 +367,6 @@
outerLoop i (B.BufferRange op ope)
where
poke8 j v = poke (op `plusPtr` j) (fromIntegral v :: Word8)
-#endif
-- | Encode text using UTF-8 encoding.
encodeUtf8 :: Text -> ByteString
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Foreign.hs new/text-1.2.2.2/Data/Text/Foreign.hs
--- old/text-1.2.2.1/Data/Text/Foreign.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Foreign.hs 2017-05-21 07:16:35.000000000 +0200
@@ -108,7 +108,7 @@
| n >= len || m >= len = t
| otherwise = Text arr off m
where
- m | w < 0xDB00 || w > 0xD8FF = n
+ m | w < 0xD800 || w > 0xDBFF = n
| otherwise = n+1
w = A.unsafeIndex arr (off+n-1)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Internal/Builder/Int/Digits.hs new/text-1.2.2.2/Data/Text/Internal/Builder/Int/Digits.hs
--- old/text-1.2.2.1/Data/Text/Internal/Builder/Int/Digits.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Internal/Builder/Int/Digits.hs 2017-05-21 07:16:35.000000000 +0200
@@ -2,7 +2,7 @@
-- Module: Data.Text.Internal.Builder.Int.Digits
-- Copyright: (c) 2013 Bryan O'Sullivan
--- License: BSD3
+-- License: BSD-style
-- Maintainer: Bryan O'Sullivan
-- Stability: experimental
-- Portability: portable
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Internal/Builder.hs new/text-1.2.2.2/Data/Text/Internal/Builder.hs
--- old/text-1.2.2.1/Data/Text/Internal/Builder.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Internal/Builder.hs 2017-05-21 07:16:35.000000000 +0200
@@ -6,7 +6,7 @@
-- Module : Data.Text.Internal.Builder
-- Copyright : (c) 2013 Bryan O'Sullivan
-- (c) 2010 Johan Tibell
--- License : BSD3-style (see LICENSE)
+-- License : BSD-style (see LICENSE)
--
-- Maintainer : Johan Tibell
-- Stability : experimental
@@ -242,6 +242,8 @@
!t = Text arr o u
ts <- inlineInterleaveST (k b)
return $! t : ts
+{-# INLINE [1] flush #-}
+-- defer inlining so that flush/flush rule may fire.
------------------------------------------------------------------------
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Internal/Fusion/Common.hs new/text-1.2.2.2/Data/Text/Internal/Fusion/Common.hs
--- old/text-1.2.2.1/Data/Text/Internal/Fusion/Common.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Internal/Fusion/Common.hs 2017-05-21 07:16:35.000000000 +0200
@@ -107,7 +107,7 @@
import qualified Data.List as L
import qualified Prelude as P
import Data.Bits (shiftL)
-import Data.Char (isLetter)
+import Data.Char (isLetter, isSpace)
import Data.Int (Int64)
import Data.Text.Internal.Fusion.Types
import Data.Text.Internal.Fusion.CaseMapping (foldMapping, lowerMapping, titleMapping,
@@ -462,15 +462,16 @@
where
next (CC (letter :*: s) '\0' _) =
case next0 s of
- Done -> Done
- Skip s' -> Skip (CC (letter :*: s') '\0' '\0')
+ Done -> Done
+ Skip s' -> Skip (CC (letter :*: s') '\0' '\0')
Yield c s'
- | letter' -> if letter
- then lowerMapping c (letter' :*: s')
- else titleMapping c (letter' :*: s')
- | otherwise -> Yield c (CC (letter' :*: s') '\0' '\0')
- where letter' = isLetter c
- next (CC s a b) = Yield a (CC s b '\0')
+ | nonSpace -> if letter
+ then lowerMapping c (nonSpace :*: s')
+ else titleMapping c (letter' :*: s')
+ | otherwise -> Yield c (CC (letter' :*: s') '\0' '\0')
+ where nonSpace = P.not (isSpace c)
+ letter' = isLetter c
+ next (CC s a b) = Yield a (CC s b '\0')
{-# INLINE [0] toTitle #-}
data Justify i s = Just1 !i !s
@@ -669,12 +670,12 @@
-- ** Generating and unfolding streams
replicateCharI :: Integral a => a -> Char -> Stream Char
-replicateCharI n c
+replicateCharI !n !c
| n < 0 = empty
| otherwise = Stream next 0 (fromIntegral n) -- HINT maybe too low
where
- next i | i >= n = Done
- | otherwise = Yield c (i + 1)
+ next !i | i >= n = Done
+ | otherwise = Yield c (i + 1)
{-# INLINE [0] replicateCharI #-}
data RI s = RI !s {-# UNPACK #-} !Int64
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Internal/Fusion.hs new/text-1.2.2.2/Data/Text/Internal/Fusion.hs
--- old/text-1.2.2.1/Data/Text/Internal/Fusion.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Internal/Fusion.hs 2017-05-21 07:16:35.000000000 +0200
@@ -98,25 +98,35 @@
-- | /O(n)/ Convert a 'Stream Char' into a 'Text'.
unstream :: Stream Char -> Text
unstream (Stream next0 s0 len) = runText $ \done -> do
- let mlen = upperBound 4 len
+ -- Before encoding each char we perform a buffer realloc check assuming
+ -- worst case encoding size of two 16-bit units for the char. Just add an
+ -- extra space to the buffer so that we do not end up reallocating even when
+ -- all the chars are encoded as single unit.
+ let mlen = upperBound 4 len + 1
arr0 <- A.new mlen
- let outer arr top = loop
+ let outer !arr !maxi = encode
where
- loop !s !i =
- case next0 s of
- Done -> done arr i
- Skip s' -> loop s' i
- Yield x s'
- | j >= top -> {-# SCC "unstream/resize" #-} do
- let top' = (top + 1) `shiftL` 1
- arr' <- A.new top'
- A.copyM arr' 0 arr 0 top
- outer arr' top' s i
- | otherwise -> do d <- unsafeWrite arr i x
- loop s' (i+d)
- where j | ord x < 0x10000 = i
- | otherwise = i + 1
- outer arr0 mlen s0 0
+ -- keep the common case loop as small as possible
+ encode !si !di =
+ case next0 si of
+ Done -> done arr di
+ Skip si' -> encode si' di
+ Yield c si'
+ -- simply check for the worst case
+ | maxi < di + 1 -> realloc si di
+ | otherwise -> do
+ n <- unsafeWrite arr di c
+ encode si' (di + n)
+
+ -- keep uncommon case separate from the common case code
+ {-# NOINLINE realloc #-}
+ realloc !si !di = do
+ let newlen = (maxi + 1) * 2
+ arr' <- A.new newlen
+ A.copyM arr' 0 arr 0 di
+ outer arr' (newlen - 1) si di
+
+ outer arr0 (mlen - 1) s0 0
{-# INLINE [0] unstream #-}
{-# RULES "STREAM stream/unstream fusion" forall s. stream (unstream s) = s #-}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Lazy/Builder/Int.hs new/text-1.2.2.2/Data/Text/Lazy/Builder/Int.hs
--- old/text-1.2.2.1/Data/Text/Lazy/Builder/Int.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Lazy/Builder/Int.hs 2017-05-21 07:16:35.000000000 +0200
@@ -7,7 +7,7 @@
-- Module: Data.Text.Lazy.Builder.Int
-- Copyright: (c) 2013 Bryan O'Sullivan
-- (c) 2011 MailRank, Inc.
--- License: BSD3
+-- License: BSD-style
-- Maintainer: Bryan O'Sullivan
-- Stability: experimental
-- Portability: portable
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Lazy/Builder.hs new/text-1.2.2.2/Data/Text/Lazy/Builder.hs
--- old/text-1.2.2.1/Data/Text/Lazy/Builder.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Lazy/Builder.hs 2017-05-21 07:16:35.000000000 +0200
@@ -8,7 +8,7 @@
-- Module : Data.Text.Lazy.Builder
-- Copyright : (c) 2013 Bryan O'Sullivan
-- (c) 2010 Johan Tibell
--- License : BSD3-style (see LICENSE)
+-- License : BSD-style (see LICENSE)
--
-- Maintainer : Johan Tibell
-- Stability : experimental
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Lazy/Encoding.hs new/text-1.2.2.2/Data/Text/Lazy/Encoding.hs
--- old/text-1.2.2.1/Data/Text/Lazy/Encoding.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Lazy/Encoding.hs 2017-05-21 07:16:35.000000000 +0200
@@ -46,27 +46,23 @@
, encodeUtf32LE
, encodeUtf32BE
-#if MIN_VERSION_bytestring(0,10,4)
-- * Encoding Text using ByteString Builders
, encodeUtf8Builder
, encodeUtf8BuilderEscaped
-#endif
) where
import Control.Exception (evaluate, try)
+import Data.Monoid (Monoid(..))
import Data.Text.Encoding.Error (OnDecodeError, UnicodeException, strictDecode)
import Data.Text.Internal.Lazy (Text(..), chunk, empty, foldrChunks)
-import qualified Data.ByteString as S
-import qualified Data.ByteString.Lazy as B
-import qualified Data.ByteString.Lazy.Internal as B
-import qualified Data.ByteString.Unsafe as B
-#if MIN_VERSION_bytestring(0,10,4)
import Data.Word (Word8)
-import Data.Monoid (Monoid(..))
+import qualified Data.ByteString as S
import qualified Data.ByteString.Builder as B
import qualified Data.ByteString.Builder.Extra as B (safeStrategy, toLazyByteStringWith)
import qualified Data.ByteString.Builder.Prim as BP
-#endif
+import qualified Data.ByteString.Lazy as B
+import qualified Data.ByteString.Lazy.Internal as B
+import qualified Data.ByteString.Unsafe as B
import qualified Data.Text as T
import qualified Data.Text.Encoding as TE
import qualified Data.Text.Internal.Lazy.Encoding.Fusion as E
@@ -146,7 +142,6 @@
{-# INLINE decodeUtf8' #-}
encodeUtf8 :: Text -> B.ByteString
-#if MIN_VERSION_bytestring(0,10,4)
encodeUtf8 Empty = B.empty
encodeUtf8 lt@(Chunk t _) =
B.toLazyByteStringWith strategy B.empty $ encodeUtf8Builder lt
@@ -168,11 +163,6 @@
encodeUtf8BuilderEscaped prim =
foldrChunks (\c b -> TE.encodeUtf8BuilderEscaped prim c `mappend` b) mempty
-#else
-encodeUtf8 (Chunk c cs) = B.Chunk (TE.encodeUtf8 c) (encodeUtf8 cs)
-encodeUtf8 Empty = B.Empty
-#endif
-
-- | Decode text from little endian UTF-16 encoding.
decodeUtf16LEWith :: OnDecodeError -> B.ByteString -> Text
decodeUtf16LEWith onErr bs = F.unstream (E.streamUtf16LE onErr bs)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Lazy/Read.hs new/text-1.2.2.2/Data/Text/Lazy/Read.hs
--- old/text-1.2.2.1/Data/Text/Lazy/Read.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Lazy/Read.hs 2017-05-21 07:16:35.000000000 +0200
@@ -68,9 +68,9 @@
go n d = (n * 10 + fromIntegral (digitToInt d))
-- | Read a hexadecimal integer, consisting of an optional leading
--- @\"0x\"@ followed by at least one decimal digit. Input is consumed
--- until a non-hex-digit or end of string is reached. This function
--- is case insensitive.
+-- @\"0x\"@ followed by at least one hexadecimal digit. Input is
+-- consumed until a non-hex-digit or end of string is reached.
+-- This function is case insensitive.
--
-- This function does not handle leading sign characters. If you need
-- to handle signed input, use @'signed' 'hexadecimal'@.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Lazy.hs new/text-1.2.2.2/Data/Text/Lazy.hs
--- old/text-1.2.2.1/Data/Text/Lazy.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Lazy.hs 2017-05-21 07:16:35.000000000 +0200
@@ -545,7 +545,7 @@
unstream (S.tail (stream t)) = tail t
#-}
--- | /O(1)/ Returns all but the last character of a 'Text', which must
+-- | /O(n\/c)/ Returns all but the last character of a 'Text', which must
-- be non-empty. Subject to fusion.
init :: Text -> Text
init (Chunk t0 ts0) = go t0 ts0
@@ -581,7 +581,7 @@
isSingleton = S.isSingleton . stream
{-# INLINE isSingleton #-}
--- | /O(1)/ Returns the last character of a 'Text', which must be
+-- | /O(n\/c)/ Returns the last character of a 'Text', which must be
-- non-empty. Subject to fusion.
last :: Text -> Char
last Empty = emptyError "last"
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text/Read.hs new/text-1.2.2.2/Data/Text/Read.hs
--- old/text-1.2.2.1/Data/Text/Read.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text/Read.hs 2017-05-21 07:16:35.000000000 +0200
@@ -67,9 +67,9 @@
go n d = (n * 10 + fromIntegral (digitToInt d))
-- | Read a hexadecimal integer, consisting of an optional leading
--- @\"0x\"@ followed by at least one decimal digit. Input is consumed
--- until a non-hex-digit or end of string is reached. This function
--- is case insensitive.
+-- @\"0x\"@ followed by at least one hexadecimal digit. Input is
+-- consumed until a non-hex-digit or end of string is reached.
+-- This function is case insensitive.
--
-- This function does not handle leading sign characters. If you need
-- to handle signed input, use @'signed' 'hexadecimal'@.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/Data/Text.hs new/text-1.2.2.2/Data/Text.hs
--- old/text-1.2.2.1/Data/Text.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/Data/Text.hs 2017-05-21 07:16:35.000000000 +0200
@@ -238,6 +238,7 @@
import qualified Data.Text.Lazy as L
import Data.Int (Int64)
#endif
+import GHC.Base (eqInt, neInt, gtInt, geInt, ltInt, leInt)
#if __GLASGOW_HASKELL__ >= 708
import qualified GHC.Exts as Exts
#endif
@@ -571,7 +572,9 @@
-- Subject to fusion.
length :: Text -> Int
length t = S.length (stream t)
-{-# INLINE length #-}
+{-# INLINE [0] length #-}
+-- length needs to be phased after the compareN/length rules otherwise
+-- it may inline before the rules have an opportunity to fire.
-- | /O(n)/ Compare the count of characters in a 'Text' to a number.
-- Subject to fusion.
@@ -590,32 +593,32 @@
{-# RULES
"TEXT ==N/length -> compareLength/==EQ" [~1] forall t n.
- (==) (length t) n = compareLength t n == EQ
+ eqInt (length t) n = compareLength t n == EQ
#-}
{-# RULES
"TEXT /=N/length -> compareLength//=EQ" [~1] forall t n.
- (/=) (length t) n = compareLength t n /= EQ
+ neInt (length t) n = compareLength t n /= EQ
#-}
{-# RULES
"TEXT compareLength/==LT" [~1] forall t n.
- (<) (length t) n = compareLength t n == LT
+ ltInt (length t) n = compareLength t n == LT
#-}
{-# RULES
"TEXT <=N/length -> compareLength//=GT" [~1] forall t n.
- (<=) (length t) n = compareLength t n /= GT
+ leInt (length t) n = compareLength t n /= GT
#-}
{-# RULES
"TEXT >N/length -> compareLength/==GT" [~1] forall t n.
- (>) (length t) n = compareLength t n == GT
+ gtInt (length t) n = compareLength t n == GT
#-}
{-# RULES
"TEXT >=N/length -> compareLength//=LT" [~1] forall t n.
- (>=) (length t) n = compareLength t n /= LT
+ geInt (length t) n = compareLength t n /= LT
#-}
-- -----------------------------------------------------------------------------
@@ -1096,8 +1099,8 @@
iterNEnd :: Int -> Text -> Int
iterNEnd n t@(Text _arr _off len) = loop (len-1) n
where loop i !m
+ | m <= 0 = i+1
| i <= 0 = 0
- | m <= 1 = i
| otherwise = loop (i+d) (m-1)
where d = reverseIter_ t i
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/benchmarks/haskell/Benchmarks/Stream.hs new/text-1.2.2.2/benchmarks/haskell/Benchmarks/Stream.hs
--- old/text-1.2.2.1/benchmarks/haskell/Benchmarks/Stream.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/benchmarks/haskell/Benchmarks/Stream.hs 2017-05-21 07:16:35.000000000 +0200
@@ -18,11 +18,11 @@
import qualified Data.Text.Encoding.Error as E
import qualified Data.Text.Internal.Encoding.Fusion as T
import qualified Data.Text.Internal.Encoding.Fusion.Common as F
-import qualified Data.Text.Internal.Fusion as T
+import qualified Data.Text.Internal.Fusion as F
import qualified Data.Text.IO as T
import qualified Data.Text.Lazy.Encoding as TL
import qualified Data.Text.Internal.Lazy.Encoding.Fusion as TL
-import qualified Data.Text.Internal.Lazy.Fusion as TL
+import qualified Data.Text.Internal.Lazy.Fusion as FL
import qualified Data.Text.Lazy.IO as TL
instance NFData a => NFData (Stream a) where
@@ -53,14 +53,25 @@
!utf32beL = TL.encodeUtf32BE tl
-- For the functions which operate on streams
- let !s = T.stream t
+ let !s = F.stream t
return $ bgroup "Stream"
-- Fusion
[ bgroup "stream" $
- [ bench "Text" $ nf T.stream t
- , bench "LazyText" $ nf TL.stream tl
+ [ bench "Text" $ nf F.stream t
+ , bench "LazyText" $ nf FL.stream tl
+ ]
+ -- must perform exactly the same as stream above due to
+ -- stream/unstream (i.e. stream after unstream) fusion
+ , bgroup "stream-fusion" $
+ [ bench "Text" $ nf (F.stream . F.unstream . F.stream) t
+ , bench "LazyText" $ nf (FL.stream . FL.unstream . FL.stream) tl
+ ]
+ -- measure the overhead of unstream after stream
+ , bgroup "stream-unstream" $
+ [ bench "Text" $ nf (F.unstream . F.stream) t
+ , bench "LazyText" $ nf (FL.unstream . FL.stream) tl
]
-- Encoding.Fusion
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/benchmarks/haskell/Benchmarks.hs new/text-1.2.2.2/benchmarks/haskell/Benchmarks.hs
--- old/text-1.2.2.1/benchmarks/haskell/Benchmarks.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/benchmarks/haskell/Benchmarks.hs 2017-05-21 07:16:35.000000000 +0200
@@ -53,7 +53,7 @@
, Mul.benchmark
, Pure.benchmark "tiny" (tf "tiny.txt")
, Pure.benchmark "ascii" (tf "ascii-small.txt")
- , Pure.benchmark "france" (tf "france.html")
+ -- , Pure.benchmark "france" (tf "france.html")
, Pure.benchmark "russian" (tf "russian-small.txt")
, Pure.benchmark "japanese" (tf "japanese.txt")
, ReadNumbers.benchmark (tf "numbers.txt")
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/benchmarks/text-benchmarks.cabal new/text-1.2.2.2/benchmarks/text-benchmarks.cabal
--- old/text-1.2.2.1/benchmarks/text-benchmarks.cabal 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/benchmarks/text-benchmarks.cabal 2017-05-21 07:16:35.000000000 +0200
@@ -3,7 +3,7 @@
synopsis: Benchmarks for the text package
description: Benchmarks for the text package
homepage: https://bitbucket.org/bos/text
-license: BSD3
+license: BSD2
license-file: ../LICENSE
author: Jasper Van der Jeugt ,
Bryan O'Sullivan ,
@@ -15,6 +15,11 @@
cabal-version: >=1.2
+flag bytestring-builder
+ description: Depend on the bytestring-builder package for backwards compatibility.
+ default: False
+ manual: False
+
flag llvm
description: use LLVM
default: False
@@ -33,7 +38,6 @@
build-depends: base == 4.*,
binary,
blaze-builder,
- bytestring,
bytestring-lexing >= 0.5.0,
containers,
criterion >= 0.10.0.0,
@@ -46,6 +50,12 @@
utf8-string,
vector
+ if flag(bytestring-builder)
+ build-depends: bytestring >= 0.9 && < 0.10.4,
+ bytestring-builder >= 0.10.4
+ else
+ build-depends: bytestring >= 0.10.4
+
executable text-multilang
hs-source-dirs: haskell
main-is: Multilang.hs
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/changelog.md new/text-1.2.2.2/changelog.md
--- old/text-1.2.2.1/changelog.md 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/changelog.md 2017-05-21 07:16:35.000000000 +0200
@@ -1,10 +1,27 @@
+1.2.2.2
+
+* The `toTitle` function now correctly handles letters that
+ immediately follow punctuation. Before, `"there's"` would turn into
+ `"There'S"`. Now, it becomes `"There's"`.
+
+* The implementation of unstreaming is faster, resulting in operations
+ such as `map` and `intersperse` speeding up by up to 30%, with
+ smaller code generated.
+
+* The optimised length comparison function is now more likely to be
+ used after some rewrite rule tweaking.
+
+* Bug fix: an off-by-one bug in `takeEnd` is fixed.
+
+* Bug fix: a logic error in `takeWord16` is fixed.
+
1.2.2.1
* The switch to `integer-pure` in 1.2.2.0 was apparently mistaken.
The build flag has been renamed accordingly. Your army of diligent
maintainers apologizes for the churn.
-* Spec compliance: toCaseFold now follows the Unicode 8.0 spec
+* Spec compliance: `toCaseFold` now follows the Unicode 8.0 spec
(updated from 7.0)
* An STG lint error has been fixed
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/tests/Tests/Properties.hs new/text-1.2.2.2/tests/Tests/Properties.hs
--- old/text-1.2.2.1/tests/Tests/Properties.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/tests/Tests/Properties.hs 2017-05-21 07:16:36.000000000 +0200
@@ -11,7 +11,7 @@
import Control.Applicative ((<$>), (<*>))
import Control.Arrow ((***), second)
import Data.Bits ((.&.))
-import Data.Char (chr, isDigit, isHexDigit, isLower, isSpace, isUpper, ord)
+import Data.Char (chr, isDigit, isHexDigit, isLower, isSpace, isLetter, isUpper, ord)
import Data.Int (Int8, Int16, Int32, Int64)
import Data.Monoid (Monoid(..))
import Data.String (IsString(fromString))
@@ -23,6 +23,7 @@
import Data.Text.Lazy.Read as TL
import Data.Text.Read as T
import Data.Word (Word, Word8, Word16, Word32, Word64)
+import Data.Maybe (mapMaybe)
import Numeric (showEFloat, showFFloat, showGFloat, showHex)
import Prelude hiding (replicate)
import Test.Framework (Test, testGroup)
@@ -37,6 +38,7 @@
import qualified Data.Bits as Bits (shiftL, shiftR)
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as BL
+import qualified Data.Char as C
import qualified Data.List as L
import qualified Data.Text as T
import qualified Data.Text.Encoding as E
@@ -60,10 +62,10 @@
tl_pack_unpack = (TL.unpack . TL.pack) `eq` id
t_stream_unstream = (S.unstream . S.stream) `eq` id
tl_stream_unstream = (SL.unstream . SL.stream) `eq` id
-t_reverse_stream t = (S.reverse . S.reverseStream) t == t
-t_singleton c = [c] == (T.unpack . T.singleton) c
-tl_singleton c = [c] == (TL.unpack . TL.singleton) c
-tl_unstreamChunks x = f 11 x == f 1000 x
+t_reverse_stream t = (S.reverse . S.reverseStream) t === t
+t_singleton c = [c] === (T.unpack . T.singleton) c
+tl_singleton c = [c] === (TL.unpack . TL.singleton) c
+tl_unstreamChunks x = f 11 x === f 1000 x
where f n = SL.unstreamChunks n . S.streamList
tl_chunk_unchunk = (TL.fromChunks . TL.toChunks) `eq` id
tl_from_to_strict = (TL.fromStrict . TL.toStrict) `eq` id
@@ -74,13 +76,13 @@
encodeLazyL1 :: TL.Text -> BL.ByteString
encodeLazyL1 = BL.fromChunks . map encodeL1 . TL.toChunks
-t_ascii t = E.decodeASCII (E.encodeUtf8 a) == a
+t_ascii t = E.decodeASCII (E.encodeUtf8 a) === a
where a = T.map (\c -> chr (ord c `mod` 128)) t
-tl_ascii t = EL.decodeASCII (EL.encodeUtf8 a) == a
+tl_ascii t = EL.decodeASCII (EL.encodeUtf8 a) === a
where a = TL.map (\c -> chr (ord c `mod` 128)) t
-t_latin1 t = E.decodeLatin1 (encodeL1 a) == a
+t_latin1 t = E.decodeLatin1 (encodeL1 a) === a
where a = T.map (\c -> chr (ord c `mod` 256)) t
-tl_latin1 t = EL.decodeLatin1 (encodeLazyL1 a) == a
+tl_latin1 t = EL.decodeLatin1 (encodeLazyL1 a) === a
where a = TL.map (\c -> chr (ord c `mod` 256)) t
t_utf8 = forAll genUnicode $ (E.decodeUtf8 . E.encodeUtf8) `eq` id
t_utf8' = forAll genUnicode $ (E.decodeUtf8' . E.encodeUtf8) `eq` (id . Right)
@@ -111,7 +113,7 @@
let b = E.encodeUtf8 t
ls = concatMap (leftover . E.encodeUtf8 . T.singleton) . T.unpack $ t
leftover = (++ [B.empty]) . init . tail . B.inits
- in (map snd . feedChunksOf 1 E.streamDecodeUtf8) b == ls
+ in (map snd . feedChunksOf 1 E.streamDecodeUtf8) b === ls
data Badness = Solo | Leading | Trailing
deriving (Eq, Show)
@@ -201,8 +203,8 @@
mconcat `eq` (unpackS . mconcat . L.map T.pack)
tl_mconcat = unsquare $
mconcat `eq` (unpackS . mconcat . L.map TL.pack)
-t_mempty = mempty == (unpackS (mempty :: T.Text))
-tl_mempty = mempty == (unpackS (mempty :: TL.Text))
+t_mempty = mempty === (unpackS (mempty :: T.Text))
+tl_mempty = mempty === (unpackS (mempty :: TL.Text))
t_IsString = fromString `eqP` (T.unpack . fromString)
tl_IsString = fromString `eqP` (TL.unpack . fromString)
@@ -326,6 +328,19 @@
where p = T.length . T.filter isUpper
tl_toUpper_upper t = p (TL.toUpper t) >= p t
where p = TL.length . TL.filter isUpper
+t_toTitle_title t = all (<= 1) (caps w)
+ where caps = fmap (T.length . T.filter isUpper) . T.words . T.toTitle
+ -- TIL: there exist uppercase-only letters
+ w = T.filter (\c -> if C.isUpper c then C.toLower c /= c else True) t
+t_toTitle_1stNotLower = and . notLow . T.toTitle . T.filter stable
+ where notLow = mapMaybe (fmap (not . isLower) . (T.find isLetter)) . T.words
+ -- Surprise! The Spanish/Portuguese ordinal indicators changed
+ -- from category Ll (letter, lowercase) to Lo (letter, other)
+ -- in Unicode 7.0
+ -- Oh, and there exist lowercase-only letters (see previous test)
+ stable c = if isLower c
+ then C.toUpper c /= c
+ else c /= '\170' && c /= '\186'
justifyLeft k c xs = xs ++ L.replicate (k - length xs) c
justifyRight m n xs = L.replicate (m - length xs) n ++ xs
@@ -720,7 +735,7 @@
conc = T.concat . TL.toChunks
t_indices_occurs = unsquare $ \(NotEmpty t) ts ->
let s = T.intercalate t ts
- in Slow.indices t s == indices t s
+ in Slow.indices t s === indices t s
-- Bit shifts.
shiftL w = forAll (choose (0,width-1)) $ \k -> Bits.shiftL w k == U.shiftL w k
@@ -812,18 +827,18 @@
-- Reading.
t_decimal (n::Int) s =
- T.signed T.decimal (T.pack (show n) `T.append` t) == Right (n,t)
+ T.signed T.decimal (T.pack (show n) `T.append` t) === Right (n,t)
where t = T.dropWhile isDigit s
tl_decimal (n::Int) s =
- TL.signed TL.decimal (TL.pack (show n) `TL.append` t) == Right (n,t)
+ TL.signed TL.decimal (TL.pack (show n) `TL.append` t) === Right (n,t)
where t = TL.dropWhile isDigit s
t_hexadecimal m s ox =
- T.hexadecimal (T.concat [p, T.pack (showHex n ""), t]) == Right (n,t)
+ T.hexadecimal (T.concat [p, T.pack (showHex n ""), t]) === Right (n,t)
where t = T.dropWhile isHexDigit s
p = if ox then "0x" else ""
n = getPositive m :: Int
tl_hexadecimal m s ox =
- TL.hexadecimal (TL.concat [p, TL.pack (showHex n ""), t]) == Right (n,t)
+ TL.hexadecimal (TL.concat [p, TL.pack (showHex n ""), t]) === Right (n,t)
where t = TL.dropWhile isHexDigit s
p = if ox then "0x" else ""
n = getPositive m :: Int
@@ -867,11 +882,11 @@
t_dropWord16 m t = dropWord16 m t `T.isSuffixOf` t
t_takeWord16 m t = takeWord16 m t `T.isPrefixOf` t
-t_take_drop_16 m t = T.append (takeWord16 n t) (dropWord16 n t) == t
+t_take_drop_16 m t = T.append (takeWord16 n t) (dropWord16 n t) === t
where n = small m
t_use_from t = monadicIO $ assert . (==t) =<< run (useAsPtr t fromPtr)
-t_copy t = T.copy t == t
+t_copy t = T.copy t === t
-- Regression tests.
s_filter_eq s = S.filter p t == S.streamList (filter p s)
@@ -1030,7 +1045,9 @@
testProperty "tl_toLower_lower" tl_toLower_lower,
testProperty "t_toUpper_length" t_toUpper_length,
testProperty "t_toUpper_upper" t_toUpper_upper,
- testProperty "tl_toUpper_upper" tl_toUpper_upper
+ testProperty "tl_toUpper_upper" tl_toUpper_upper,
+ testProperty "t_toTitle_title" t_toTitle_title,
+ testProperty "t_toTitle_1stNotLower" t_toTitle_1stNotLower
],
testGroup "justification" [
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/tests/Tests/QuickCheckUtils.hs new/text-1.2.2.2/tests/Tests/QuickCheckUtils.hs
--- old/text-1.2.2.1/tests/Tests/QuickCheckUtils.hs 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/tests/Tests/QuickCheckUtils.hs 2017-05-21 07:16:36.000000000 +0200
@@ -106,7 +106,7 @@
where smallish = round . (sqrt :: Double -> Double) . fromIntegral . abs
instance Arbitrary T.Text where
- arbitrary = T.pack `fmap` arbitrary
+ arbitrary = T.pack `fmap` string
shrink = map T.pack . shrink . T.unpack
instance Arbitrary TL.Text where
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/tests/text-tests.cabal new/text-1.2.2.2/tests/text-tests.cabal
--- old/text-1.2.2.1/tests/text-tests.cabal 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/tests/text-tests.cabal 2017-05-21 07:16:36.000000000 +0200
@@ -3,7 +3,7 @@
synopsis: Functional tests for the text package
description: Functional tests for the text package
homepage: https://github.com/bos/text
-license: BSD3
+license: BSD2
license-file: ../LICENSE
author: Jasper Van der Jeugt ,
Bryan O'Sullivan ,
@@ -20,6 +20,11 @@
default: False
manual: True
+flag bytestring-builder
+ description: Depend on the bytestring-builder package for backwards compatibility.
+ default: False
+ manual: False
+
executable text-tests
main-is: Tests.hs
@@ -48,16 +53,21 @@
HUnit >= 1.2,
QuickCheck >= 2.7,
base == 4.*,
- bytestring,
deepseq,
directory,
- quickcheck-unicode,
+ quickcheck-unicode >= 1.0.1.0,
random,
test-framework >= 0.4,
test-framework-hunit >= 0.2,
test-framework-quickcheck2 >= 0.2,
text-tests
+ if flag(bytestring-builder)
+ build-depends: bytestring >= 0.9 && < 0.10.4,
+ bytestring-builder >= 0.10.4
+ else
+ build-depends: bytestring >= 0.10.4
+
executable text-tests-stdio
main-is: Tests/IO.hs
@@ -137,7 +147,12 @@
array,
base == 4.*,
binary,
- bytestring,
deepseq,
ghc-prim,
integer-gmp
+
+ if flag(bytestring-builder)
+ build-depends: bytestring >= 0.9 && < 0.10.4,
+ bytestring-builder >= 0.10.4
+ else
+ build-depends: bytestring >= 0.10.4
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/text-1.2.2.1/text.cabal new/text-1.2.2.2/text.cabal
--- old/text-1.2.2.1/text.cabal 2016-03-17 18:53:39.000000000 +0100
+++ new/text-1.2.2.2/text.cabal 2017-05-21 07:16:35.000000000 +0200
@@ -1,5 +1,5 @@
name: text
-version: 1.2.2.1
+version: 1.2.2.2
homepage: https://github.com/bos/text
bug-reports: https://github.com/bos/text/issues
synopsis: An efficient packed Unicode text type.
@@ -31,7 +31,7 @@
the @text-icu@ package:
http://hackage.haskell.org/package/text-icu
-license: BSD3
+license: BSD2
license-file: LICENSE
author: Bryan O'Sullivan
maintainer: Bryan O'Sullivan
@@ -64,6 +64,11 @@
tests/scripts/*.sh
tests/text-tests.cabal
+flag bytestring-builder
+ description: Depend on the bytestring-builder package for backwards compatibility.
+ default: False
+ manual: False
+
flag developer
description: operate in developer mode
default: False
@@ -133,10 +138,11 @@
deepseq >= 1.1.0.0,
ghc-prim >= 0.2
- if impl(ghc >= 7.7)
- build-depends: bytestring >= 0.10.4.0
+ if flag(bytestring-builder)
+ build-depends: bytestring >= 0.9 && < 0.10.4,
+ bytestring-builder >= 0.10.4
else
- build-depends: bytestring >= 0.9
+ build-depends: bytestring >= 0.10.4
cpp-options: -DHAVE_DEEPSEQ
ghc-options: -Wall -fwarn-tabs -funbox-strict-fields -O2
@@ -171,16 +177,21 @@
array,
base,
binary,
- bytestring,
deepseq,
directory,
ghc-prim,
- quickcheck-unicode,
+ quickcheck-unicode >= 1.0.1.0,
random,
test-framework >= 0.4,
test-framework-hunit >= 0.2,
test-framework-quickcheck2 >= 0.2
+ if flag(bytestring-builder)
+ build-depends: bytestring >= 0.9 && < 0.10.4,
+ bytestring-builder >= 0.10.4
+ else
+ build-depends: bytestring >= 0.10.4
+
if flag(integer-simple)
cpp-options: -DINTEGER_SIMPLE
build-depends: integer-simple >= 0.1 && < 0.5