master..54e45df · text

Data/Text.hs+7−10

since splitsnapshots

unifiedsplit

@@ -238,7 +238,6 @@ import Data.ByteString (ByteString)

238import qualified Data.Text.Lazy as L

239import Data.Int (Int64)

240#endif

241−import GHC.Base (eqInt, neInt, gtInt, geInt, ltInt, leInt)

242#if __GLASGOW_HASKELL__ >= 708

241#if __GLASGOW_HASKELL__ >= 708

243import qualified GHC.Exts as Exts

242import qualified GHC.Exts as Exts

244#endif

243#endif

@@ -572,9 +571,7 @@ isSingleton = S.isSingleton . stream

572-- Subject to fusion.

571-- Subject to fusion.

573length :: Text -> Int

572length :: Text -> Int

574length t = S.length (stream t)

573length t = S.length (stream t)

575−{-# INLINE [0] length #-}

574+{-# INLINE length #-}

576−-- length needs to be phased after the compareN/length rules otherwise

577−-- it may inline before the rules have an opportunity to fire.

578

575

579-- | /O(n)/ Compare the count of characters in a 'Text' to a number.

576-- | /O(n)/ Compare the count of characters in a 'Text' to a number.

580-- Subject to fusion.

577-- Subject to fusion.

@@ -593,32 +590,32 @@ compareLength t n = S.compareLengthI (stream t) n

593

590

594{-# RULES

591{-# RULES

595"TEXT ==N/length -> compareLength/==EQ" [~1] forall t n.

592"TEXT ==N/length -> compareLength/==EQ" [~1] forall t n.

596− eqInt (length t) n = compareLength t n == EQ

593+ (==) (length t) n = compareLength t n == EQ

597 #-}

594 #-}

598

595

599{-# RULES

596{-# RULES

600"TEXT /=N/length -> compareLength//=EQ" [~1] forall t n.

597"TEXT /=N/length -> compareLength//=EQ" [~1] forall t n.

601− neInt (length t) n = compareLength t n /= EQ

598+ (/=) (length t) n = compareLength t n /= EQ

602 #-}

599 #-}

603

600

604{-# RULES

601{-# RULES

605"TEXT <N/length -> compareLength/==LT" [~1] forall t n.

602"TEXT <N/length -> compareLength/==LT" [~1] forall t n.

606− ltInt (length t) n = compareLength t n == LT

603+ (<) (length t) n = compareLength t n == LT

607 #-}

604 #-}

608

605

609{-# RULES

606{-# RULES

610"TEXT <=N/length -> compareLength//=GT" [~1] forall t n.

607"TEXT <=N/length -> compareLength//=GT" [~1] forall t n.

611− leInt (length t) n = compareLength t n /= GT

608+ (<=) (length t) n = compareLength t n /= GT

612 #-}

609 #-}

613

610

614{-# RULES

611{-# RULES

615"TEXT >N/length -> compareLength/==GT" [~1] forall t n.

612"TEXT >N/length -> compareLength/==GT" [~1] forall t n.

616− gtInt (length t) n = compareLength t n == GT

613+ (>) (length t) n = compareLength t n == GT

617 #-}

614 #-}

618

615

619{-# RULES

616{-# RULES

620"TEXT >=N/length -> compareLength//=LT" [~1] forall t n.

617"TEXT >=N/length -> compareLength//=LT" [~1] forall t n.

621− geInt (length t) n = compareLength t n /= LT

618+ (>=) (length t) n = compareLength t n /= LT

622 #-}

619 #-}

623

620

624-- -----------------------------------------------------------------------------

621-- -----------------------------------------------------------------------------

Data/Text/Array.hs+1−1

@@ -20,7 +20,7 @@

20-- > import qualified Data.Text.Array as A

21--

22-- The names in this module resemble those in the 'Data.Array' family

23−-- of modules, but are shorter due to the assumption of qualified

23+-- of modules, but are shorter due to the assumption of qualifid

24-- naming.

25module Data.Text.Array

26 (

Data/Text/Internal/Builder.hs+1−3

@@ -6,7 +6,7 @@

6-- Module : Data.Text.Internal.Builder

9−-- License : BSD-style (see LICENSE)

9+-- License : BSD3-style (see LICENSE)

10--

11-- Maintainer : Johan Tibell <johan.tibell@gmail.com>

12-- Stability : experimental

@@ -242,8 +242,6 @@ flush = Builder $ \ k buf@(Buffer p o u l) ->

242 !t = Text arr o u

243 ts <- inlineInterleaveST (k b)

244 return $! t : ts

245−{-# INLINE [1] flush #-}

246−-- defer inlining so that flush/flush rule may fire.

247

245

248------------------------------------------------------------------------

246------------------------------------------------------------------------

249

247

Data/Text/Internal/Builder/Int/Digits.hs+1−1

@@ -2,7 +2,7 @@

2

3-- Module: Data.Text.Internal.Builder.Int.Digits

5−-- License: BSD-style

5+-- License: BSD3

6-- Maintainer: Bryan O'Sullivan <bos@serpentine.com>

7-- Stability: experimental

8-- Portability: portable

Data/Text/Internal/Fusion.hs+17−27

@@ -98,35 +98,25 @@ reverseStream (Text arr off len) = Stream next (off+len-1) (betweenSize (len `sh

98-- | /O(n)/ Convert a 'Stream Char' into a 'Text'.

99unstream :: Stream Char -> Text

100unstream (Stream next0 s0 len) = runText $ \done -> do

101− -- Before encoding each char we perform a buffer realloc check assuming

102− -- worst case encoding size of two 16-bit units for the char. Just add an

103− -- extra space to the buffer so that we do not end up reallocating even when

104− -- all the chars are encoded as single unit.

105− let mlen = upperBound 4 len + 1

101+ let mlen = upperBound 4 len

106 arr0 <- A.new mlen

102 arr0 <- A.new mlen

107− let outer !arr !maxi = encode

103+ let outer arr top = loop

108 where

104 where

109− -- keep the common case loop as small as possible

105+ loop !s !i =

110− encode !si !di =

111− case next0 si of

106+ case next0 s of

112− Done -> done arr di

107+ Done -> done arr i

113− Skip si' -> encode si' di

108+ Skip s' -> loop s' i

114− Yield c si'

109+ Yield x s'

115− -- simply check for the worst case

110+ | j >= top -> {-# SCC "unstream/resize" #-} do

116− | maxi < di + 1 -> realloc si di

111+ let top' = (top + 1) `shiftL` 1

117− | otherwise -> do

118− n <- unsafeWrite arr di c

119− encode si' (di + n)

120−

121− -- keep uncommon case separate from the common case code

122− {-# NOINLINE realloc #-}

123− realloc !si !di = do

124− let newlen = (maxi + 1) * 2

125− arr' <- A.new newlen

112+ arr' <- A.new top'

126− A.copyM arr' 0 arr 0 di

113+ A.copyM arr' 0 arr 0 top

127− outer arr' (newlen - 1) si di

114+ outer arr' top' s i

128−

115+ | otherwise -> do d <- unsafeWrite arr i x

116+ loop s' (i+d)

117+ where j | ord x < 0x10000 = i

118+ | otherwise = i + 1

129− outer arr0 (mlen - 1) s0 0

119+ outer arr0 mlen s0 0

130{-# INLINE [0] unstream #-}

120{-# INLINE [0] unstream #-}

131{-# RULES "STREAM stream/unstream fusion" forall s. stream (unstream s) = s #-}

121{-# RULES "STREAM stream/unstream fusion" forall s. stream (unstream s) = s #-}

132

122

Data/Text/Internal/Fusion/Common.hs+3−3

@@ -669,12 +669,12 @@ scanl f z0 (Stream next0 s0 len) = Stream next (Scan1 z0 s0) (len+1) -- HINT may

669-- ** Generating and unfolding streams

670

671replicateCharI :: Integral a => a -> Char -> Stream Char

672−replicateCharI !n !c

672+replicateCharI n c

673 | n < 0 = empty

674 | otherwise = Stream next 0 (fromIntegral n) -- HINT maybe too low

675 where

676− next !i | i >= n = Done

676+ next i | i >= n = Done

677− | otherwise = Yield c (i + 1)

677+ | otherwise = Yield c (i + 1)

678{-# INLINE [0] replicateCharI #-}

679

680data RI s = RI !s {-# UNPACK #-} !Int64

Data/Text/Lazy.hs+2−2

@@ -545,7 +545,7 @@ tail Empty = emptyError "tail"

545 unstream (S.tail (stream t)) = tail t

546 #-}

547

548−-- | /O(n\/c)/ Returns all but the last character of a 'Text', which must

548+-- | /O(1)/ Returns all but the last character of a 'Text', which must

549-- be non-empty. Subject to fusion.

550init :: Text -> Text

551init (Chunk t0 ts0) = go t0 ts0

@@ -581,7 +581,7 @@ isSingleton :: Text -> Bool

581isSingleton = S.isSingleton . stream

582{-# INLINE isSingleton #-}

583

584−-- | /O(n\/c)/ Returns the last character of a 'Text', which must be

584+-- | /O(1)/ Returns the last character of a 'Text', which must be

585-- non-empty. Subject to fusion.

586last :: Text -> Char

587last Empty = emptyError "last"

Data/Text/Lazy/Builder.hs+1−1

@@ -8,7 +8,7 @@

8-- Module : Data.Text.Lazy.Builder

11−-- License : BSD-style (see LICENSE)

11+-- License : BSD3-style (see LICENSE)

12--

13-- Maintainer : Johan Tibell <johan.tibell@gmail.com>

14-- Stability : experimental

Data/Text/Lazy/Builder/Int.hs+1−1

@@ -7,7 +7,7 @@

7-- Module: Data.Text.Lazy.Builder.Int

10−-- License: BSD-style

10+-- License: BSD3

11-- Maintainer: Bryan O'Sullivan <bos@serpentine.com>

12-- Stability: experimental

13-- Portability: portable

benchmarks/haskell/Benchmarks.hs+1−1

@@ -53,7 +53,7 @@ benchmarks = do

53 , Mul.benchmark

54 , Pure.benchmark "tiny" (tf "tiny.txt")

55 , Pure.benchmark "ascii" (tf "ascii-small.txt")

56− -- , Pure.benchmark "france" (tf "france.html")

56+ , Pure.benchmark "france" (tf "france.html")

57 , Pure.benchmark "russian" (tf "russian-small.txt")

58 , Pure.benchmark "japanese" (tf "japanese.txt")

59 , ReadNumbers.benchmark (tf "numbers.txt")

benchmarks/haskell/Benchmarks/Stream.hs+5−16

@@ -18,11 +18,11 @@ import qualified Data.Text.Encoding as T

18import qualified Data.Text.Encoding.Error as E

19import qualified Data.Text.Internal.Encoding.Fusion as T

20import qualified Data.Text.Internal.Encoding.Fusion.Common as F

21−import qualified Data.Text.Internal.Fusion as F

21+import qualified Data.Text.Internal.Fusion as T

22import qualified Data.Text.IO as T

23import qualified Data.Text.Lazy.Encoding as TL

24import qualified Data.Text.Internal.Lazy.Encoding.Fusion as TL

25−import qualified Data.Text.Internal.Lazy.Fusion as FL

25+import qualified Data.Text.Internal.Lazy.Fusion as TL

26import qualified Data.Text.Lazy.IO as TL

27

28instance NFData a => NFData (Stream a) where

@@ -53,25 +53,14 @@ benchmark fp = do

53 !utf32beL = TL.encodeUtf32BE tl

54

55 -- For the functions which operate on streams

56− let !s = F.stream t

56+ let !s = T.stream t

57

58 return $ bgroup "Stream"

59

60 -- Fusion

61 [ bgroup "stream" $

62− [ bench "Text" $ nf F.stream t

62+ [ bench "Text" $ nf T.stream t

63− , bench "LazyText" $ nf FL.stream tl

63+ , bench "LazyText" $ nf TL.stream tl

64− ]

65− -- must perform exactly the same as stream above due to

66− -- stream/unstream (i.e. stream after unstream) fusion

67− , bgroup "stream-fusion" $

68− [ bench "Text" $ nf (F.stream . F.unstream . F.stream) t

69− , bench "LazyText" $ nf (FL.stream . FL.unstream . FL.stream) tl

70− ]

71− -- measure the overhead of unstream after stream

72− , bgroup "stream-unstream" $

73− [ bench "Text" $ nf (F.unstream . F.stream) t

74− , bench "LazyText" $ nf (FL.unstream . FL.stream) tl

75 ]

64 ]

76

65

77 -- Encoding.Fusion

66 -- Encoding.Fusion

benchmarks/text-benchmarks.cabal+1−1

@@ -3,7 +3,7 @@ version: 0.0.0.0

3synopsis: Benchmarks for the text package

4description: Benchmarks for the text package

5homepage: https://bitbucket.org/bos/text

6−license: BSD2

6+license: BSD3

7license-file: ../LICENSE

8author: Jasper Van der Jeugt <jaspervdj@gmail.com>,

9 Bryan O'Sullivan <bos@serpentine.com>,

tests/text-tests.cabal+1−1

@@ -3,7 +3,7 @@ version: 0.0.0.0

3synopsis: Functional tests for the text package

4description: Functional tests for the text package

5homepage: https://github.com/bos/text

6−license: BSD2

6+license: BSD3

7license-file: ../LICENSE

8author: Jasper Van der Jeugt <jaspervdj@gmail.com>,

9 Bryan O'Sullivan <bos@serpentine.com>,

text.cabal+1−1

@@ -31,7 +31,7 @@ description:

31 the @text-icu@ package:

32 <http://hackage.haskell.org/package/text-icu>

33

34−license: BSD2

34+license: BSD3

35license-file: LICENSE

36author: Bryan O'Sullivan <bos@serpentine.com>

37maintainer: Bryan O'Sullivan <bos@serpentine.com>