An unboxed string of characters a.

Implemented as a contiguous vector of unboxed characters.

O(1) Yield the length of the string.

O(1) Test whether a string is empty.

O(1) Indexing.

>>> "abc" ! 1
'b'

O(1) Safe indexing.

>>> "abc" !? 1
Just 'b'

>>> "abc" !? 3
Nothing

O(1) First character.

>>> head "hello"
'h'

O(1) Last character.

>>> last "hello"
'o'

O(1) Unsafe indexing without bounds checking.

O(1) The character of a singleton string.

>>> single ""
Nothing

>>> single "x"
Just 'x'

>>> single "xy"
Nothing

O(1) Indexing in a monad.

See Data.Vactor.Unbox.

>>> indexM @Maybe "xyz" 5
Nothing

O(1) First character of a string in a monad.

See Data.Vactor.Unbox.

>>> headM @Maybe ""
Nothing

O(1) Last character of a string in a monad.

See Data.Vactor.Unbox.

>>> lastM @Maybe ""
Nothing

O(1) Yield the slice `s[i:i+n]` of the string without copying it.

The string must contain at least `i+n` characters.

>>> slice 2 3 "genome"
nom

O(1) Yield all but the last character without copying.

The string may not be empty.

>>> init "genome"
genom

O(1) Yield all but the first character without copying.

The string may not be empty.

>>> tail "genome"
enome

O(1) Yield at the first n characters without copying.

The string may contain less than n characters, in which case it is returned unchanged.

>>> take 2 "hello"
he

>>> take 10 "hello"
hello

O(1) Yield all but the first n characters without copying.

The string may contain less than n characters, in which case an empty string is returned.

>>> drop 2 "hello"
llo

>>> drop 10 "hello"

O(1) Yield the first n characters paired with the remainder, without copying.

Note that `splitAt n s` is equivalent to `(take n s, drop n s)`, but slightly more efficient.

>>> splitAt 6 "babushka"
(babush,ka)

O(1) Yield the head and tail of the string, or Nothing if it is empty.

>>> uncons "acgt"
Just ('a',cgt)

O(1) Yield the init and last of the string, or Nothing if it is empty.

>>> unsnoc "acgt"
Just (acg,'t')

O(1) Yield a slice of the string without copying.

The string must contain at least `i+n` characters, but this is not checked.

O(1) The empty string.

>>> empty == ""
True

O(1) A string with exactly one character.

>>> singleton 's'
s

O(n) A string of the given length with the same character in each position.

>>> replicate 10 'a'
aaaaaaaaaa

O(n) Construct a string of the given length by applying the function to each index.

>>> import Prelude (head, show)
>>> generate 5 (\i -> Prelude.head (show i))
01234

O(n) Execute the monadic action the given number of times and store the results in a string.

>>> replicateM 4 (Just 'v')
Just vvvv

O(n) Construct a string of the given length by applying the monadic action to each index.

>>> generateM 5 (\i -> Just i)
Just 0 1 2 3 4

O(f(n)) Execute the monadic action and freeze the resulting string.

>>> import Control.Applicative (pure)
>>> import Data.Vector.Unboxed.Mutable (new, write)
>>> create (do v <- new 2; write v 0 'a'; write v 1 'b'; pure v)
ab

O(n) Construct a string by repeatedly applying the generator function to a seed.

The generator function yields -- Just the next character and the new seed or Nothing if there are no more characters.

>>> unfoldr @Int (\n -> if n == 0 then Nothing else Just (n, n-1)) 10
10 9 8 7 6 5 4 3 2 1

O(n) Construct a vector with exactly n characters by repeatedly applying the generator function to a seed.

The generator function yields the next character and the new seed.

>>> unfoldrExactN @Int 3 (\n -> (n, n-1)) 10
10 9 8

O(n) Construct a string by repeatedly applying the generator function to a seed.

The generator function yields -- Just the next character and the new seed or Nothing if there are no more characters.

