Data.Text.Short

\mathcal{O}(0) The empty ShortText.

This is a type-specialised alias of mempty.

>>> empty""

>>> null emptyTrue

\mathcal{O}(1) Construct ShortText from single codepoint.

prop> singleton c == pack [c]

prop> length (singleton c) == 1

>>> singleton 'A'"A"

>>> map singleton ['\55295','\55296','\57343','\57344'] -- U+D7FF U+D800 U+DFFF U+E000["\55295","\65533","\65533","\57344"]

Note: This function is total because it replaces the (invalid) code-points U+D800 through U+DFFF with the replacement character U+FFFD.

\mathcal{O}(n) Construct a ShortText from a list of Chars.

This is an alias for fromString.

\mathcal{O}(n) Concatenate two ShortTexts

This is a type-specialised alias of <>.

>>> append "foo" "bar""foobar"

prop> length (append t1 t2) == length t1 + length t2

\mathcal{O}(n) Concatenate list of ShortTexts

This is a type-specialised alias of mconcat.

>>> concat []""

>>> concat ["foo","bar","doo"]"foobardoo"

\mathcal{O}(n) Prepend a character to a ShortText.

prop> cons c t == singleton c <> t

\mathcal{O}(n) Append a character to the ond of a ShortText.

prop> snoc t c == t <> singleton c

\mathcal{O}(n*m) Replicate a ShortText.

A repetition count smaller than 1 results in an empty string result.

>>> replicate 3 "jobs!""jobs!jobs!jobs!"

>>> replicate 10000 """"

>>> replicate 0 "nothing"""

prop> length (replicate n t) == max 0 n * length t

\mathcal{O}(n) Convert ShortText into a list of Chars.

This is an alias for toString.

prop> (pack . unpack) t == t

\mathcal{O}(n) Inverse operation to cons

Returns Nothing for empty input ShortText.

prop> uncons (cons c t) == Just (c,t)

>>> uncons ""Nothing

>>> uncons "fmap"Just ('f',"map")

\mathcal{O}(n) Inverse operation to snoc

Returns Nothing for empty input ShortText.

prop> unsnoc (snoc t c) == Just (t,c)

>>> unsnoc ""Nothing

>>> unsnoc "fmap"Just ("fma",'p')

\mathcal{O}(1) Test whether a ShortText is empty.

>>> null ""True

prop> null (singleton c) == False

prop> null t == (length t == 0)

\mathcal{O}(n) Count the number of Unicode code-points in a ShortText.

>>> length "abcd€"5

>>> length ""0

prop> length t >= 0

\mathcal{O}(n) Test whether ShortText contains only ASCII code-points (i.e. only U+0000 through U+007F).

This is a more efficient version of all isAscii.

>>> isAscii ""True

>>> isAscii "abc\NUL"True

>>> isAscii "abcd€"False

prop> isAscii t == all (< '\x80') t

\mathcal{O}(n) Test whether all code points in ShortText satisfy a predicate.

>>> all (const False) ""True

>>> all (> 'c') "abcdabcd"False

>>> all (/= 'c') "abdabd"True

\mathcal{O}(n) Test whether any code points in ShortText satisfy a predicate.

>>> any (> 'c') "abcdabcd"True

>>> any (const True) ""False

>>> any (== 'c') "abdabd"False

prop> any p t == not (all (not . p) t)

\mathcal{O}(n) Return the left-most codepoint in ShortText that satisfies the given predicate.

>>> find (> 'b') "abcdabcd"Just 'c'

>>> find (> 'b') "ababab"Nothing

\mathcal{O}(n) Tests whether the first ShortText is a prefix of the second ShortText

>>> isPrefixOf "ab" "abcdef"True

>>> isPrefixOf "ac" "abcdef"False

prop> isPrefixOf "" t == True

prop> isPrefixOf t t == True

\mathcal{O}(n) Tests whether the first ShortText is a suffix of the second ShortText

>>> isSuffixOf "ef" "abcdef"True

>>> isPrefixOf "df" "abcdef"False

prop> isSuffixOf "" t == True

