da51d3a · text · git.iko.soy

git.iko.soy/text

Improve the type of replicate. Get rid of the Compat module.

--HG-- extra : convert_revision : ee95b35cd06d0c68dae1b07d0f92d6b99647aefe

commitda51d3a3a7c716711ae9d7ec074cca263ea98539 authorBryan O'Sullivan <bos@serpentine.com> dateSun 16 Aug 2009, 05:08 (17 years ago) parent522b34d

7 files changed+66−222

compare with master

unifiedsplit

Data/Text.hs+19−8 Data/Text/Compat.hs−186 Data/Text/Fusion/Common.hs+16−2 Data/Text/Lazy.hs+18−7 Data/Text/UnsafeShift.hs+1−1 tests/Properties.hs+12−17 text.cabal−1

Data/Text.hs+19−8

@@ -97,6 +97,7 @@ module Data.Text

9797

9898 -- ** Generation and unfolding

9999 , replicate

100+ , replicateChar

100101 , unfoldr

101102 , unfoldrN

102103

@@ -169,7 +170,7 @@ import Prelude (Char, Bool(..), Functor(..), Int, Maybe(..), String,

169170 Eq(..), Ord(..), (++),

170171 Read(..), Show(..),

171172 (&&), (||), (+), (-), (.), ($),

172− div, not, return, otherwise)

173+ fromIntegral, div, not, return, otherwise)

173174import Control.Exception (assert)

174175import Data.Char (isSpace)

175176import Control.Monad.ST (ST)

@@ -465,7 +466,7 @@ toUpper t = unstream (S.toUpper (stream t))

465466justifyLeft :: Int -> Char -> Text -> Text

466467justifyLeft k c t

467468 | len >= k = t

468− | otherwise = t `append` replicate (k-len) c

469+ | otherwise = t `append` replicateChar (k-len) c

469470 where len = length t