>>> unfoldr @Int (\n -> if n == 0 then Nothing else Just (n, n-1)) 10
10 9 8 7 6 5 4 3 2 1

O(n) Construct a string with exactly n characters by repeatedly applying the generator function to a seed.

The generator function yields the next character and the new seed.

>>> unfoldrExactN @Int 3 (\n -> (n, n-1)) 10
10 9 8

O(n) Yield a string of the given length, containing the characters x, x+1 etc.

This operation is usually more efficient than enumFromTo.

>>> enumFromN @Int 5 3
5 6 7

O(n) Yield a string of the given length, containing the characters x, x+y, x+y+y etc.

This operations is usually more efficient than enumFromThenTo.

>>> enumFromStepN @Int 1 2 5
1 3 5 7 9

O(n) Prepend a character.

>>> cons 'e' "xtrem"
extrem

O(n) Append a character.

>>> snoc "xtrem" 'a'
xtrema

O(m+n) Concatenate two strings.

>>> "abc" ++ "xyz"
abcxyz

O(n) Concatenate all strings in the list.

This is the simplest variant, but requires `Unbox a`.

>>> concat ["abc", "123", "def"]
abc123def

>>> concat @Char []

O(n) Concatenate all strings in the non-empty list.

>>> concatNE ("abc" :| ["123", "def"])
abc123def

O(n) Yield the argument, but force it not to retain any extra memory, possibly by copying it.

See Data.Vector.Unbox.

O(m+n) For each pair `(i,a)` from the list of index/value pairs, replace the character at position i by a.

>>> "test" // [(2,'x'),(0,'y'),(2,'z')]
yezt

O(m+min(n1,n2)) For each index i from the index list and the corresponding value a from another string, replace the character of the initial string at position i by a.

>>> update "test" [2,0,2] "xyz"
yezt

O(m+n) For each pair (i,b) from the list, replace the character at position i by f a b.

>>> import GHC.Num ((+))
>>> accum @Int (+) [1000,2000,3000] [(2,4),(1,6),(0,3),(1,10)]
1003 2016 3004

O(m+min(n1,n2)) For each index i from the index list and the corresponding value b from the string, replace the character of the initial string at position i by f a b.

>>> import GHC.Num ((+))
>>> accumulate @Int (+) [5,9,2] [2,1,0,1] [4,6,3,7]
8 22 6

O(n) Reverse a string.

>>> reverse "abc123"
321cba

O(n) Yield the string obtained by replacing each element i of the index list by `xs!i`.

This is equivalent to `map (xs!)` is, but is often much more efficient.

>>> backpermute "abcd" [0,3,2,3,1,0]
adcdba

O(f(n)) Apply a destructive operation to a string.

The operation will be performed in place if it is safe to do so and will modify a copy of the vector otherwise.

>>> import Data.Vector.Unboxed.Mutable (write)
>>> modify (\v -> write v 3 'X') (replicate 10 'a')
aaaXaaaaaa

O(n) Pair each character in a string with its index.

>>> indexed "greedy"
(0,'g') (1,'r') (2,'e') (3,'e') (4,'d') (5,'y')

O(n) Map a function over a string.

>>> import Data.Char (ord)
>>> map ord "genome"
103 101 110 111 109 101

O(n) Map an endofunction over a string.

>>> import Data.Char (toUpper)
>>> map_ toUpper "genome"
GENOME

O(n) Apply a function to every character of a string and its index.

>>> import Data.Char (ord)
>>> import GHC.Num ((+))
>>> imap (\i c -> i + ord c) "genome"
103 102 112 114 113 106

O(n) Apply an endofunction to every character of a string and its index.

>>> import Data.Char (chr, ord)
>>> import GHC.Num ((+))
>>> imap_ (\i c -> chr (i + ord c)) "genome"
gfprqj

O(?) Map a function over a string and concatenate the results.