prop> isSuffixOf t t == True

\mathcal{O}(n) Index i-th code-point in ShortText.

Infix operator alias of indexMaybe

>>> "abcdefg" !? 2Just 'c'

\mathcal{O}(n) Lookup i-th code-point in ShortText.

Returns Nothing if out of bounds.

prop> indexMaybe (singleton c) 0 == Just c

prop> indexMaybe t 0 == fmap fst (uncons t)

prop> indexMaybe mempty i == Nothing

\mathcal{O}(n) Lookup i-th code-point from the end of ShortText.

Returns Nothing if out of bounds.

prop> indexEndMaybe (singleton c) 0 == Just c

prop> indexEndMaybe t 0 == fmap snd (unsnoc t)

prop> indexEndMaybe mempty i == Nothing

\mathcal{O}(n) Return the index of the left-most codepoint in ShortText that satisfies the given predicate.

>>> findIndex (> 'b') "abcdabcdef"Just 2

>>> findIndex (> 'b') "ababab"Nothing

prop> (indexMaybe t =<< findIndex p t) == find p t

\mathcal{O}(n) Take prefix of given length or return whole ShortText if too short.

>>> take 3 "abcdef""abc"

>>> take 3 "ab""ab"

\mathcal{O}(n) Take suffix of given length or return whole ShortText if too short.

>>> takeEnd 3 "abcdefg""efg"

>>> takeEnd 3 "ab""ab"

\mathcal{O}(n) Take remove prefix of given length from ShortText or return empty ShortText if too short.

>>> drop 4 "abcdef""ef"

>>> drop 4 "ab"""

\mathcal{O}(n) Take remove suffix of given length from ShortText or return empty ShortText if too short.

>>> drop 4 "abcdefghi""efghi"

>>> drop 4 "ab"""

\mathcal{O}(n) Take longest prefix satisfying given predicate.

prop> takeWhile p t == fst (span p t)

>>> takeWhile (< 'c') "abcdabcd""ab"

\mathcal{O}(n) Take longest suffix satisfying given predicate.

prop> takeWhileEnd p t == snd (spanEnd p t)

>>> takeWhileEnd (>= 'c') "abcdabcd""cd"

\mathcal{O}(n) Remove longest prefix satisfying given predicate.

prop> dropWhile p t == snd (span p t)

>>> dropWhile (< 'c') "abcdabcd""cdabcd"

\mathcal{O}(n) Remove longest suffix satisfying given predicate.

prop> dropWhileEnd p t == fst (spanEnd p t)

>>> dropWhileEnd (>= 'c') "abcdabcd""abcdab"

\mathcal{O}(n) Strip characters from the beginning end and of ShortText which satisfy given predicate.

>>> dropAround (== ' ') "   white   space   ""white   space"

>>> dropAround (> 'a') "bcdefghi"""

\mathcal{O}(n) Split ShortText into two halves.

splitAt n t returns a pair of ShortText with the following properties:

prop> length (fst (splitAt n t)) == min (length t) (max 0 n)

prop> fst (splitAt n t) <> snd (splitAt n t) == t

>>> splitAt 2 "abcdef"("ab","cdef")

>>> splitAt 10 "abcdef"("abcdef","")

>>> splitAt (-1) "abcdef"("","abcdef")

\mathcal{O}(n) Split ShortText into two halves.

splitAtEnd n t returns a pair of ShortText with the following properties:

prop> length (snd (splitAtEnd n t)) == min (length t) (max 0 n)

prop> fst (splitAtEnd n t) <> snd (splitAtEnd n t) == t

prop> splitAtEnd n t == splitAt (length t - n) t

>>> splitAtEnd 2 "abcdef"("abcd","ef")

>>> splitAtEnd 10 "abcdef"("","abcdef")

>>> splitAtEnd (-1) "abcdef"("abcdef","")

\mathcal{O}(n) Split ShortText into longest prefix satisfying the given predicate and the remaining suffix.

>>> span (< 'c') "abcdabcd"("ab","cdabcd")

prop> fst (span p t) <> snd (span p t) == t

