Copyright | Gautier DI FOLCO |
---|---|
License | BSD2 |
Maintainer | Gautier DI FOLCO <gautier.difolco@gmail.com> |
Stability | Unstable |
Portability | GHC |
Safe Haskell | None |
Language | Haskell2010 |
Synopsis
- type NonEmptyText = NonEmptyStrictText
- type NonEmptyStrictText = NonEmpty Text
- pack :: NonEmpty String -> NonEmptyStrictText
- unpack :: HasCallStack => NonEmptyStrictText -> NonEmpty String
- singleton :: NonEmptySingleton a => Proxy a -> NonEmptySingletonElement a -> NonEmpty a
- cons :: Char -> NonEmptyStrictText -> NonEmptyStrictText
- snoc :: NonEmptyStrictText -> Char -> NonEmptyStrictText
- uncons :: NonEmptyStrictText -> (Char, Text)
- unsnoc :: NonEmptyStrictText -> (Text, Char)
- head :: NonEmptyStrictText -> Char
- last :: NonEmptyStrictText -> Char
- tail :: NonEmptyStrictText -> Text
- init :: NonEmptyStrictText -> Text
- length :: NonEmptyStrictText -> Int
- compareLength :: NonEmptyStrictText -> Int -> Ordering
- map :: (Char -> Char) -> NonEmptyStrictText -> NonEmptyStrictText
- intercalate :: Text -> NonEmpty [NonEmptyStrictText] -> NonEmptyStrictText
- intersperse :: Char -> NonEmptyStrictText -> NonEmptyStrictText
- transpose :: NonEmpty [NonEmptyStrictText] -> NonEmpty [NonEmptyStrictText]
- reverse :: HasCallStack => NonEmptyStrictText -> NonEmptyStrictText
- replace :: NonEmptyStrictText -> NonEmptyStrictText -> NonEmptyStrictText -> NonEmptyStrictText
- toCaseFold :: NonEmptyStrictText -> NonEmptyStrictText
- toLower :: NonEmptyStrictText -> NonEmptyStrictText
- toUpper :: NonEmptyStrictText -> NonEmptyStrictText
- toTitle :: NonEmptyStrictText -> NonEmptyStrictText
- justifyLeft :: Int -> Char -> NonEmptyStrictText -> NonEmptyStrictText
- justifyRight :: Int -> Char -> NonEmptyStrictText -> NonEmptyStrictText
- center :: Int -> Char -> NonEmptyStrictText -> NonEmptyStrictText
- foldl :: (a -> Char -> a) -> a -> NonEmptyStrictText -> a
- foldl' :: (a -> Char -> a) -> a -> NonEmptyStrictText -> a
- foldl1 :: (Char -> Char -> Char) -> NonEmptyStrictText -> Char
- foldl1' :: (Char -> Char -> Char) -> NonEmptyStrictText -> Char
- foldr :: (Char -> a -> a) -> a -> NonEmptyStrictText -> a
- foldr1 :: (Char -> Char -> Char) -> NonEmptyStrictText -> Char
- concat :: NonEmpty [NonEmptyStrictText] -> NonEmptyStrictText
- concatMap :: (Char -> NonEmptyStrictText) -> NonEmptyStrictText -> NonEmptyStrictText
- any :: (Char -> Bool) -> NonEmptyStrictText -> Bool
- all :: (Char -> Bool) -> NonEmptyStrictText -> Bool
- maximum :: NonEmptyStrictText -> Char
- minimum :: NonEmptyStrictText -> Char
- scanl :: (Char -> Char -> Char) -> Char -> NonEmptyStrictText -> NonEmptyStrictText
- scanl1 :: (Char -> Char -> Char) -> NonEmptyStrictText -> NonEmptyStrictText
- scanr :: (Char -> Char -> Char) -> Char -> NonEmptyStrictText -> NonEmptyStrictText
- scanr1 :: (Char -> Char -> Char) -> NonEmptyStrictText -> NonEmptyStrictText
- mapAccumL :: forall a. (a -> Char -> (a, Char)) -> a -> NonEmptyStrictText -> (a, NonEmptyStrictText)
- mapAccumR :: forall a. (a -> Char -> (a, Char)) -> a -> NonEmptyStrictText -> (a, NonEmptyStrictText)
- replicate :: Int -> NonEmptyStrictText -> NonEmptyStrictText
- take :: Int -> NonEmptyStrictText -> Text
- takeEnd :: Int -> NonEmptyStrictText -> Text
- drop :: Int -> NonEmptyStrictText -> Text
- dropEnd :: Int -> NonEmptyStrictText -> Text
- takeWhile :: (Char -> Bool) -> NonEmptyStrictText -> Text
- takeWhileEnd :: (Char -> Bool) -> NonEmptyStrictText -> Text
- dropWhile :: (Char -> Bool) -> NonEmptyStrictText -> Text
- dropWhileEnd :: (Char -> Bool) -> NonEmptyStrictText -> Text
- dropAround :: (Char -> Bool) -> NonEmptyStrictText -> Text
- strip :: NonEmptyStrictText -> Text
- stripStart :: NonEmptyStrictText -> Text
- stripEnd :: NonEmptyStrictText -> Text
- splitAt :: Int -> NonEmptyStrictText -> (Text, Text)
- breakOn :: NonEmptyStrictText -> NonEmptyStrictText -> (Text, Text)
- breakOnEnd :: NonEmptyStrictText -> NonEmptyStrictText -> (Text, Text)
- break :: (Char -> Bool) -> NonEmptyStrictText -> (Text, Text)
- span :: (Char -> Bool) -> NonEmptyStrictText -> (Text, Text)
- group :: NonEmptyStrictText -> NonEmpty [NonEmptyStrictText]
- groupBy :: (Char -> Char -> Bool) -> NonEmptyStrictText -> NonEmpty [Text]
- inits :: NonEmptyStrictText -> NonEmpty [Text]
- tails :: NonEmptyStrictText -> NonEmpty [Text]
- splitOn :: NonEmptyStrictText -> NonEmptyStrictText -> NonEmpty [Text]
- split :: (Char -> Bool) -> NonEmptyStrictText -> NonEmpty [Text]
- chunksOf :: Int -> NonEmptyStrictText -> [Text]
- lines :: NonEmptyStrictText -> NonEmpty [NonEmptyStrictText]
- words :: NonEmptyStrictText -> NonEmpty [NonEmptyStrictText]
- unlines :: NonEmpty [NonEmptyStrictText] -> NonEmptyStrictText
- unwords :: NonEmpty [NonEmptyStrictText] -> NonEmptyStrictText
- isPrefixOf :: NonEmptyStrictText -> NonEmptyStrictText -> Bool
- isSuffixOf :: NonEmptyStrictText -> NonEmptyStrictText -> Bool
- isInfixOf :: HasCallStack => NonEmptyStrictText -> NonEmptyStrictText -> Bool
- stripPrefix :: NonEmptyStrictText -> NonEmptyStrictText -> Maybe Text
- stripSuffix :: NonEmptyStrictText -> NonEmptyStrictText -> Maybe Text
- commonPrefixes :: NonEmptyStrictText -> NonEmptyStrictText -> Maybe (Text, Text, Text)
- filter :: (Char -> Bool) -> NonEmptyStrictText -> Text
- breakOnAll :: NonEmptyStrictText -> NonEmptyStrictText -> [(Text, Text)]
- find :: (Char -> Bool) -> NonEmptyStrictText -> Maybe Char
- partition :: (Char -> Bool) -> NonEmptyStrictText -> (Text, Text)
- index :: HasCallStack => NonEmptyStrictText -> Int -> Char
- findIndex :: (Char -> Bool) -> NonEmptyStrictText -> Maybe Int
- count :: NonEmptyStrictText -> NonEmptyStrictText -> Int
- zip :: NonEmptyStrictText -> NonEmptyStrictText -> NonEmpty [(Char, Char)]
- zipWith :: (Char -> Char -> Char) -> NonEmptyStrictText -> NonEmptyStrictText -> NonEmptyStrictText
Types
type NonEmptyText = NonEmptyStrictText Source #
type NonEmptyStrictText = NonEmpty Text Source #
Creation and elimination
pack :: NonEmpty String -> NonEmptyStrictText Source #
O(n) Convert a 'NonEmpty String' into a NonEmptyStrictText
.
Performs replacement on invalid scalar values.
unpack :: HasCallStack => NonEmptyStrictText -> NonEmpty String Source #
O(n) Convert a NonEmptyStrictText
into a 'NonEmpty String'.
singleton :: NonEmptySingleton a => Proxy a -> NonEmptySingletonElement a -> NonEmpty a #
Build a NonEmpty
value from a singleton value
Basic interface
cons :: Char -> NonEmptyStrictText -> NonEmptyStrictText infixr 5 Source #
O(n) Adds a character to the front of a NonEmptyStrictText
. This function
is more costly than its List
counterpart because it requires
copying a new array. Performs replacement on
invalid scalar values.
snoc :: NonEmptyStrictText -> Char -> NonEmptyStrictText Source #
O(n) Adds a character to the end of a NonEmptyStrictText
. This copies the
entire array in the process.
Performs replacement on invalid scalar values.
uncons :: NonEmptyStrictText -> (Char, Text) Source #
O(1) Returns the first character and rest of a NonEmptyStrictText
.
unsnoc :: NonEmptyStrictText -> (Text, Char) Source #
O(1) Returns all but the last character and the last character of a
NonEmptyStrictText
.
head :: NonEmptyStrictText -> Char Source #
O(1) Returns the first character of a NonEmptyStrictText
.
last :: NonEmptyStrictText -> Char Source #
O(1) Returns the last character of a NonEmptyStrictText
.
tail :: NonEmptyStrictText -> Text Source #
O(1) Returns all characters after the head of a NonEmptyStrictText
.
init :: NonEmptyStrictText -> Text Source #
O(1) Returns all but the last character of a NonEmptyStrictText
.
length :: NonEmptyStrictText -> Int Source #
O(n) Returns the number of characters in a NonEmptyStrictText
.
compareLength :: NonEmptyStrictText -> Int -> Ordering Source #
O(min(n,c)) Compare the count of characters in a NonEmptyStrictText
to a number.
compareLength
t c =compare
(length
t) c
This function gives the same answer as comparing against the result
of length
, but can short circuit if the count of characters is
greater than the number, and hence be more efficient.
Transformations
map :: (Char -> Char) -> NonEmptyStrictText -> NonEmptyStrictText Source #
O(n) map
f
t
is the NonEmptyStrictText
obtained by applying f
to
each element of t
.
Example:
>>>
let message = pack "I am not angry. Not at all."
>>>
T.map (\c -> if c == '.' then '!' else c) message
"I am not angry! Not at all!"
Performs replacement on invalid scalar values.
intercalate :: Text -> NonEmpty [NonEmptyStrictText] -> NonEmptyStrictText Source #
O(n) The intercalate
function takes a NonEmptyStrictText
and a list of
NonEmptyStrictText
s and concatenates the list after interspersing the first
argument between each element of the list.
Example:
>>>
T.intercalate "NI!" ["We", "seek", "the", "Holy", "Grail"]
"WeNI!seekNI!theNI!HolyNI!Grail"
intersperse :: Char -> NonEmptyStrictText -> NonEmptyStrictText Source #
O(n) The intersperse
function takes a character and places it
between the characters of a NonEmptyStrictText
.
Example:
>>>
T.intersperse '.' "SHIELD"
"S.H.I.E.L.D"
Performs replacement on invalid scalar values.
transpose :: NonEmpty [NonEmptyStrictText] -> NonEmpty [NonEmptyStrictText] Source #
O(n) The transpose
function transposes the rows and columns
of its NonEmptyStrictText
argument. Note that this function uses pack
,
unpack
, and the list version of transpose, and is thus not very
efficient.
Examples:
>>>
transpose ["green","orange"]
["go","rr","ea","en","ng","e"]
>>>
transpose ["blue","red"]
["br","le","ud","e"]
reverse :: HasCallStack => NonEmptyStrictText -> NonEmptyStrictText Source #
O(n) Reverse the characters of a string.
Example:
>>>
T.reverse "desrever"
"reversed"
:: NonEmptyStrictText |
|
-> NonEmptyStrictText |
|
-> NonEmptyStrictText |
|
-> NonEmptyStrictText |
O(m+n) Replace every non-overlapping occurrence of needle
in
haystack
with replacement
.
This function behaves as though it was defined as follows:
replace needle replacement haystack =intercalate
replacement (splitOn
needle haystack)
As this suggests, each occurrence is replaced exactly once. So if
needle
occurs in replacement
, that occurrence will not itself
be replaced recursively:
>>>
replace "oo" "foo" "oo"
"foo"
In cases where several instances of needle
overlap, only the
first one will be replaced:
>>>
replace "ofo" "bar" "ofofo"
"barfo"
In (unlikely) bad cases, this function's time complexity degrades towards O(n*m).
Case conversion
When case converting NonEmptyStrictText
values, do not use combinators like
map toUpper
to case convert each character of a string
individually, as this gives incorrect results according to the
rules of some writing systems. The whole-string case conversion
functions from this module, such as toUpper
, obey the correct
case conversion rules. As a result, these functions may map one
input character to two or three output characters. For examples,
see the documentation of each function.
Note: In some languages, case conversion is a locale- and context-dependent operation. The case conversion functions in this module are not locale sensitive. Programs that require locale sensitivity should use appropriate versions of the case mapping functions from the text-icu package.
toCaseFold :: NonEmptyStrictText -> NonEmptyStrictText Source #
O(n) Convert a string to folded case.
This function is mainly useful for performing caseless (also known as case insensitive) string comparisons.
A string x
is a caseless match for a string y
if and only if:
toCaseFold x == toCaseFold y
The result string may be longer than the input string, and may
differ from applying toLower
to the input string. For instance,
the Armenian small ligature "ﬓ" (men now, U+FB13) is case
folded to the sequence "մ" (men, U+0574) followed by
"ն" (now, U+0576), while the Greek "µ" (micro sign,
U+00B5) is case folded to "μ" (small letter mu, U+03BC)
instead of itself.
toLower :: NonEmptyStrictText -> NonEmptyStrictText Source #
O(n) Convert a string to lower case, using simple case conversion.
The result string may be longer than the input string. For instance, "İ" (Latin capital letter I with dot above, U+0130) maps to the sequence "i" (Latin small letter i, U+0069) followed by " ̇" (combining dot above, U+0307).
toUpper :: NonEmptyStrictText -> NonEmptyStrictText Source #
O(n) Convert a string to upper case, using simple case conversion.
The result string may be longer than the input string. For instance, the German "ß" (eszett, U+00DF) maps to the two-letter sequence "SS".
toTitle :: NonEmptyStrictText -> NonEmptyStrictText Source #
O(n) Convert a string to title case, using simple case conversion.
The first letter of the input is converted to title case, as is every subsequent letter that immediately follows a non-letter. Every letter that immediately follows another letter is converted to lower case.
The result string may be longer than the input string. For example, the Latin small ligature fl (U+FB02) is converted to the sequence Latin capital letter F (U+0046) followed by Latin small letter l (U+006C).
Note: this function does not take language or culture specific rules into account. For instance, in English, different style guides disagree on whether the book name "The Hill of the Red Fox" is correctly title cased—but this function will capitalize every word.
Justification
justifyLeft :: Int -> Char -> NonEmptyStrictText -> NonEmptyStrictText Source #
O(n) Left-justify a string to the given length, using the specified fill character on the right. Performs replacement on invalid scalar values.
Examples:
>>>
justifyLeft 7 'x' "foo"
"fooxxxx"
>>>
justifyLeft 3 'x' "foobar"
"foobar"
justifyRight :: Int -> Char -> NonEmptyStrictText -> NonEmptyStrictText Source #
O(n) Right-justify a string to the given length, using the specified fill character on the left. Performs replacement on invalid scalar values.
Examples:
>>>
justifyRight 7 'x' "bar"
"xxxxbar"
>>>
justifyRight 3 'x' "foobar"
"foobar"
center :: Int -> Char -> NonEmptyStrictText -> NonEmptyStrictText Source #
O(n) Center a string to the given length, using the specified fill character on either side. Performs replacement on invalid scalar values.
Examples:
>>>
center 8 'x' "HS"
"xxxHSxxx"
Folds
foldl :: (a -> Char -> a) -> a -> NonEmptyStrictText -> a Source #
O(n) foldl
, applied to a binary operator, a starting value
(typically the left-identity of the operator), and a NonEmptyStrictText
,
reduces the NonEmptyStrictText
using the binary operator, from left to right.
foldl1 :: (Char -> Char -> Char) -> NonEmptyStrictText -> Char Source #
O(n) A variant of foldl
that has no starting value argument.
foldl1' :: (Char -> Char -> Char) -> NonEmptyStrictText -> Char Source #
O(n) A strict version of foldl1
.
foldr :: (Char -> a -> a) -> a -> NonEmptyStrictText -> a Source #
O(n) foldr
, applied to a binary operator, a starting value
(typically the right-identity of the operator), and a NonEmptyStrictText
,
reduces the NonEmptyStrictText
using the binary operator, from right to left.
If the binary operator is strict in its second argument, use foldr'
instead.
foldr
is lazy like foldr
for lists: evaluation actually
traverses the NonEmptyStrictText
from left to right, only as far as it needs to.
@
Searches from left to right with short-circuiting behavior can
also be defined using foldr
(e.g., any
, all
, find
, elem
).
foldr1 :: (Char -> Char -> Char) -> NonEmptyStrictText -> Char Source #
O(n) A variant of foldr
that has no starting value argument.
Special folds
concat :: NonEmpty [NonEmptyStrictText] -> NonEmptyStrictText Source #
O(n) Concatenate a list of NonEmptyStrictText
s.
concatMap :: (Char -> NonEmptyStrictText) -> NonEmptyStrictText -> NonEmptyStrictText Source #
O(n) Map a function over a NonEmptyStrictText
that results in a NonEmptyStrictText
, and
concatenate the results.
any :: (Char -> Bool) -> NonEmptyStrictText -> Bool Source #
O(n) any
p
t
determines whether any character in the
NonEmptyStrictText
t
satisfies the predicate p
.
all :: (Char -> Bool) -> NonEmptyStrictText -> Bool Source #
O(n) all
p
t
determines whether all characters in the
NonEmptyStrictText
t
satisfy the predicate p
.
maximum :: NonEmptyStrictText -> Char Source #
O(n) maximum
returns the maximum value from a NonEmptyStrictText
.
minimum :: NonEmptyStrictText -> Char Source #
O(n) minimum
returns the minimum value from a NonEmptyStrictText
.
Construction
Scans
scanl :: (Char -> Char -> Char) -> Char -> NonEmptyStrictText -> NonEmptyStrictText Source #
scanl1 :: (Char -> Char -> Char) -> NonEmptyStrictText -> NonEmptyStrictText Source #
scanr :: (Char -> Char -> Char) -> Char -> NonEmptyStrictText -> NonEmptyStrictText Source #
scanr1 :: (Char -> Char -> Char) -> NonEmptyStrictText -> NonEmptyStrictText Source #
Accumulating maps
mapAccumL :: forall a. (a -> Char -> (a, Char)) -> a -> NonEmptyStrictText -> (a, NonEmptyStrictText) Source #
O(n) Like a combination of map
and foldl'
. Applies a
function to each element of a NonEmptyStrictText
, passing an accumulating
parameter from left to right, and returns a final NonEmptyStrictText
. Performs
replacement on invalid scalar values.
mapAccumR :: forall a. (a -> Char -> (a, Char)) -> a -> NonEmptyStrictText -> (a, NonEmptyStrictText) Source #
The mapAccumR
function behaves like a combination of map
and
a strict foldr
; it applies a function to each element of a
NonEmptyStrictText
, passing an accumulating parameter from right to left, and
returning a final value of this accumulator together with the new
NonEmptyStrictText
.
Performs replacement on invalid scalar values.
Generation and unfolding
replicate :: Int -> NonEmptyStrictText -> NonEmptyStrictText Source #
O(n*m) replicate
n
t
is a NonEmptyStrictText
consisting of the input
t
repeated n
times, n
should be strictly positive.
Substrings
Breaking strings
take :: Int -> NonEmptyStrictText -> Text Source #
O(n) take
n
, applied to a NonEmptyStrictText
, returns the prefix of the
Text
of length n
, or the Text
itself if n
is greater than
the length of the NonEmptyStrictText.
takeEnd :: Int -> NonEmptyStrictText -> Text Source #
O(n) takeEnd
n
t
returns the suffix remaining after
taking n
characters from the end of t
.
Examples:
>>>
takeEnd 3 "foobar"
"bar"
drop :: Int -> NonEmptyStrictText -> Text Source #
O(n) drop
n
, applied to a NonEmptyStrictText
, returns the suffix of the
Text
after the first n
characters, or the empty Text
if n
is greater than the length of the NonEmptyStrictText
.
dropEnd :: Int -> NonEmptyStrictText -> Text Source #
O(n) dropEnd
n
t
returns the prefix remaining after
dropping n
characters from the end of t
.
Examples:
>>>
dropEnd 3 "foobar"
"foo"
takeWhile :: (Char -> Bool) -> NonEmptyStrictText -> Text Source #
O(n) takeWhile
, applied to a predicate p
and a NonEmptyStrictText
,
returns the longest prefix (possibly empty) of elements that
satisfy p
.
takeWhileEnd :: (Char -> Bool) -> NonEmptyStrictText -> Text Source #
O(n) takeWhileEnd
, applied to a predicate p
and a NonEmptyStrictText
,
returns the longest suffix (possibly empty) of elements that
satisfy p
.
Examples:
>>>
takeWhileEnd (=='o') "foo"
"oo"
dropWhileEnd :: (Char -> Bool) -> NonEmptyStrictText -> Text Source #
O(n) dropWhileEnd
p
t
returns the prefix remaining after
dropping characters that satisfy the predicate p
from the end of
t
.
Examples:
>>>
dropWhileEnd (=='.') "foo..."
"foo"
dropAround :: (Char -> Bool) -> NonEmptyStrictText -> Text Source #
O(n) dropAround
p
t
returns the substring remaining after
dropping characters that satisfy the predicate p
from both the
beginning and end of t
.
strip :: NonEmptyStrictText -> Text Source #
O(n) Remove leading and trailing white space from a string. Equivalent to:
dropAround isSpace
stripStart :: NonEmptyStrictText -> Text Source #
O(n) Remove leading white space from a string. Equivalent to:
dropWhile isSpace
stripEnd :: NonEmptyStrictText -> Text Source #
O(n) Remove trailing white space from a string. Equivalent to:
dropWhileEnd isSpace
breakOn :: NonEmptyStrictText -> NonEmptyStrictText -> (Text, Text) Source #
O(n+m) Find the first instance of needle
(which must be
non-null
) in haystack
. The first element of the returned tuple
is the prefix of haystack
before needle
is matched. The second
is the remainder of haystack
, starting with the match.
Examples:
>>>
breakOn "::" "a::b::c"
("a","::b::c")
>>>
breakOn "/" "foobar"
("foobar","")
Laws:
append prefix match == haystack where (prefix, match) = breakOn needle haystack
If you need to break a string by a substring repeatedly (e.g. you
want to break on every instance of a substring), use breakOnAll
instead, as it has lower startup overhead.
In (unlikely) bad cases, this function's time complexity degrades towards O(n*m).
breakOnEnd :: NonEmptyStrictText -> NonEmptyStrictText -> (Text, Text) Source #
O(n+m) Similar to breakOn
, but searches from the end of the
string.
The first element of the returned tuple is the prefix of haystack
up to and including the last match of needle
. The second is the
remainder of haystack
, following the match.
>>>
breakOnEnd "::" "a::b::c"
("a::b::","c")
span :: (Char -> Bool) -> NonEmptyStrictText -> (Text, Text) Source #
O(n) span
, applied to a predicate p
and text t
, returns
a pair whose first element is the longest prefix (possibly empty)
of t
of elements that satisfy p
, and whose second is the
remainder of the text.
>>>
T.span (=='0') "000AB"
("000","AB")
group :: NonEmptyStrictText -> NonEmpty [NonEmptyStrictText] Source #
O(n) Group characters in a string by equality.
groupBy :: (Char -> Char -> Bool) -> NonEmptyStrictText -> NonEmpty [Text] Source #
O(n) Group characters in a string according to a predicate.
inits :: NonEmptyStrictText -> NonEmpty [Text] Source #
O(n) Return all initial segments of the given NonEmptyStrictText
, shortest
first.
tails :: NonEmptyStrictText -> NonEmpty [Text] Source #
O(n) Return all final segments of the given NonEmptyStrictText
, longest
first.
Breaking into many substrings
Splitting functions in this library do not perform character-wise
copies to create substrings; they just construct new Text
s that
are slices of the original.
:: NonEmptyStrictText | String to split on. If this string is empty, an error will occur. |
-> NonEmptyStrictText | Input text. |
-> NonEmpty [Text] |
O(m+n) Break a NonEmptyStrictText
into pieces separated by the first Text
argument (which cannot be empty), consuming the delimiter. An empty
delimiter is invalid, and will cause an error to be raised.
Examples:
>>>
splitOn "\r\n" "a\r\nb\r\nd\r\ne"
["a","b","d","e"]
>>>
splitOn "aaa" "aaaXaaaXaaaXaaa"
["","X","X","X",""]
>>>
splitOn "x" "x"
["",""]
and
intercalate s . splitOn s == id splitOn (singleton c) == split (==c)
(Note: the string s
to split on above cannot be empty.)
In (unlikely) bad cases, this function's time complexity degrades towards O(n*m).
split :: (Char -> Bool) -> NonEmptyStrictText -> NonEmpty [Text] Source #
O(n) Splits a NonEmptyStrictText
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') ""
[""]
chunksOf :: Int -> NonEmptyStrictText -> [Text] Source #
O(n) Splits a NonEmptyStrictText
into components of length k
. The last
element may be shorter than the other chunks, depending on the
length of the input. Examples:
>>>
chunksOf 3 "foobarbaz"
["foo","bar","baz"]
>>>
chunksOf 4 "haskell.org"
["hask","ell.","org"]
Breaking into lines and words
lines :: NonEmptyStrictText -> NonEmpty [NonEmptyStrictText] Source #
O(n) Breaks a NonEmptyStrictText
up into a list of NonEmptyStrictText
s at newline characters
'\n'
(LF, line feed). The resulting strings do not contain newlines.
lines
does not treat '\r'
(CR, carriage return) as a newline character.
words :: NonEmptyStrictText -> NonEmpty [NonEmptyStrictText] Source #
O(n) Breaks a NonEmptyStrictText
up into a list of words, delimited by Char
s
representing white space.
unlines :: NonEmpty [NonEmptyStrictText] -> NonEmptyStrictText Source #
O(n) Joins lines, after appending a terminating newline to each.
unwords :: NonEmpty [NonEmptyStrictText] -> NonEmptyStrictText Source #
O(n) Joins words using single space characters.
Predicates
isPrefixOf :: NonEmptyStrictText -> NonEmptyStrictText -> Bool Source #
O(n) The isPrefixOf
function takes two NonEmptyStrictText
s and returns
True
if and only if the first is a prefix of the second.
isSuffixOf :: NonEmptyStrictText -> NonEmptyStrictText -> Bool Source #
O(n) The isSuffixOf
function takes two NonEmptyStrictText
s and returns
True
if and only if the first is a suffix of the second.
isInfixOf :: HasCallStack => NonEmptyStrictText -> NonEmptyStrictText -> Bool Source #
O(n+m) The isInfixOf
function takes two NonEmptyStrictText
s and returns
True
if and only if the first is contained, wholly and intact, anywhere
within the second.
In (unlikely) bad cases, this function's time complexity degrades towards O(n*m).
View patterns
stripPrefix :: NonEmptyStrictText -> NonEmptyStrictText -> Maybe Text Source #
O(n) Return the suffix of the second string if its prefix matches the entire first string.
Examples:
>>>
stripPrefix "foo" "foobar"
Just "bar"
>>>
stripPrefix "" "baz"
Just "baz"
>>>
stripPrefix "foo" "quux"
Nothing
This is particularly useful with the ViewPatterns
extension to
GHC, as follows:
{-# LANGUAGE ViewPatterns #-} import Data.Text.NonEmpty as T fnordLength :: NonEmptyStrictText -> Int fnordLength (stripPrefix "fnord" -> Just suf) = T.length suf fnordLength _ = -1
stripSuffix :: NonEmptyStrictText -> NonEmptyStrictText -> Maybe Text Source #
O(n) Return the prefix of the second string if its suffix matches the entire first string.
Examples:
>>>
stripSuffix "bar" "foobar"
Just "foo"
>>>
stripSuffix "" "baz"
Just "baz"
>>>
stripSuffix "foo" "quux"
Nothing
This is particularly useful with the ViewPatterns
extension to
GHC, as follows:
{-# LANGUAGE ViewPatterns #-} import Data.Text.NonEmpty as T quuxLength :: NonEmptyStrictText -> Int quuxLength (stripSuffix "quux" -> Just pre) = T.length pre quuxLength _ = -1
commonPrefixes :: NonEmptyStrictText -> NonEmptyStrictText -> Maybe (Text, Text, Text) Source #
O(n) Find the longest non-empty common prefix of two strings and return it, along with the suffixes of each string at which they no longer match.
If the strings do not have a common prefix or either one is empty,
this function returns Nothing
.
Examples:
>>>
commonPrefixes "foobar" "fooquux"
Just ("foo","bar","quux")
>>>
commonPrefixes "veeble" "fetzer"
Nothing
>>>
commonPrefixes "" "baz"
Nothing
Searching
filter :: (Char -> Bool) -> NonEmptyStrictText -> Text Source #
O(n) filter
, applied to a predicate and a NonEmptyStrictText
,
returns a Text
containing those characters that satisfy the
predicate.
:: NonEmptyStrictText |
|
-> NonEmptyStrictText |
|
-> [(Text, Text)] |
O(n+m) Find all non-overlapping instances of needle
in
haystack
. Each element of the returned list consists of a pair:
- The entire string prior to the kth match (i.e. the prefix)
- The kth match, followed by the remainder of the string
Examples:
>>>
breakOnAll "::" ""
[]
>>>
breakOnAll "/" "a/b/c/"
[("a","/b/c/"),("a/b","/c/"),("a/b/c","/")]
In (unlikely) bad cases, this function's time complexity degrades towards O(n*m).
The needle
parameter may not be empty.
find :: (Char -> Bool) -> NonEmptyStrictText -> Maybe Char Source #
O(n) The elem
function takes a character and a NonEmptyStrictText
, and
returns True
if the element is found in the given NonEmptyStrictText
, or
False
otherwise.
O(n) The find
function takes a predicate and a NonEmptyStrictText
, and
returns the first element matching the predicate, or Nothing
if
there is no such element.
partition :: (Char -> Bool) -> NonEmptyStrictText -> (Text, Text) Source #
O(n) The partition
function takes a predicate and a NonEmptyStrictText
,
and returns the pair of Text
s with elements which do and do not
satisfy the predicate, respectively; i.e.
partition p t == (filter p t, filter (not . p) t)
Indexing
index :: HasCallStack => NonEmptyStrictText -> Int -> Char Source #
O(n) NonEmptyStrictText
index (subscript) operator, starting from 0.
findIndex :: (Char -> Bool) -> NonEmptyStrictText -> Maybe Int Source #
O(n) The findIndex
function takes a predicate and a NonEmptyStrictText
and returns the index of the first element in the NonEmptyStrictText
satisfying
the predicate.
count :: NonEmptyStrictText -> NonEmptyStrictText -> Int Source #
O(n+m) The count
function returns the number of times the
query string appears in the given NonEmptyStrictText
. An empty query string is
invalid, and will cause an error to be raised.
In (unlikely) bad cases, this function's time complexity degrades towards O(n*m).
Zipping
zip :: NonEmptyStrictText -> NonEmptyStrictText -> NonEmpty [(Char, Char)] Source #
O(n) zip
takes two NonEmptyStrictText
s and returns a list of
corresponding pairs of bytes. If one input NonEmptyStrictText
is short,
excess elements of the longer NonEmptyStrictText
are discarded. This is
equivalent to a pair of unpack
operations.
zipWith :: (Char -> Char -> Char) -> NonEmptyStrictText -> NonEmptyStrictText -> NonEmptyStrictText Source #