>>> concatMap (\c -> [c, c]) "genome"
ggeennoommee

O(?) Map a function over a string and concatenate the resulting strings.

>>> concatMap_ (\c -> replicate 3 c) "gen"
gggeeennn

O(n) Apply the monadic action to all characters of the string, yielding a string of results.

O(n) Apply the monadic action to all characters of the string, yielding a string of results.

O(n) Apply the monadic action to all characters of a string and ignore the results.

O(n) Apply the monadic action to all characters of a string and their indices and ignore the results.

O(min(m,n)) Zip two strings with the given function.

O(min(m,n,k)) Zip three strings with the given function.

O(min(m,n)) Zip two strings.

O(min(m,n)) Zip three strings.

O(min(m,n)) Zip the two strings with the monadic action and yield a vector of results.

O(min(m,n)) Zip the two strings with the monadic action and ignore the results.

O(n) Unzip a string of pairs.

O(n) Unzip a string of triples.

O(n) Drop all characters that do not satisfy the predicate.

>>> import Data.Char (isUpper)
>>> filter isUpper "ABCdefGHI"
ABCGHI

O(n) Drop all characters that do not satisfy the predicate which is applied to the values and their indices.

O(n) Drop all characters that do not satisfy the monadic predicate.

O(n) Drop repeated adjacent characters.

>>> uniq "aaaabbbcccaabc"
abcabc

O(n) Map the values and collect the Just results.

O(n) Apply the monadic function to each element of the string and discard characters returning Nothing.

O(n) Yield the longest prefix of characters satisfying the predicate.

The current implementation is not copy-free, unless the result string is fused away.

O(n) Drop the longest prefix of characters that satisfy the predicate without copying.

O(n) Split the string in two parts, the first one containing those characters that satisfy the predicate and the second one those that don't.

The relative order of the characters is preserved at the cost of a sometimes reduced performance compared to unstablePartition.

O(n) Split the string into two parts, the first one containing the Left characters and the second containing the Right characters.

The relative order of the characters is preserved.

O(n) Split the string in two parts, the first one containing those characters that satisfy the predicate and the second one those that don't.

The order of the characters is not preserved, but the operation is often faster than partition.

O(n) Split the string into the longest prefix of characters that satisfy the predicate and the rest without copying.

O(n) Split the string into the longest prefix of characters that do not satisfy the predicate and the rest without copying.

O(n) Split a string into a list of slices.

The concatenation of this list of slices is equal to the argument string, and each slice contains only equal characters, as determined by the equality predicate function.

>>> import Data.Char (isUpper)
>>> groupBy (\x y -> isUpper x == isUpper y) "Rio Grande"
[R,io ,G,rande]

O(n) Split a string into a list of slices.

The concatenation of this list of slices is equal to the argument string, and each slice contains only equal characters.

This is the equivalent of 'groupBy (==)'.

>>> group "Mississippi"
[M,i,ss,i,ss,i,pp,i]

O(n) Check if the string contains a character.

O(n) Check if the string does not contain a character (inverse of elem).

O(n) Yield Just the first character matching the predicate or Nothing if no such character exists.

O(n) Yield Just the index of the first character matching the predicate or Nothing if no such character exists.

O(n) Yield Just the index of the last character matching the predicate or Nothing if no such character exists.

O(n) Yield the indices of character satisfying the predicate in ascending order.

O(n) Yield Just the index of the first occurrence of the given character or Nothing if the vector does not contain the character.

This is a specialised version of findIndex.

O(n) Yield the indices of all occurrences of the given character in ascending order.

This is a specialised version of findIndices.

O(n) Check if two strings are equal using the supplied equality predicate.

>>> import Data.Char (toLower)
>>> eqBy (\x y -> toLower x == toLower y) "ABcd" "abcD"
True

O(n) Compare two strings using the supplied comparison function for characters.

Comparison works the same as for lists.

O(n) Convert to a vector of characters.