\mathcal{O}(n) Variant of span with negated predicate.

>>> break (> 'c') "abcdabcd"("abc","dabcd")

prop> break p t == span (not . p) t

prop> fst (break p t) <> snd (break p t) == t

\mathcal{O}(n) Split ShortText into longest suffix satisfying the given predicate and the preceding prefix.

>>> spanEnd (> 'c') "abcdabcd"("abcdabc","d")

prop> fst (spanEnd p t) <> snd (spanEnd p t) == t

\mathcal{O}(n) Variant of spanEnd with negated predicate.

>>> breakEnd (< 'c') "abcdabcd"("abcdab","cd")

prop> breakEnd p t == spanEnd (not . p) t

prop> fst (breakEnd p t) <> snd (breakEnd p t) == t

\mathcal{O}(n) Splits a string into components delimited by separators, where the predicate returns True for a separator element. The resulting components do not contain the separators. Two adjacent separators result in an empty component in the output. eg.

>>> split (=='a') "aabbaca"["","","bb","c",""]

>>> split (=='a') ""[""]

prop> intercalate (singleton c) (split (== c) t) = t

NOTE: split never returns an empty list to match the semantics of its counterpart from Data.Text.

\mathcal{O}(n) Strip prefix from second ShortText argument.

Returns Nothing if first argument is not a prefix of the second argument.

>>> stripPrefix "text-" "text-short"Just "short"

>>> stripPrefix "test-" "text-short"Nothing

\mathcal{O}(n) Strip suffix from second ShortText argument.

Returns Nothing if first argument is not a suffix of the second argument.

>>> stripSuffix "-short" "text-short"Just "text"

>>> stripSuffix "-utf8" "text-short"Nothing

\mathcal{O}(n) Construct/pack from String

>>> fromString []""

>>> fromString ['a','b','c']"abc"

>>> fromString ['\55295','\55296','\57343','\57344'] -- U+D7FF U+D800 U+DFFF U+E000"\55295\65533\65533\57344"

Note: This function is total because it replaces the (invalid) code-points U+D800 through U+DFFF with the replacement character U+FFFD.

\mathcal{O}(n) Convert to String

prop> (fromString . toString) t == t

Note: See documentation of fromString for why (toString . fromString) is not an identity function.

\mathcal{O}(n) Construct ShortText from Text

This is \mathcal{O}(1) with text-2 when the Text is not sliced. Previously it wasn't because Text used UTF-16 as its internal representation.

\mathcal{O}(n) Convert to Text

prop> (fromText . toText) t == t

prop> (toText . fromText) t == t

This is \mathcal{O}(1) with text-2. Previously it wasn't because Text used UTF-16 as its internal representation.

\mathcal{O}(n) Construct ShortText from UTF-8 encoded ShortByteString

This operation doesn't copy the input ShortByteString but it cannot be \mathcal{O}(1) because we need to validate the UTF-8 encoding.

Returns Nothing in case of invalid UTF-8 encoding.

>>> fromShortByteString "\x00\x38\xF0\x90\x8C\x9A" -- U+00 U+38 U+1031AJust "\NUL8\66330"

>>> fromShortByteString "\xC0\x80" -- invalid denormalised U+00Nothing

>>> fromShortByteString "\xED\xA0\x80" -- U+D800 (non-scalar code-point)Nothing

>>> fromShortByteString "\xF4\x8f\xbf\xbf" -- U+10FFFFJust "\1114111"

>>> fromShortByteString "\xF4\x90\x80\x80" -- U+110000 (invalid)Nothing

prop> fromShortByteString (toShortByteString t) == Just t

\mathcal{O}(0) Converts to UTF-8 encoded ShortByteString

This operation has effectively no overhead, as it's currently merely a newtype-cast.

\mathcal{O}(n) Construct ShortText from UTF-8 encoded ByteString

fromByteString accepts (or rejects) the same input data as fromShortByteString.

Returns Nothing in case of invalid UTF-8 encoding.

\mathcal{O}(n) Converts to UTF-8 encoded ByteString

Construct a Builder that encodes ShortText as UTF-8.