git.iko.soy/text
on master help sign in
First stab at lazy text support
1175a74Bryan O'Sullivan
Data/Text.hs+5−23
compare with master
unifiedsplit
@@ -158,8 +158,10 @@ import Data.Word (Word16)
158import Data.String (IsString(..))
158import Data.String (IsString(..))
159
159
160import qualified Data.Text.Fusion as S
160import qualified Data.Text.Fusion as S
161+import qualified Data.Text.Fusion.Internal as S
161import Data.Text.Fusion (Stream(..), Step(..), stream, reverseStream, unstream)
162import Data.Text.Fusion (Stream(..), Step(..), stream, reverseStream, unstream)
163+
162−import Data.Text.Internal (Text(..), empty, text)
164+import Data.Text.Internal (Text(..), empty, text, textP)
163import qualified Prelude as P
165import qualified Prelude as P
164import Data.Text.Unsafe (iter, iter_, unsafeHead, unsafeTail)
166import Data.Text.Unsafe (iter, iter_, unsafeHead, unsafeTail)
165import Data.Text.UnsafeChar (unsafeChr)
167import Data.Text.UnsafeChar (unsafeChr)
@@ -195,26 +197,13 @@ instance IsString Text where
195--
197--
196-- This function is subject to array fusion.
198-- This function is subject to array fusion.
197pack :: String -> Text
199pack :: String -> Text
198−pack str = (unstream (stream_list str))
200+pack = unstream . S.streamList
199− where
200− stream_list s0 = S.Stream next s0 (P.length s0) -- total guess
201− where
202− next [] = S.Done
203− next (x:xs) = S.Yield x xs
204{-# INLINE [1] pack #-}
201{-# INLINE [1] pack #-}
205−-- TODO: Has to do validation! -- No, it doesn't, the
206
202
207-- | /O(n)/ Convert a Text into a String.
203-- | /O(n)/ Convert a Text into a String.
208-- Subject to array fusion.
204-- Subject to array fusion.
209unpack :: Text -> String
205unpack :: Text -> String
210−unpack txt = (unstream_list (stream txt))
206+unpack = S.unstreamList . stream
211− where
212− unstream_list (S.Stream next s0 _len) = unfold s0
213− where
214− unfold !s = case next s of
215− S.Done -> []
216− S.Skip s' -> unfold s'
217− S.Yield x s' -> x : unfold s'
218{-# INLINE [1] unpack #-}
207{-# INLINE [1] unpack #-}
219
208
220-- | /O(1)/ Convert a character into a Text.
209-- | /O(1)/ Convert a character into a Text.
@@ -312,13 +301,6 @@ last (Text arr off len)
312 S.last (stream t) = last t
301 S.last (stream t) = last t
313 #-}
302 #-}
314
303
315−-- | Construct a 'Text' without invisibly pinning its byte array in
316−-- memory if its length has dwindled to zero.
317−textP :: A.Array Word16 -> Int -> Int -> Text
318−textP arr off len | len == 0 = empty
319− | otherwise = text arr off len
320−{-# INLINE textP #-}
321−
322-- | /O(1)/ Returns all characters after the head of a 'Text', which
304-- | /O(1)/ Returns all characters after the head of a 'Text', which
323-- must be non-empty. Subject to array fusion.
305-- must be non-empty. Subject to array fusion.
324tail :: Text -> Text
306tail :: Text -> Text
Data/Text/Fusion.hs+5−51
@@ -1,4 +1,4 @@
1−{-# LANGUAGE ExistentialQuantification, BangPatterns, MagicHash #-}
1+{-# LANGUAGE BangPatterns, MagicHash #-}
2
2
3-- |
3-- |
4-- Module : Data.Text.Fusion
4-- Module : Data.Text.Fusion
@@ -22,6 +22,7 @@ module Data.Text.Fusion
22
22
23 -- * Creation and elimination
23 -- * Creation and elimination
24 , stream
24 , stream
25+ , streamList
25 , unstream
26 , unstream
26 , reverseStream
27 , reverseStream
27 , empty
28 , empty
@@ -114,40 +115,13 @@ import Data.Char (ord)
114import Data.Text.Internal (Text(..))
115import Data.Text.Internal (Text(..))
115import Data.Text.UnsafeChar (unsafeChr, unsafeWrite, unsafeWriteRev)
116import Data.Text.UnsafeChar (unsafeChr, unsafeWrite, unsafeWriteRev)
116import qualified Data.Text.Array as A
117import qualified Data.Text.Array as A
118+import Data.Text.Fusion.Internal
117import qualified Data.Text.Internal as I
119import qualified Data.Text.Internal as I
118import qualified Data.Text.Encoding.Utf16 as U16
120import qualified Data.Text.Encoding.Utf16 as U16
119import qualified Prelude as P
121import qualified Prelude as P
120
122
121default(Int)
123default(Int)
122
124
123−infixl 2 :!:
124−data PairS a b = !a :!: !b
125−
126−-- | Allow a function over a stream to switch between two states.
127−data Switch = S1 | S2
128−
129−data Stream a =
130− forall s. Stream
131− (s -> Step s a) -- stepper function
132− !s -- current state
133− {-# UNPACK #-}!Int -- length hint
134−
135−-- The length hint in a Stream has two roles. If its value is zero,
136−-- we trust it, and treat the stream as empty. Otherwise, we treat it
137−-- as a hint: it should usually be accurate, so we use it when
138−-- unstreaming to decide what size array to allocate. However, the
139−-- unstreaming functions must be able to cope with the hint being too
140−-- small or too large.
141−--
142−-- The size hint tries to track the UTF-16 code points in a stream,
143−-- but often counts the number of characters instead. It can easily
144−-- undercount if, for instance, a transformed stream contains astral
145−-- plane characters (those above 0x10000).
146−
147−data Step s a = Done
148− | Skip !s
149− | Yield !a !s
150−
151-- | /O(n)/ Convert a 'Text' into a 'Stream Char'.
125-- | /O(n)/ Convert a 'Text' into a 'Stream Char'.
152stream :: Text -> Stream Char
126stream :: Text -> Stream Char
153stream (Text arr off len) = Stream next off len
127stream (Text arr off len) = Stream next off len
@@ -182,7 +156,7 @@ reverseStream (Text arr off len) = Stream next (off+len-1) len
182unstream :: Stream Char -> Text
156unstream :: Stream Char -> Text
183unstream (Stream next0 s0 len)
157unstream (Stream next0 s0 len)
184 | len == 0 = I.empty
158 | len == 0 = I.empty
185− | otherwise = Text (P.fst a) 0 (P.snd a)
159+ | otherwise = I.textP (P.fst a) 0 (P.snd a)
186 where
160 where
187 a = runST (A.unsafeNew len >>= (\arr -> loop arr len s0 0))
161 a = runST (A.unsafeNew len >>= (\arr -> loop arr len s0 0))
188 loop arr !top !s !i
162 loop arr !top !s !i
@@ -198,26 +172,6 @@ unstream (Stream next0 s0 len)
198{-# INLINE [0] unstream #-}
172{-# INLINE [0] unstream #-}
199{-# RULES "STREAM stream/unstream fusion" forall s. stream (unstream s) = s #-}
173{-# RULES "STREAM stream/unstream fusion" forall s. stream (unstream s) = s #-}
200
174
201−-- | The empty stream.
202−empty :: Stream Char
203−empty = Stream next () 0
204− where next _ = Done
205−{-# INLINE [0] empty #-}
206−
207−-- | /O(n)/ Determines if two streams are equal.
208−eq :: Ord a => Stream a -> Stream a -> Bool
209−eq (Stream next1 s1 _) (Stream next2 s2 _) = cmp (next1 s1) (next2 s2)
210− where
211− cmp Done Done = True
212− cmp Done _ = False
213− cmp _ Done = False
214− cmp (Skip s1') (Skip s2') = cmp (next1 s1') (next2 s2')
215− cmp (Skip s1') x2 = cmp (next1 s1') x2
216− cmp x1 (Skip s2') = cmp x1 (next2 s2')
217− cmp (Yield x1 s1') (Yield x2 s2') = x1 == x2 &&
218− cmp (next1 s1') (next2 s2')
219−{-# SPECIALISE eq :: Stream Char -> Stream Char -> Bool #-}
220−
221streamError :: String -> String -> a
175streamError :: String -> String -> a
222streamError func msg = P.error $ "Data.Text.Fusion." ++ func ++ ": " ++ msg
176streamError func msg = P.error $ "Data.Text.Fusion." ++ func ++ ": " ++ msg
223
177
@@ -403,7 +357,7 @@ intersperse c (Stream next0 s0 len) = Stream next (s0 :!: Nothing :!: S1) len
403reverse :: Stream Char -> Text
357reverse :: Stream Char -> Text
404reverse (Stream next s len0)
358reverse (Stream next s len0)
405 | len0 == 0 = I.empty
359 | len0 == 0 = I.empty
406− | otherwise = Text arr off' len'
360+ | otherwise = I.textP arr off' len'
407 where
361 where
408 len0' = max len0 4
362 len0' = max len0 4
409 (arr, (off', len')) = A.run2 (A.unsafeNew len0' >>= loop s (len0'-1) len0')
363 (arr, (off', len')) = A.run2 (A.unsafeNew len0' >>= loop s (len0'-1) len0')
Data/Text/Internal.hs+8
@@ -21,6 +21,7 @@ module Data.Text.Internal
21 Text(..)
21 Text(..)
22 -- * Construction
22 -- * Construction
23 , text
23 , text
24+ , textP
24 -- * Code that must be here for accessibility
25 -- * Code that must be here for accessibility
25 , empty
26 , empty
26 -- * Debugging
27 -- * Debugging
@@ -56,6 +57,13 @@ empty :: Text
56empty = Text A.empty 0 0
57empty = Text A.empty 0 0
57{-# INLINE [1] empty #-}
58{-# INLINE [1] empty #-}
58
59
60+-- | Construct a 'Text' without invisibly pinning its byte array in
61+-- memory if its length has dwindled to zero.
62+textP :: A.Array Word16 -> Int -> Int -> Text
63+textP arr off len | len == 0 = empty
64+ | otherwise = text arr off len
65+{-# INLINE textP #-}
66+
59-- | A useful 'show'-like function for debugging purposes.
67-- | A useful 'show'-like function for debugging purposes.
60showText :: Text -> String
68showText :: Text -> String
61showText (Text arr off len) =
69showText (Text arr off len) =
Data/Text/Lazy/Internal.hsnew file+95
@@ -0,0 +1,95 @@
1+{-# LANGUAGE BangPatterns, DeriveDataTypeable #-}
2+-- |
3+-- Module : Data.Text.Lazy.Internal
4+-- Copyright : (c) Bryan O'Sullivan 2009
5+--
6+-- License : BSD-style
7+-- Maintainer : bos@serpentine.com
8+-- Stability : experimental
9+-- Portability : GHC
10+--
11+-- A module containing semi-public 'Text' internals. This exposes the
12+-- 'Text' representation and low level construction functions.
13+-- Modules which extend the 'Text' system may need to use this module.
14+-- Regular users should not.
15+module Data.Text.Lazy.Internal
16+ (
17+ Text(..)
18+ , chunk
19+ , foldrChunks
20+ , foldlChunks
21+ -- * Data type invariant and abstraction functions
22+ , invariant
23+ , checkInvariant
24+ , showStructure
25+ -- * Chunk allocation sizes
26+ , defaultChunkSize
27+ , smallChunkSize
28+ , chunkOverhead
29+ ) where
30+
31+import qualified Data.Text.Internal as T
32+import qualified Data.Text as T
33+import Data.Typeable (Typeable)
34+import Data.Word (Word16)
35+import Foreign.Storable (sizeOf)
36+
37+data Text = Empty
38+ | Chunk {-# UNPACK #-} !T.Text Text
39+ deriving (Typeable)
40+
41+-- | The data type invariant: Every 'Text' is either 'Empty' or
42+-- consists of non-null 'T.Text's. All functions must preserve this,
43+-- and the QC properties must check this.
44+invariant :: Text -> Bool
45+invariant Empty = True
46+invariant (Chunk (T.Text _ _ len) cs) = len > 0 && invariant cs
47+
48+showStructure :: Text -> String
49+showStructure Empty = "Empty"
50+showStructure (Chunk t Empty) = "Chunk " ++ show t ++ " Empty"
51+showStructure (Chunk t ts) =
52+ "Chunk " ++ show t ++ " (" ++ showStructure ts ++ ")"
53+
54+-- | In a form that checks the invariant lazily.
55+checkInvariant :: Text -> Text
56+checkInvariant Empty = Empty
57+checkInvariant (Chunk c@(T.Text _ _ len) cs)
58+ | len > 0 = Chunk c (checkInvariant cs)
59+ | otherwise = error $ "Data.Text.Lazy: invariant violation: "
60+ ++ showStructure (Chunk c cs)
61+
62+-- | Smart constructor for 'Chunk'. Guarantees the data type invariant.
63+chunk :: T.Text -> Text -> Text
64+{-# INLINE chunk #-}
65+chunk t@(T.Text _ _ len) ts | len == 0 = ts
66+ | otherwise = Chunk t ts
67+
68+-- | Consume the chunks of a lazy 'Text' with a natural right fold.
69+foldrChunks :: (T.Text -> a -> a) -> a -> Text -> a
70+foldrChunks f z = go
71+ where go Empty = z
72+ go (Chunk c cs) = f c (go cs)
73+{-# INLINE foldrChunks #-}
74+
75+-- | Consume the chunks of a lazy 'Text' with a strict, tail-recursive,
76+-- accumulating left fold.
77+foldlChunks :: (a -> T.Text -> a) -> a -> Text -> a
78+foldlChunks f z = go z
79+ where go !a Empty = a
80+ go !a (Chunk c cs) = go (f a c) cs
81+{-# INLINE foldlChunks #-}
82+
83+-- | Currently set to 32k, less the memory management overhead.
84+defaultChunkSize :: Int
85+defaultChunkSize = 32 * k - chunkOverhead
86+ where k = 1024 `div` sizeOf (undefined :: Word16)
87+
88+-- | Currently set to 4k, less the memory management overhead.
89+smallChunkSize :: Int
90+smallChunkSize = 4 * k - chunkOverhead
91+ where k = 1024 `div` sizeOf (undefined :: Word16)
92+
93+-- | The memory management overhead. Currently this is tuned for GHC only.
94+chunkOverhead :: Int
95+chunkOverhead = 2 * sizeOf (undefined :: Int)
tests/Properties.hs+204−200
@@ -13,11 +13,11 @@ import Control.Monad
13import Data.Word
13import Data.Word
14import qualified Data.ByteString as B
14import qualified Data.ByteString as B
15import qualified Data.Text as T
15import qualified Data.Text as T
16−import Data.Text (pack,unpack)
16+import qualified Data.Text.Lazy as TL
17import qualified Data.Text.Encoding as E
17import qualified Data.Text.Encoding as E
18import Control.Exception
18import Control.Exception
19import qualified Data.Text.Fusion as S
19import qualified Data.Text.Fusion as S
20−import Data.Text.Fusion (stream, unstream)
20+import qualified Data.Text.Lazy.Fusion as SL
21import qualified Data.List as L
21import qualified Data.List as L
22import System.IO.Unsafe
22import System.IO.Unsafe
23import Prelude hiding (catch)
23import Prelude hiding (catch)
@@ -33,18 +33,20 @@ crashy onException p = unsafePerformIO $
33 let types = e :: SomeException
33 let types = e :: SomeException
34 in trace ("*** Exception: " ++ show e) return onException
34 in trace ("*** Exception: " ++ show e) return onException
35
35
36−prop_pack_unpack s = (unpack . pack) s == s
36+prop_T_pack_unpack = (T.unpack . T.pack) `eq` id
37−prop_stream_unstream t = (unstream . stream) t == t
37+prop_TL_pack_unpack = (TL.unpack . TL.pack) `eq` id
38+prop_T_stream_unstream = (S.unstream . S.stream) `eq` id
39+prop_TL_stream_unstream = (SL.unstream . SL.stream) `eq` id
38−prop_reverse_stream t = (S.reverse . S.reverseStream) t == t
40+prop_T_reverse_stream t = (S.reverse . S.reverseStream) t == t
39−prop_singleton c = [c] == (unpack . T.singleton) c
41+prop_T_singleton c = [c] == (T.unpack . T.singleton) c
40
42
41−prop_ascii t = E.decodeASCII (E.encodeUtf8 a) == a
43+prop_T_ascii t = E.decodeASCII (E.encodeUtf8 a) == a
42 where a = T.map (\c -> chr (ord c `mod` 128)) t
44 where a = T.map (\c -> chr (ord c `mod` 128)) t
43−prop_utf8 = (E.decodeUtf8 . E.encodeUtf8) `eq` id
45+prop_T_utf8 = (E.decodeUtf8 . E.encodeUtf8) `eq` id
44−prop_utf16LE = (E.decodeUtf16LE . E.encodeUtf16LE) `eq` id
46+prop_T_utf16LE = (E.decodeUtf16LE . E.encodeUtf16LE) `eq` id
45−prop_utf16BE = (E.decodeUtf16BE . E.encodeUtf16BE) `eq` id
47+prop_T_utf16BE = (E.decodeUtf16BE . E.encodeUtf16BE) `eq` id
46−prop_utf32LE = (E.decodeUtf32LE . E.encodeUtf32LE) `eq` id
48+prop_T_utf32LE = (E.decodeUtf32LE . E.encodeUtf32LE) `eq` id
47−prop_utf32BE = (E.decodeUtf32BE . E.encodeUtf32BE) `eq` id
49+prop_T_utf32BE = (E.decodeUtf32BE . E.encodeUtf32BE) `eq` id
48
50
49-- Do two functions give the same answer?
51-- Do two functions give the same answer?
50eq :: (Eq a) => (t -> a) -> (t -> a) -> t -> Bool
52eq :: (Eq a) => (t -> a) -> (t -> a) -> t -> Bool
@@ -54,7 +56,7 @@ eqP :: (Eq a, Show a) => (String -> a) -> (T.Text -> a) -> String -> Word8 -> Bo
54eqP a b s w = eq "orig" (a s) (b t) &&
56eqP a b s w = eq "orig" (a s) (b t) &&
55 eq "head" (a sa) (b ta) &&
57 eq "head" (a sa) (b ta) &&
56 eq "tail" (a sb) (b tb)
58 eq "tail" (a sb) (b tb)
57− where t = pack s
59+ where t = T.pack s
58 (sa,sb) = splitAt m s
60 (sa,sb) = splitAt m s
59 (ta,tb) = T.splitAt m t
61 (ta,tb) = T.splitAt m t
60 l = length s
62 l = length s
@@ -71,92 +73,92 @@ eqEP a b e w = a s == b t &&
71 (null sb || a sb == b tb)
73 (null sb || a sb == b tb)
72 where (sa,sb) = splitAt m s
74 where (sa,sb) = splitAt m s
73 (ta,tb) = T.splitAt m t
75 (ta,tb) = T.splitAt m t
74− t = pack s
76+ t = T.pack s
75 l = length s
77 l = length s
76 m | l == 0 = n
78 m | l == 0 = n
77 | otherwise = n `mod` l
79 | otherwise = n `mod` l
78 n = fromIntegral w
80 n = fromIntegral w
79 s = notEmpty e
81 s = notEmpty e
80
82
81−prop_cons x = (x:) `eqP` (unpack . T.cons x)
83+prop_T_cons x = (x:) `eqP` (T.unpack . T.cons x)
82−prop_snoc x = (++ [x]) `eqP` (unpack . (flip T.snoc) x)
84+prop_T_snoc x = (++ [x]) `eqP` (T.unpack . (flip T.snoc) x)
83−prop_append s = (s++) `eqP` (unpack . T.append (pack s))
85+prop_T_append s = (s++) `eqP` (T.unpack . T.append (T.pack s))
84−prop_appendS s = (s++) `eqP` (unpack . unstream . S.append (stream (pack s)) . stream)
86+prop_T_appendS s = (s++) `eqP` (T.unpack . S.unstream . S.append (S.stream (T.pack s)) . S.stream)
85−prop_uncons s = uncons `eqP` (fmap (second unpack) . T.uncons)
87+prop_T_uncons s = uncons `eqP` (fmap (second T.unpack) . T.uncons)
86 where uncons (x:xs) = Just (x,xs)
88 where uncons (x:xs) = Just (x,xs)
87 uncons _ = Nothing
89 uncons _ = Nothing
88 types = s :: String
90 types = s :: String
89−prop_head = head `eqEP` T.head
91+prop_T_head = head `eqEP` T.head
90−prop_last = last `eqEP` T.last
92+prop_T_last = last `eqEP` T.last
91−prop_lastS = last `eqEP` (S.last . stream)
93+prop_T_lastS = last `eqEP` (S.last . S.stream)
92−prop_tail = tail `eqEP` (unpack . T.tail)
94+prop_T_tail = tail `eqEP` (T.unpack . T.tail)
93−prop_tailS = tail `eqEP` (unpack . unstream . S.tail . stream)
95+prop_T_tailS = tail `eqEP` (T.unpack . S.unstream . S.tail . S.stream)
94−prop_init = init `eqEP` (unpack . T.init)
96+prop_T_init = init `eqEP` (T.unpack . T.init)
95−prop_initS = init `eqEP` (unpack . unstream . S.init . stream)
97+prop_T_initS = init `eqEP` (T.unpack . S.unstream . S.init . S.stream)
96−prop_null = null `eqP` T.null
98+prop_T_null = null `eqP` T.null
97−prop_length = length `eqP` T.length
99+prop_T_length = length `eqP` T.length
98−prop_map f = map f `eqP` (unpack . T.map f)
100+prop_T_map f = map f `eqP` (T.unpack . T.map f)
99−prop_intercalate c = L.intercalate c `eq` (unpack . T.intercalate (pack c) . map pack)
101+prop_T_intercalate c = L.intercalate c `eq` (T.unpack . T.intercalate (T.pack c) . map T.pack)
100−prop_intersperse c = L.intersperse c `eqP` (unpack . T.intersperse c)
102+prop_T_intersperse c = L.intersperse c `eqP` (T.unpack . T.intersperse c)
101−prop_transpose = L.transpose `eq` (map unpack . T.transpose . map pack)
103+prop_T_transpose = L.transpose `eq` (map T.unpack . T.transpose . map T.pack)
102−prop_reverse = L.reverse `eqP` (unpack . T.reverse)
104+prop_T_reverse = L.reverse `eqP` (T.unpack . T.reverse)
103−prop_reverse_short n = L.reverse `eqP` (unpack . S.reverse . shorten n . stream)
105+prop_T_reverse_short n = L.reverse `eqP` (T.unpack . S.reverse . shorten n . S.stream)
104−
106+
105−prop_foldl f z = L.foldl f z `eqP` (T.foldl f z)
107+prop_T_foldl f z = L.foldl f z `eqP` (T.foldl f z)
106 where types = f :: Char -> Char -> Char
108 where types = f :: Char -> Char -> Char
107−prop_foldl' f z = L.foldl' f z `eqP` T.foldl' f z
109+prop_T_foldl' f z = L.foldl' f z `eqP` T.foldl' f z
108 where types = f :: Char -> Char -> Char
110 where types = f :: Char -> Char -> Char
109−prop_foldl1 f = L.foldl1 f `eqEP` T.foldl1 f
111+prop_T_foldl1 f = L.foldl1 f `eqEP` T.foldl1 f
110−prop_foldl1' f = L.foldl1' f `eqEP` T.foldl1' f
112+prop_T_foldl1' f = L.foldl1' f `eqEP` T.foldl1' f
111−prop_foldr f z = L.foldr f z `eqP` T.foldr f z
113+prop_T_foldr f z = L.foldr f z `eqP` T.foldr f z
112 where types = f :: Char -> Char -> Char
114 where types = f :: Char -> Char -> Char
113−prop_foldr1 f = L.foldr1 f `eqEP` T.foldr1 f
115+prop_T_foldr1 f = L.foldr1 f `eqEP` T.foldr1 f
114
116
115−prop_concat = L.concat `eq` (unpack . T.concat . map pack)
117+prop_T_concat = L.concat `eq` (T.unpack . T.concat . map T.pack)
116−prop_concatMap f = L.concatMap f `eqP` (unpack . T.concatMap (pack . f))
118+prop_T_concatMap f = L.concatMap f `eqP` (T.unpack . T.concatMap (T.pack . f))
117−prop_any p = L.any p `eqP` T.any p
119+prop_T_any p = L.any p `eqP` T.any p
118−prop_all p = L.all p `eqP` T.all p
120+prop_T_all p = L.all p `eqP` T.all p
119−prop_maximum = L.maximum `eqEP` T.maximum
121+prop_T_maximum = L.maximum `eqEP` T.maximum
120−prop_minimum = L.minimum `eqEP` T.minimum
122+prop_T_minimum = L.minimum `eqEP` T.minimum
121
123
122−prop_scanl f z = L.scanl f z `eqP` (unpack . T.scanl f z)
124+prop_T_scanl f z = L.scanl f z `eqP` (T.unpack . T.scanl f z)
123−prop_scanl1 f = L.scanl1 f `eqP` (unpack . T.scanl1 f)
125+prop_T_scanl1 f = L.scanl1 f `eqP` (T.unpack . T.scanl1 f)
124−prop_scanr f z = L.scanr f z `eqP` (unpack . T.scanr f z)
126+prop_T_scanr f z = L.scanr f z `eqP` (T.unpack . T.scanr f z)
125−prop_scanr1 f = L.scanr1 f `eqP` (unpack . T.scanr1 f)
127+prop_T_scanr1 f = L.scanr1 f `eqP` (T.unpack . T.scanr1 f)
126
128
127−prop_mapAccumL f z = L.mapAccumL f z `eqP` (second unpack . T.mapAccumL f z)
129+prop_T_mapAccumL f z = L.mapAccumL f z `eqP` (second T.unpack . T.mapAccumL f z)
128 where types = f :: Int -> Char -> (Int,Char)
130 where types = f :: Int -> Char -> (Int,Char)
129−prop_mapAccumR f z = L.mapAccumR f z `eqP` (second unpack . T.mapAccumR f z)
131+prop_T_mapAccumR f z = L.mapAccumR f z `eqP` (second T.unpack . T.mapAccumR f z)
130 where types = f :: Int -> Char -> (Int,Char)
132 where types = f :: Int -> Char -> (Int,Char)
131
133
132−prop_replicate n = L.replicate n `eq` (unpack . T.replicate n)
134+prop_T_replicate n = L.replicate n `eq` (T.unpack . T.replicate n)
133−prop_unfoldr n = L.unfoldr f `eq` (unpack . T.unfoldr f)
135+prop_T_unfoldr n = L.unfoldr f `eq` (T.unpack . T.unfoldr f)
134 where f c | fromEnum c * 100 > n = Nothing
136 where f c | fromEnum c * 100 > n = Nothing
135 | otherwise = Just (c, succ c)
137 | otherwise = Just (c, succ c)
136
138
137−prop_unfoldrN n m = (L.take n . L.unfoldr f) `eq` (unpack . T.unfoldrN n f)
139+prop_T_unfoldrN n m = (L.take n . L.unfoldr f) `eq` (T.unpack . T.unfoldrN n f)
138 where f c | fromEnum c * 100 > m = Nothing
140 where f c | fromEnum c * 100 > m = Nothing
139 | otherwise = Just (c, succ c)
141 | otherwise = Just (c, succ c)
140
142
141−unpack2 = unpack *** unpack
143+unpack2 = T.unpack *** T.unpack
142
144
143−prop_take n = L.take n `eqP` (unpack . T.take n)
145+prop_T_take n = L.take n `eqP` (T.unpack . T.take n)
144−prop_drop n = L.drop n `eqP` (unpack . T.drop n)
146+prop_T_drop n = L.drop n `eqP` (T.unpack . T.drop n)
145−prop_takeWhile p = L.takeWhile p `eqP` (unpack . T.takeWhile p)
147+prop_T_takeWhile p = L.takeWhile p `eqP` (T.unpack . T.takeWhile p)
146−prop_takeWhileS p = L.takeWhile p `eqP` (unpack . unstream . S.takeWhile p . stream)
148+prop_T_takeWhileS p = L.takeWhile p `eqP` (T.unpack . S.unstream . S.takeWhile p . S.stream)
147−prop_dropWhile p = L.dropWhile p `eqP` (unpack . T.dropWhile p)
149+prop_T_dropWhile p = L.dropWhile p `eqP` (T.unpack . T.dropWhile p)
148−prop_dropWhileS p = L.dropWhile p `eqP` (unpack . unstream . S.dropWhile p . stream)
150+prop_T_dropWhileS p = L.dropWhile p `eqP` (T.unpack . S.unstream . S.dropWhile p . S.stream)
149−prop_splitAt n = L.splitAt n `eqP` (unpack2 . T.splitAt n)
151+prop_T_splitAt n = L.splitAt n `eqP` (unpack2 . T.splitAt n)
150−prop_span p = L.span p `eqP` (unpack2 . T.span p)
152+prop_T_span p = L.span p `eqP` (unpack2 . T.span p)
151−prop_break p = L.break p `eqP` (unpack2 . T.break p)
153+prop_T_break p = L.break p `eqP` (unpack2 . T.break p)
152−prop_group = L.group `eqP` (map unpack . T.group)
154+prop_T_group = L.group `eqP` (map T.unpack . T.group)
153−prop_groupBy p = L.groupBy p `eqP` (map unpack . T.groupBy p)
155+prop_T_groupBy p = L.groupBy p `eqP` (map T.unpack . T.groupBy p)
154−prop_inits = L.inits `eqP` (map unpack . T.inits)
156+prop_T_inits = L.inits `eqP` (map T.unpack . T.inits)
155−prop_tails = L.tails `eqP` (map unpack . T.tails)
157+prop_T_tails = L.tails `eqP` (map T.unpack . T.tails)
156
158
157−prop_split_i c = id `eq` (T.intercalate (T.singleton c) . T.split c)
159+prop_T_split_i c = id `eq` (T.intercalate (T.singleton c) . T.split c)
158
160
159−prop_splitWith p = splitWith p `eqP` (map unpack . T.splitWith p)
161+prop_T_splitWith p = splitWith p `eqP` (map T.unpack . T.splitWith p)
160
162
161splitWith _ "" = []
163splitWith _ "" = []
162splitWith p s = if null s'
164splitWith p s = if null s'
@@ -164,16 +166,16 @@ splitWith p s = if null s'
164 else l : splitWith p (tail s')
166 else l : splitWith p (tail s')
165 where (l, s') = break p s
167 where (l, s') = break p s
166
168
167−prop_breakSubstring_isInfixOf s l
169+prop_T_breakSubstring_isInfixOf s l
168 = T.isInfixOf s l ==
170 = T.isInfixOf s l ==
169 T.null s || (not . T.null . snd $ T.breakSubstring s l)
171 T.null s || (not . T.null . snd $ T.breakSubstring s l)
170−prop_breakSubstringC c
172+prop_T_breakSubstringC c
171 = L.break (==c) `eqP`
173 = L.break (==c) `eqP`
172 (unpack2 . T.breakSubstring (T.singleton c))
174 (unpack2 . T.breakSubstring (T.singleton c))
173
175
174−prop_lines = L.lines `eqP` (map unpack . T.lines)
176+prop_T_lines = L.lines `eqP` (map T.unpack . T.lines)
175{-
177{-
176−prop_lines' = lines' `eqP` (map unpack . T.lines')
178+prop_T_lines' = lines' `eqP` (map T.unpack . T.lines')
177 where lines' "" = []
179 where lines' "" = []
178 lines' s = let (l, s') = break eol s
180 lines' s = let (l, s') = break eol s
179 in l : case s' of
181 in l : case s' of
@@ -182,28 +184,28 @@ prop_lines' = lines' `eqP` (map unpack . T.lines')
182 (_:s'') -> lines' s''
184 (_:s'') -> lines' s''
183 eol c = c == '\r' || c == '\n'
185 eol c = c == '\r' || c == '\n'
184-}
186-}
185−prop_words = L.words `eqP` (map unpack . T.words)
187+prop_T_words = L.words `eqP` (map T.unpack . T.words)
186−prop_unlines = L.unlines `eq` (unpack . T.unlines . map pack)
188+prop_T_unlines = L.unlines `eq` (T.unpack . T.unlines . map T.pack)
187−prop_unwords = L.unwords `eq` (unpack . T.unwords . map pack)
189+prop_T_unwords = L.unwords `eq` (T.unpack . T.unwords . map T.pack)
188−
190+
189−prop_isPrefixOf s = L.isPrefixOf s`eqP` T.isPrefixOf (pack s)
191+prop_T_isPrefixOf s = L.isPrefixOf s`eqP` T.isPrefixOf (T.pack s)
190−prop_isPrefixOfS s = L.isPrefixOf s`eqP` (S.isPrefixOf (stream $ pack s) . stream)
192+prop_T_isPrefixOfS s = L.isPrefixOf s`eqP` (S.isPrefixOf (S.stream $ T.pack s) . S.stream)
191−prop_isSuffixOf s = L.isSuffixOf s`eqP` T.isSuffixOf (pack s)
193+prop_T_isSuffixOf s = L.isSuffixOf s`eqP` T.isSuffixOf (T.pack s)
192−prop_isInfixOf s = L.isInfixOf s `eqP` T.isInfixOf (pack s)
194+prop_T_isInfixOf s = L.isInfixOf s `eqP` T.isInfixOf (T.pack s)
193−
195+
194−prop_elem c = L.elem c `eqP` T.elem c
196+prop_T_elem c = L.elem c `eqP` T.elem c
195−prop_filter p = L.filter p `eqP` (unpack . T.filter p)
197+prop_T_filter p = L.filter p `eqP` (T.unpack . T.filter p)
196−prop_find p = L.find p `eqP` T.find p
198+prop_T_find p = L.find p `eqP` T.find p
197−prop_partition p = L.partition p `eqP` (unpack2 . T.partition p)
199+prop_T_partition p = L.partition p `eqP` (unpack2 . T.partition p)
198−
200+
199−prop_index x s = x < L.length s && x >= 0 ==>
201+prop_T_index x s = x < L.length s && x >= 0 ==>
200− (L.!!) s x == T.index (pack s) x
202+ (L.!!) s x == T.index (T.pack s) x
201−prop_findIndex p = L.findIndex p `eqP` T.findIndex p
203+prop_T_findIndex p = L.findIndex p `eqP` T.findIndex p
202−prop_findIndices p = L.findIndices p`eqP` T.findIndices p
204+prop_T_findIndices p = L.findIndices p`eqP` T.findIndices p
203−prop_elemIndex c = L.elemIndex c `eqP` T.elemIndex c
205+prop_T_elemIndex c = L.elemIndex c `eqP` T.elemIndex c
204−prop_elemIndices c = L.elemIndices c`eqP` T.elemIndices c
206+prop_T_elemIndices c = L.elemIndices c`eqP` T.elemIndices c
205−prop_count c = (L.length . L.elemIndices c) `eqP` T.count c
207+prop_T_count c = (L.length . L.elemIndices c) `eqP` T.count c
206−prop_zipWith c s = L.zipWith c s `eqP` (unpack . T.zipWith c (pack s))
208+prop_T_zipWith c s = L.zipWith c s `eqP` (T.unpack . T.zipWith c (T.pack s))
207
209
208-- Make a stream appear shorter than it really is, to ensure that
210-- Make a stream appear shorter than it really is, to ensure that
209-- functions that consume inaccurately sized streams behave
211-- functions that consume inaccurately sized streams behave
@@ -228,106 +230,108 @@ run tests args = do
228
230
229tests :: [(String, Int -> IO (Bool, Int))]
231tests :: [(String, Int -> IO (Bool, Int))]
230tests = [
232tests = [
231− ("prop_pack_unpack", mytest prop_pack_unpack),
233+ ("prop_T_pack_unpack", mytest prop_T_pack_unpack),
232− ("prop_stream_unstream", mytest prop_stream_unstream),
234+ ("prop_TL_pack_unpack", mytest prop_TL_pack_unpack),
233− ("prop_reverse_stream", mytest prop_reverse_stream),
235+ ("prop_T_stream_unstream", mytest prop_T_stream_unstream),
234− ("prop_singleton", mytest prop_singleton),
236+ ("prop_TL_stream_unstream", mytest prop_TL_stream_unstream),
235−
237+ ("prop_T_reverse_stream", mytest prop_T_reverse_stream),
236− ("prop_ascii", mytest prop_ascii),
238+ ("prop_T_singleton", mytest prop_T_singleton),
237− ("prop_utf8", mytest prop_utf8),
239+
238− ("prop_utf16LE", mytest prop_utf16LE),
240+ ("prop_T_ascii", mytest prop_T_ascii),
239− ("prop_utf16BE", mytest prop_utf16BE),
241+ ("prop_T_utf8", mytest prop_T_utf8),
240− ("prop_utf32LE", mytest prop_utf32LE),
242+ ("prop_T_utf16LE", mytest prop_T_utf16LE),
241− ("prop_utf32BE", mytest prop_utf32BE),
243+ ("prop_T_utf16BE", mytest prop_T_utf16BE),
242−
244+ ("prop_T_utf32LE", mytest prop_T_utf32LE),
243− ("prop_cons", mytest prop_cons),
245+ ("prop_T_utf32BE", mytest prop_T_utf32BE),
244− ("prop_snoc", mytest prop_snoc),
246+
245− ("prop_append", mytest prop_append),
247+ ("prop_T_cons", mytest prop_T_cons),
246− ("prop_appendS", mytest prop_appendS),
248+ ("prop_T_snoc", mytest prop_T_snoc),
247− ("prop_uncons", mytest prop_uncons),
249+ ("prop_T_append", mytest prop_T_append),
248− ("prop_head", mytest prop_head),
250+ ("prop_T_appendS", mytest prop_T_appendS),
249− ("prop_last", mytest prop_last),
251+ ("prop_T_uncons", mytest prop_T_uncons),
250− ("prop_lastS", mytest prop_lastS),
252+ ("prop_T_head", mytest prop_T_head),
251− ("prop_tail", mytest prop_tail),
253+ ("prop_T_last", mytest prop_T_last),
252− ("prop_tailS", mytest prop_tailS),
254+ ("prop_T_lastS", mytest prop_T_lastS),
253− ("prop_init", mytest prop_init),
255+ ("prop_T_tail", mytest prop_T_tail),
254− ("prop_initS", mytest prop_initS),
256+ ("prop_T_tailS", mytest prop_T_tailS),
255− ("prop_null", mytest prop_null),
257+ ("prop_T_init", mytest prop_T_init),
256− ("prop_length", mytest prop_length),
258+ ("prop_T_initS", mytest prop_T_initS),
257−
259+ ("prop_T_null", mytest prop_T_null),
258− ("prop_map", mytest prop_map),
260+ ("prop_T_length", mytest prop_T_length),
259− ("prop_intercalate", mytest prop_intercalate),
261+
260− ("prop_intersperse", mytest prop_intersperse),
262+ ("prop_T_map", mytest prop_T_map),
261− ("prop_transpose", mytest prop_transpose),
263+ ("prop_T_intercalate", mytest prop_T_intercalate),
262− ("prop_reverse", mytest prop_reverse),
264+ ("prop_T_intersperse", mytest prop_T_intersperse),
263− ("prop_reverse_short", mytest prop_reverse_short),
265+ ("prop_T_transpose", mytest prop_T_transpose),
264−
266+ ("prop_T_reverse", mytest prop_T_reverse),
265− ("prop_foldl", mytest prop_foldl),
267+ ("prop_T_reverse_short", mytest prop_T_reverse_short),
266− ("prop_foldl'", mytest prop_foldl'),
268+
267− ("prop_foldl1", mytest prop_foldl1),
269+ ("prop_T_foldl", mytest prop_T_foldl),
268− ("prop_foldl1'", mytest prop_foldl1'),
270+ ("prop_T_foldl'", mytest prop_T_foldl'),
269− ("prop_foldr", mytest prop_foldr),
271+ ("prop_T_foldl1", mytest prop_T_foldl1),
270− ("prop_foldr1", mytest prop_foldr1),
272+ ("prop_T_foldl1'", mytest prop_T_foldl1'),
271−
273+ ("prop_T_foldr", mytest prop_T_foldr),
272− ("prop_concat", mytest prop_concat),
274+ ("prop_T_foldr1", mytest prop_T_foldr1),
273− ("prop_concatMap", mytest prop_concatMap),
275+
274− ("prop_any", mytest prop_any),
276+ ("prop_T_concat", mytest prop_T_concat),
275− ("prop_all", mytest prop_all),
277+ ("prop_T_concatMap", mytest prop_T_concatMap),
276− ("prop_maximum", mytest prop_maximum),
278+ ("prop_T_any", mytest prop_T_any),
277− ("prop_minimum", mytest prop_minimum),
279+ ("prop_T_all", mytest prop_T_all),
278−
280+ ("prop_T_maximum", mytest prop_T_maximum),
279− ("prop_scanl", mytest prop_scanl),
281+ ("prop_T_minimum", mytest prop_T_minimum),
280− ("prop_scanl1", mytest prop_scanl1),
282+
281− ("prop_scanr", mytest prop_scanr),
283+ ("prop_T_scanl", mytest prop_T_scanl),
282− ("prop_scanr1", mytest prop_scanr1),
284+ ("prop_T_scanl1", mytest prop_T_scanl1),
283−
285+ ("prop_T_scanr", mytest prop_T_scanr),
284− ("prop_mapAccumL", mytest prop_mapAccumL),
286+ ("prop_T_scanr1", mytest prop_T_scanr1),
285− ("prop_mapAccumR", mytest prop_mapAccumR),
287+
286−
288+ ("prop_T_mapAccumL", mytest prop_T_mapAccumL),
287− ("prop_replicate", mytest prop_replicate),
289+ ("prop_T_mapAccumR", mytest prop_T_mapAccumR),
288− ("prop_unfoldr", mytest prop_unfoldr),
290+
289− ("prop_unfoldrN", mytest prop_unfoldrN),
291+ ("prop_T_replicate", mytest prop_T_replicate),
290−
292+ ("prop_T_unfoldr", mytest prop_T_unfoldr),
291− ("prop_take", mytest prop_take),
293+ ("prop_T_unfoldrN", mytest prop_T_unfoldrN),
292− ("prop_drop", mytest prop_drop),
294+
293− ("prop_takeWhile", mytest prop_takeWhile),
295+ ("prop_T_take", mytest prop_T_take),
294− ("prop_takeWhileS", mytest prop_takeWhileS),
296+ ("prop_T_drop", mytest prop_T_drop),
295− ("prop_dropWhile", mytest prop_dropWhile),
297+ ("prop_T_takeWhile", mytest prop_T_takeWhile),
296− ("prop_dropWhileS", mytest prop_dropWhileS),
298+ ("prop_T_takeWhileS", mytest prop_T_takeWhileS),
297− ("prop_splitAt", mytest prop_splitAt),
299+ ("prop_T_dropWhile", mytest prop_T_dropWhile),
298− ("prop_span", mytest prop_span),
300+ ("prop_T_dropWhileS", mytest prop_T_dropWhileS),
299− ("prop_break", mytest prop_break),
301+ ("prop_T_splitAt", mytest prop_T_splitAt),
300− ("prop_group", mytest prop_group),
302+ ("prop_T_span", mytest prop_T_span),
301− ("prop_groupBy", mytest prop_groupBy),
303+ ("prop_T_break", mytest prop_T_break),
302− ("prop_inits", mytest prop_inits),
304+ ("prop_T_group", mytest prop_T_group),
303− ("prop_tails", mytest prop_tails),
305+ ("prop_T_groupBy", mytest prop_T_groupBy),
304−
306+ ("prop_T_inits", mytest prop_T_inits),
305− ("prop_split_i", mytest prop_split_i),
307+ ("prop_T_tails", mytest prop_T_tails),
306− ("prop_splitWith", mytest prop_splitWith),
308+
307− ("prop_breakSubstringC", mytest prop_breakSubstringC),
309+ ("prop_T_split_i", mytest prop_T_split_i),
308− ("prop_breakSubstring_isInfixOf", mytest prop_breakSubstring_isInfixOf),
310+ ("prop_T_splitWith", mytest prop_T_splitWith),
309−
311+ ("prop_T_breakSubstringC", mytest prop_T_breakSubstringC),
310− ("prop_lines", mytest prop_lines),
312+ ("prop_T_breakSubstring_isInfixOf", mytest prop_T_breakSubstring_isInfixOf),
311−--("prop_lines'", mytest prop_lines'),
313+
312− ("prop_words", mytest prop_words),
314+ ("prop_T_lines", mytest prop_T_lines),
313− ("prop_unlines", mytest prop_unlines),
315+--("prop_T_lines'", mytest prop_T_lines'),
314− ("prop_unwords", mytest prop_unwords),
316+ ("prop_T_words", mytest prop_T_words),
315−
317+ ("prop_T_unlines", mytest prop_T_unlines),
316− ("prop_isPrefixOf", mytest prop_isPrefixOf),
318+ ("prop_T_unwords", mytest prop_T_unwords),
317− ("prop_isPrefixOfS", mytest prop_isPrefixOfS),
319+
318− ("prop_isSuffixOf", mytest prop_isSuffixOf),
320+ ("prop_T_isPrefixOf", mytest prop_T_isPrefixOf),
319− ("prop_isInfixOf", mytest prop_isInfixOf),
321+ ("prop_T_isPrefixOfS", mytest prop_T_isPrefixOfS),
320−
322+ ("prop_T_isSuffixOf", mytest prop_T_isSuffixOf),
321− ("prop_elem", mytest prop_elem),
323+ ("prop_T_isInfixOf", mytest prop_T_isInfixOf),
322− ("prop_filter", mytest prop_filter),
324+
323− ("prop_find", mytest prop_find),
325+ ("prop_T_elem", mytest prop_T_elem),
324− ("prop_partition", mytest prop_partition),
326+ ("prop_T_filter", mytest prop_T_filter),
325−
327+ ("prop_T_find", mytest prop_T_find),
326− ("prop_index", mytest prop_index),
328+ ("prop_T_partition", mytest prop_T_partition),
327− ("prop_findIndex", mytest prop_findIndex),
329+
328− ("prop_findIndices", mytest prop_findIndices),
330+ ("prop_T_index", mytest prop_T_index),
329− ("prop_elemIndex", mytest prop_elemIndex),
331+ ("prop_T_findIndex", mytest prop_T_findIndex),
330− ("prop_elemIndices", mytest prop_elemIndices),
332+ ("prop_T_findIndices", mytest prop_T_findIndices),
331− ("prop_count", mytest prop_count),
333+ ("prop_T_elemIndex", mytest prop_T_elemIndex),
332− ("prop_zipWith", mytest prop_zipWith)
334+ ("prop_T_elemIndices", mytest prop_T_elemIndices),
335+ ("prop_T_count", mytest prop_T_count),
336+ ("prop_T_zipWith", mytest prop_T_zipWith)
333 ]
337 ]
tests/QuickCheckUtils.hs+9
@@ -5,6 +5,7 @@ module QuickCheckUtils where
5import Data.List
5import Data.List
6import Data.Word
6import Data.Word
7import qualified Data.Text as T
7import qualified Data.Text as T
8+import qualified Data.Text.Lazy as TL
8import System.IO
9import System.IO
9import System.Random
10import System.Random
10import Test.QuickCheck
11import Test.QuickCheck
@@ -43,6 +44,10 @@ instance Arbitrary T.Text where
43 arbitrary = T.pack `fmap` arbitrary
44 arbitrary = T.pack `fmap` arbitrary
44 coarbitrary s = coarbitrary (T.unpack s)
45 coarbitrary s = coarbitrary (T.unpack s)
45
46
47+instance Arbitrary TL.Text where
48+ arbitrary = TL.pack `fmap` arbitrary
49+ coarbitrary s = coarbitrary (TL.unpack s)
50+
46newtype NotEmpty a = NotEmpty { notEmpty :: a }
51newtype NotEmpty a = NotEmpty { notEmpty :: a }
47 deriving (Eq, Ord, Show)
52 deriving (Eq, Ord, Show)
48
53
@@ -57,6 +62,10 @@ instance Arbitrary (NotEmpty T.Text) where
57 arbitrary = (fmap T.pack) `fmap` arbitrary
62 arbitrary = (fmap T.pack) `fmap` arbitrary
58 coarbitrary = coarbitrary . notEmpty
63 coarbitrary = coarbitrary . notEmpty
59
64
65+instance Arbitrary (NotEmpty TL.Text) where
66+ arbitrary = (fmap TL.pack) `fmap` arbitrary
67+ coarbitrary = coarbitrary . notEmpty
68+
60instance Arbitrary (NotEmpty B.ByteString) where
69instance Arbitrary (NotEmpty B.ByteString) where
61 arbitrary = (fmap B.pack) `fmap` arbitrary
70 arbitrary = (fmap B.pack) `fmap` arbitrary
62 coarbitrary = coarbitrary . notEmpty
71 coarbitrary = coarbitrary . notEmpty
text.cabal+4
@@ -21,9 +21,13 @@ library
21 Data.Text.Encoding.Fusion
21 Data.Text.Encoding.Fusion
22 Data.Text.Foreign
22 Data.Text.Foreign
23 Data.Text.Fusion
23 Data.Text.Fusion
24+ Data.Text.Lazy
25+ Data.Text.Lazy.Fusion
24 other-modules:
26 other-modules:
25 Data.Text.Array
27 Data.Text.Array
26 Data.Text.Internal
28 Data.Text.Internal
29+ Data.Text.Fusion.Internal
30+ Data.Text.Lazy.Internal
27 Data.Text.Unsafe
31 Data.Text.Unsafe
28 Data.Text.UnsafeChar
32 Data.Text.UnsafeChar
29 Data.Text.Encoding.Utf8
33 Data.Text.Encoding.Utf8