470471{-# INLINE [1] justifyLeft #-}

471472

@@ -484,7 +485,7 @@ justifyLeft k c t

484485justifyRight :: Int -> Char -> Text -> Text

485486justifyRight k c t

486487 | len >= k = t

487− | otherwise = replicate (k-len) c `append` t

488+ | otherwise = replicateChar (k-len) c `append` t

488489 where len = length t

489490{-# INLINE justifyRight #-}

490491

@@ -495,7 +496,7 @@ justifyRight k c t

495496center :: Int -> Char -> Text -> Text

496497center k c t

497498 | len >= k = t

498− | otherwise = replicate l c `append` t `append` replicate r c

499+ | otherwise = replicateChar l c `append` t `append` replicateChar r c

499500 where len = length t

500501 d = k - len

501502 r = d `div` 2

@@ -654,11 +655,21 @@ mapAccumR f s t = case uncons t of

654655-- -----------------------------------------------------------------------------

655656-- ** Generating and unfolding 'Text's

656657

657−-- | /O(n)/ 'replicate' @n@ @c@ is a 'Text' of length @n@ with @c@ the

658+-- | /O(n*m)/ 'replicate' @n@ @t@ is a 'Text' consisting of the input

659+-- @t@ repeated @n@ times. Subject to fusion.

660+replicate :: Int -> Text -> Text

661+replicate n t = unstream (S.replicateI (fromIntegral n) (S.stream t))

662+{-# INLINE [1] replicate #-}

663+

664+{-# RULES

665+"TEXT replicate/singleton -> replicateChar" [~1] forall n c.

666+ replicate n (singleton c) = replicateChar n c

667+ #-}

668+

669+-- | /O(n)/ 'replicateChar' @n@ @c@ is a 'Text' of length @n@ with @c@ the

658670-- value of every element. Subject to fusion.

659−replicate :: Int -> Char -> Text

660−replicate n c = unstream (S.replicateI n c)

661−{-# INLINE replicate #-}

671+replicateChar :: Int -> Char -> Text

672+replicateChar n c = unstream (S.replicateCharI n c)

662673

663674-- | /O(n)/, where @n@ is the length of the result. The 'unfoldr'

664675-- function is analogous to the List 'L.unfoldr'. 'unfoldr' builds a

Data/Text/Compat.hsdeleted−186

@@ -1,186 +0,0 @@

1−{-# LANGUAGE BangPatterns #-}

2−{-# OPTIONS_GHC -fno-warn-unused-imports #-}

3−-- |

4−-- Module : Data.Text.Compat

5−-- Copyright : (c) Bryan O'Sullivan 2009

6−--

7−-- License : BSD-style

8−-- Maintainer : bos@serpentine.com, rtharper@aftereternity.co.uk,

9−-- duncan@haskell.org

10−-- Stability : experimental

11−-- Portability : GHC

12−--

13−-- A text API for which function names closely resemble those of the

14−-- list and 'ByteString' types.

15−--

16−-- This module is intended to be imported @qualified@, to avoid name

17−-- clashes with "Prelude" functions, e.g.

18−--

19−-- > import qualified Data.Text.Compat as T

20−

21−module Data.Text.Compat

22− (

23− -- * Types

24− Text

25−

26− -- * Creation and elimination

27− , pack

28− , unpack

29− , singleton

30− , empty

31−

32− -- * Basic interface

33− , cons

34− , snoc

35− , append

36− , uncons

37− , head

38− , last

39− , tail

40− , init

41− , null

42− , length

43−

44− -- * Transformations

45− , map

46− , intercalate

47− , intersperse

48− , transpose

49− , reverse

50−

51− -- * Case conversion

52− -- $case

53− , toCaseFold

54− , toLower

55− , toUpper

56−

57− -- * Folds

58− , foldl

59− , foldl'

60− , foldl1

61− , foldl1'

62− , foldr

63− , foldr1

64−

65− -- ** Special folds

66− , concat

67− , concatMap

68− , any

69− , all

70− , maximum

71− , minimum

72−

73− -- * Construction

74−

75− -- ** Scans

76− , scanl

77− , scanl1

78− , scanr

79− , scanr1

80−

81− -- ** Accumulating maps

82− , mapAccumL

83− , mapAccumR

84−

85− -- ** Generation and unfolding

86− , replicate

87− , unfoldr

88− , unfoldrN

89−

90− -- * Substrings

91−

92− -- ** Breaking strings

93− , take

94− , drop

95− , takeWhile

96− , dropWhile

97− , splitAt

98− , span

99− , break

100− , group

101− , groupBy

102− , inits

103− , tails

104−

105− -- ** Breaking into many substrings

106− , split

107− , splitWith

108− , breakSubstring

109−

110− -- ** Breaking into lines and words

111− , lines

112− --, lines'

113− , words

114− , unlines

115− , unwords

116−

117− -- * Predicates

118− , isPrefixOf

119− , isSuffixOf

120− , isInfixOf

121−

122− -- * Searching

123− , elem

124− , filter

125− , find

126− , partition

127−

128− -- , findSubstring

129−

130− -- * Indexing

131− , index

132− , findIndex

133− , findIndices

134− , elemIndex

135− , elemIndices

136− , count

137−

138− -- * Zipping and unzipping

139− , zip

140− , zipWith

141−

142− -- -* Ordered text

143− -- , sort

144− ) where

145−

146−import Data.ByteString (ByteString)

147−import Data.Text hiding (split)

148−import qualified Data.Text as T

149−import Data.Text.Unsafe (unsafeTail)

150−import Prelude (Char, (+), otherwise)

151−

152−split :: Char -> Text -> [Text]

153−split c = T.split (singleton c)

154−{-# INLINE split #-}

155−

156−-- | /O(n)/ Break a string on a substring, returning a pair of the

157−-- part of the string prior to the match, and the rest of the string.

158−--

159−-- The following relationship holds:

160−--

161−-- > break (==c) l == breakSubstring (singleton c) l

162−--

163−-- For example, to tokenise a string, dropping delimiters:

164−--

165−-- > tokenise x y = h : if null t then [] else tokenise x (drop (length x) t)

166−-- > where (h,t) = breakSubstring x y

167−--

168−-- To skip to the first occurence of a string:

169−--

170−-- > snd (breakSubstring x y)

171−--

172−-- To take the parts of a string before a delimiter:

173−--

174−-- > fst (breakSubstring x y)

175−--

176−breakSubstring :: Text -- ^ String to search for

177− -> Text -- ^ String to search in

178− -> (Text,Text) -- ^ Head and tail of string broken at substring

179−

180−breakSubstring pat src = search 0 src

181− where

182− search !n !s

183− | null s = (src,empty) -- not found

184− | pat `isPrefixOf` s = (take n src,s)

185− | otherwise = search (n+1) (unsafeTail s)

186−{-# INLINE breakSubstring #-}

Data/Text/Fusion/Common.hs+16−2

@@ -68,6 +68,7 @@ module Data.Text.Fusion.Common

6868 -- , mapAccumL

6969

7070 -- ** Generation and unfolding

71+ , replicateCharI

7172 , replicateI

7273 , unfoldr

7374 , unfoldrNI

@@ -104,6 +105,7 @@ import Prelude (Bool(..), Char, Either(..), Eq(..), Int, Integral, Maybe(..),

104105 fromIntegral, otherwise)

105106import qualified Data.List as L

106107import qualified Prelude as P

108+import Data.Int (Int64)

107109import Data.Text.Fusion.Internal

108110import Data.Text.Fusion.CaseMapping (foldMapping, lowerMapping, upperMapping)

109111

@@ -576,14 +578,26 @@ mapAccumL f z0 (Stream next0 s0 len) = Stream next (s0 :!: z0) len -- HINT depen

576578-- -----------------------------------------------------------------------------

577579-- ** Generating and unfolding streams

578580

579−replicateI :: Integral a => a -> Char -> Stream Char

580−replicateI n c

581+replicateCharI :: Integral a => a -> Char -> Stream Char

582+replicateCharI n c

581583 | n < 0 = empty

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

583585 where

584586 {-# INLINE next #-}

585587 next i | i >= n = Done

586588 | otherwise = Yield c (i + 1)

589+{-# INLINE [0] replicateCharI #-}

590+

591+replicateI :: Int64 -> Stream Char -> Stream Char

592+replicateI n (Stream next0 s0 len) =

593+ Stream next (0 :!: s0) (max 0 (fromIntegral n * len))

594+ where

595+ next (k :!: s)

596+ | k >= n = Done

597+ | otherwise = case next0 s of

598+ Done -> Skip (k+1 :!: s0)

599+ Skip s' -> Skip (k :!: s')

600+ Yield x s' -> Yield x (k :!: s')

587601{-# INLINE [0] replicateI #-}

588602

589603-- | /O(n)/, where @n@ is the length of the result. The unfoldr function

Data/Text/Lazy.hs+18−7

@@ -101,6 +101,7 @@ module Data.Text.Lazy

101101

102102 -- ** Generation and unfolding

103103 , replicate

104+ , replicateChar

104105 , unfoldr

105106 , unfoldrN

106107

@@ -388,7 +389,7 @@ intersperse c t = unstream (S.intersperse c (stream t))

388389justifyLeft :: Int64 -> Char -> Text -> Text

389390justifyLeft k c t

390391 | len >= k = t

391− | otherwise = t `append` replicate (k-len) c

392+ | otherwise = t `append` replicateChar (k-len) c

392393 where len = length t

393394{-# INLINE [1] justifyLeft #-}

394395

@@ -407,7 +408,7 @@ justifyLeft k c t

407408justifyRight :: Int64 -> Char -> Text -> Text

408409justifyRight k c t

409410 | len >= k = t

410− | otherwise = replicate (k-len) c `append` t

411+ | otherwise = replicateChar (k-len) c `append` t

411412 where len = length t

412413{-# INLINE justifyRight #-}

413414

@@ -418,7 +419,7 @@ justifyRight k c t

418419center :: Int64 -> Char -> Text -> Text

419420center k c t

420421 | len >= k = t

421− | otherwise = replicate l c `append` t `append` replicate r c

422+ | otherwise = replicateChar l c `append` t `append` replicateChar r c

422423 where len = length t

423424 d = k - len

424425 r = d `div` 2

@@ -631,12 +632,22 @@ mapAccumR f s t = case uncons t of

631632 where (s'',y ) = f s' x

632633 (s', ys) = mapAccumR f s xs

633634

634−-- | /O(n)/ 'replicate' @n@ @c@ is a 'Text' of length @n@ with @c@ the

635−-- value of every element.

636−replicate :: Int64 -> Char -> Text

637−replicate n c = unstream (S.replicateI n c)

635+-- | /O(n*m)/ 'replicate' @n@ @t@ is a 'Text' consisting of the input

636+-- @t@ repeated @n@ times. Subject to fusion.

637+replicate :: Int64 -> Text -> Text

638+replicate n t = unstream (S.replicateI (fromIntegral n) (S.stream t))

638639{-# INLINE replicate #-}

639640

641+-- | /O(n)/ 'replicateChar' @n@ @c@ is a 'Text' of length @n@ with @c@ the

642+-- value of every element. Subject to fusion.

643+replicateChar :: Int64 -> Char -> Text

644+replicateChar n c = unstream (S.replicateCharI n c)

645+

646+{-# RULES

647+"LAZY TEXT replicate/singleton -> replicateChar" [~1] forall n c.

648+ replicate n (singleton c) = replicateChar n c

649+ #-}

650+

640651-- | /O(n)/, where @n@ is the length of the result. The 'unfoldr'

641652-- function is analogous to the List 'L.unfoldr'. 'unfoldr' builds a

642653-- 'Text' from a seed value. The function takes the element and

Data/Text/UnsafeShift.hs+1−1

@@ -17,7 +17,7 @@ module Data.Text.UnsafeShift

1717 UnsafeShift(..)

1818 ) where

1919

20−import qualified Data.Bits as Bits

20+-- import qualified Data.Bits as Bits

2121import GHC.Base

2222import GHC.Word

2323

tests/Properties.hs+12−17

@@ -13,7 +13,6 @@ import Debug.Trace (trace)

1313import Control.Arrow ((***), second)

1414import Data.Word (Word8, Word16, Word32)

1515import qualified Data.Text as T

16−import qualified Data.Text.Compat as C

1716import qualified Data.Text.Lazy as TL

1817import qualified Data.Text.Encoding as E

1918import Control.Exception (SomeException, try)

@@ -23,6 +22,7 @@ import qualified Data.Text.Lazy.Encoding as EL

2322import qualified Data.Text.Lazy.Fusion as SL

2423import qualified Data.Text.UnsafeShift as U

2524import qualified Data.List as L

25+import Prelude hiding (replicate)

2626import System.IO.Unsafe (unsafePerformIO)

2727import Test.Framework (defaultMain, testGroup)

2828import Test.Framework.Providers.QuickCheck (testProperty)

@@ -238,8 +238,8 @@ t_toUpper_upper t = p (T.toUpper t) >= p t

238238tl_toUpper_upper t = p (TL.toUpper t) >= p t

239239 where p = TL.length . TL.filter isUpper

240240

241−justifyLeft k c s = s ++ replicate (k - length s) c

242−justifyRight m n s = replicate (m - length s) n ++ s

241+justifyLeft k c s = s ++ L.replicate (k - length s) c

242+justifyRight m n s = L.replicate (m - length s) n ++ s

243243

244244s_justifyLeft k c = justifyLeft k c `eqP` (unpackS . S.justifyLeftI k c)

245245sf_justifyLeft p k c =

@@ -315,8 +315,12 @@ t_mapAccumR f z = unsquare (L.mapAccumR f z `eqP` (second unpackS . T.mapAccum

315315tl_mapAccumR f z = unsquare (L.mapAccumR f z `eqP` (second unpackS . TL.mapAccumR f z))

316316 where _types = f :: Int -> Char -> (Int,Char)

317317

318−t_replicate n = L.replicate n `eq` (unpackS . T.replicate n)

319−tl_replicate n = L.replicate n `eq` (unpackS . TL.replicate (fromIntegral n))

318+replicate n l = concat (L.replicate n l)

319+

320+t_replicate n = replicate n `eq` (unpackS . T.replicate n . packS)

321+tl_replicate n = replicate n `eq` (unpackS . TL.replicate (fromIntegral n) . packS)

322+t_replicateChar n = L.replicate n `eq` (unpackS . T.replicateChar n)

323+tl_replicateChar n= L.replicate n `eq` (unpackS . TL.replicateChar (fromIntegral n))

320324

321325unf :: Int -> Char -> Maybe (Char, Char)

322326unf n c | fromEnum c * 100 > n = Nothing

@@ -393,7 +397,6 @@ tl_split_i t = id `eq` (TL.intercalate t . TL.split t)

393397t_splitWith p = splitWith p `eqP` (map unpackS . T.splitWith p)

394398t_splitWith_count c = (L.length . T.splitWith (==c)) `eq` ((1+) . T.count c)

395399t_splitWith_split c = T.splitWith (==c) `eq` T.split (T.singleton c)

396−t_splitWith_Csplit c = T.splitWith (==c) `eq` C.split c

397400tl_splitWith p = splitWith p `eqP` (map unpackS . TL.splitWith p)

398401

399402splitWith :: (a -> Bool) -> [a] -> [[a]]

@@ -412,13 +415,6 @@ t_chunksOf_length k t = len == T.length t || (k <= 0 && len == 0)

412415

413416tl_chunksOf k = T.chunksOf k `eq` (map (T.concat . TL.toChunks) . TL.chunksOf (fromIntegral k) . TL.fromChunks . (:[]))

414417

415−t_breakSubstring_isInfixOf s l

416− = T.isInfixOf s l ==

417− T.null s || (not . T.null . snd $ C.breakSubstring s l)

418−t_breakSubstringC c

419− = L.break (==c) `eqP`

420− (unpack2 . C.breakSubstring (T.singleton c))

421−

422418t_lines = L.lines `eqP` (map unpackS . T.lines)

423419tl_lines = L.lines `eqP` (map unpackS . TL.lines)

424420{-

@@ -711,6 +707,8 @@ tests = [

711707 testGroup "unfolds" [

712708 testProperty "t_replicate" t_replicate,

713709 testProperty "tl_replicate" tl_replicate,

710+ testProperty "t_replicateChar" t_replicateChar,

711+ testProperty "tl_replicateChar" tl_replicateChar,

714712 testProperty "t_unfoldr" t_unfoldr,

715713 testProperty "tl_unfoldr" tl_unfoldr,

716714 testProperty "t_unfoldrN" t_unfoldrN,

@@ -776,13 +774,10 @@ tests = [

776774 testProperty "t_splitWith" t_splitWith,

777775 testProperty "t_splitWith_count" t_splitWith_count,

778776 testProperty "t_splitWith_split" t_splitWith_split,

779− testProperty "t_splitWith_Csplit" t_splitWith_Csplit,

780777 testProperty "tl_splitWith" tl_splitWith,

781778 testProperty "t_chunksOf_same_lengths" t_chunksOf_same_lengths,

782779 testProperty "t_chunksOf_length" t_chunksOf_length,

783− testProperty "tl_chunksOf" tl_chunksOf,

784− testProperty "t_breakSubstringC" t_breakSubstringC,

785− testProperty "t_breakSubstring_isInfixOf" t_breakSubstring_isInfixOf

780+ testProperty "tl_chunksOf" tl_chunksOf

786781 ],

787782

788783 testGroup "lines and words" [

text.cabal−1

@@ -17,7 +17,6 @@ extra-source-files: README

1717library

1818 exposed-modules:

1919 Data.Text

20− Data.Text.Compat

2120 Data.Text.Encoding

2221 Data.Text.Encoding.Error

2322 Data.Text.Foreign