Data.String.NonEmpty

newtype NonEmptyString

A string that is known not to be empty.

Instances

• Eq NonEmptyString
• Ord NonEmptyString
• Semigroup NonEmptyString
• Show NonEmptyString

newtype NonEmptyReplacement

A newtype used in cases to specify a non-empty replacement for a pattern.

Constructors

• NonEmptyReplacement NonEmptyString

Instances

• Eq NonEmptyReplacement
• Ord NonEmptyReplacement
• Semigroup NonEmptyReplacement
• Show NonEmptyReplacement

fromString :: String -> Maybe NonEmptyString

Creates a NonEmptyString from a String, returning Nothing if the input is empty.

fromString "" = Nothing
fromString "hello" = Just (NonEmptyString "hello")

unsafeFromString :: Partial => String -> NonEmptyString

A partial version of fromString.

fromCharArray :: Array Char -> Maybe NonEmptyString

Creates a NonEmptyString from a character array String, returning Nothing if the input is empty.

fromCharArray [] = Nothing
fromCharArray ['a', 'b', 'c'] = Just (NonEmptyString "abc")

singleton :: Char -> NonEmptyString

Creates a NonEmptyString from a character.

cons :: Char -> String -> NonEmptyString

Creates a NonEmptyString from a string by prepending a character.

cons 'a' "bc" = NonEmptyString "abc"
cons 'a' "" = NonEmptyString "a"

snoc :: Char -> String -> NonEmptyString

Creates a NonEmptyString from a string by appending a character.

snoc 'c' "ab" = NonEmptyString "abc"
snoc 'a' "" = NonEmptyString "a"

fromFoldable1 :: forall f. Foldable1 f => f Char -> NonEmptyString

Creates a NonEmptyString from a Foldable1 container carrying characters.

toString :: NonEmptyString -> String

Converts a NonEmptyString back into a standard String.

toCharArray :: NonEmptyString -> Array Char

Converts the NonEmptyString into an array of characters.

toCharArray (NonEmptyString "Hello☺\n") == ['H','e','l','l','o','☺','\n']

charAt :: Int -> NonEmptyString -> Maybe Char

Returns the character at the given index, if the index is within bounds.

charAt 2 (NonEmptyString "Hello") == Just 'l'
charAt 10 (NonEmptyString "Hello") == Nothing

charCodeAt :: Int -> NonEmptyString -> Maybe Int

Returns the numeric Unicode value of the character at the given index, if the index is within bounds.

charCodeAt 2 (NonEmptyString "5 €") == Just 0x20AC
charCodeAt 10 (NonEmptyString "5 €") == Nothing

toChar :: NonEmptyString -> Maybe Char

Converts the NonEmptyString to a character, if the length of the string is exactly 1.

toChar "H" == Just 'H'
toChar "Hi" == Nothing

appendString :: NonEmptyString -> String -> NonEmptyString

Appends a string to this non-empty string. Since one of the strings is non-empty we know the result will be too.

appendString (NonEmptyString "Hello") " world" == NonEmptyString "Hello world"
appendString (NonEmptyString "Hello") "" == NonEmptyString "Hello"

prependString :: String -> NonEmptyString -> NonEmptyString

Prepends a string to this non-empty string. Since one of the strings is non-empty we know the result will be too.

prependString "be" (NonEmptyString "fore") == NonEmptyString "before"
prependString "" (NonEmptyString "fore") == NonEmptyString "fore"

contains :: Pattern -> NonEmptyString -> Boolean

Checks whether the pattern appears in the given string.

contains (Pattern "needle") (NonEmptyString "haystack with needle") == true
contains (Pattern "needle") (NonEmptyString "haystack") == false

indexOf :: Pattern -> NonEmptyString -> Maybe Int

Returns the index of the first occurrence of the pattern in the given string. Returns Nothing if there is no match.

indexOf (Pattern "c") (NonEmptyString "abcdc") == Just 2
indexOf (Pattern "c") (NonEmptyString "aaa") == Nothing

indexOf' :: Pattern -> Int -> NonEmptyString -> Maybe Int

Returns the index of the first occurrence of the pattern in the given string, starting at the specified index. Returns Nothing if there is no match.

indexOf' (Pattern "a") 2 (NonEmptyString "ababa") == Just 2
indexOf' (Pattern "a") 3 (NonEmptyString "ababa") == Just 4

lastIndexOf :: Pattern -> NonEmptyString -> Maybe Int

Returns the index of the last occurrence of the pattern in the given string. Returns Nothing if there is no match.

lastIndexOf (Pattern "c") (NonEmptyString "abcdc") == Just 4
lastIndexOf (Pattern "c") (NonEmptyString "aaa") == Nothing

lastIndexOf' :: Pattern -> Int -> NonEmptyString -> Maybe Int

Returns the index of the last occurrence of the pattern in the given string, starting at the specified index and searching backwards towards the beginning of the string. Returns Nothing if there is no match.

lastIndexOf' (Pattern "a") 1 (NonEmptyString "ababa") == Just 0
lastIndexOf' (Pattern "a") 3 (NonEmptyString "ababa") == Just 2
lastIndexOf' (Pattern "a") 4 (NonEmptyString "ababa") == Just 4

uncons :: NonEmptyString -> { head :: Char, tail :: Maybe NonEmptyString }

Returns the first character and the rest of the string.

uncons "a" == { head: 'a', tail: Nothing }
uncons "Hello World" == { head: 'H', tail: Just (NonEmptyString "ello World") }

length :: NonEmptyString -> Int

Returns the number of characters the string is composed of.

length (NonEmptyString "Hello World") == 11

localeCompare :: NonEmptyString -> NonEmptyString -> Ordering

Compare two strings in a locale-aware fashion. This is in contrast to the Ord instance on String which treats strings as arrays of code units:

NonEmptyString "ä" `localeCompare` NonEmptyString "b" == LT
NonEmptyString "ä" `compare` NonEmptyString "b" == GT

replace :: Pattern -> NonEmptyReplacement -> NonEmptyString -> NonEmptyString

Replaces the first occurence of the pattern with the replacement string.

replace (Pattern "<=") (NonEmptyReplacement "≤") (NonEmptyString "a <= b <= c") == NonEmptyString "a ≤ b <= c"

replaceAll :: Pattern -> NonEmptyReplacement -> NonEmptyString -> NonEmptyString

Replaces all occurences of the pattern with the replacement string.

replaceAll (Pattern "<=") (NonEmptyReplacement "≤") (NonEmptyString "a <= b <= c") == NonEmptyString "a ≤ b ≤ c"

take :: Int -> NonEmptyString -> Maybe NonEmptyString

Returns the first n characters of the string. Returns Nothing if n is less than 1.

take 5 (NonEmptyString "Hello World") == Just (NonEmptyString "Hello")
take 0 (NonEmptyString "Hello World") == Nothing

takeRight :: Int -> NonEmptyString -> Maybe NonEmptyString

Returns the last n characters of the string. Returns Nothing if n is less than 1.

take 5 (NonEmptyString "Hello World") == Just (NonEmptyString "World")
take 0 (NonEmptyString "Hello World") == Nothing

takeWhile :: (Char -> Boolean) -> NonEmptyString -> Maybe NonEmptyString

Returns the longest prefix of characters that satisfy the predicate. Nothing is returned if there is no matching prefix.

takeWhile (_ /= ':') (NonEmptyString "http://purescript.org") == Just (NonEmptyString "http")
takeWhile (_ == 'a') (NonEmptyString "xyz") == Nothing

drop :: Int -> NonEmptyString -> Maybe NonEmptyString

Returns the string without the first n characters. Returns Nothing if more characters are dropped than the string is long.

drop 6 (NonEmptyString "Hello World") == Just (NonEmptyString "World")
drop 20 (NonEmptyString "Hello World") == Nothing

dropRight :: Int -> NonEmptyString -> Maybe NonEmptyString

Returns the string without the last n characters. Returns Nothing if more characters are dropped than the string is long.

dropRight 6 (NonEmptyString "Hello World") == Just (NonEmptyString "Hello")
dropRight 20 (NonEmptyString "Hello World") == Nothing

dropWhile :: (Char -> Boolean) -> NonEmptyString -> Maybe NonEmptyString

Returns the suffix remaining after takeWhile.

dropWhile (_ /= '.') (NonEmptyString "Test.purs") == Just (NonEmptyString ".purs")

stripPrefix :: Pattern -> NonEmptyString -> Maybe NonEmptyString

If the string starts with the given prefix, return the portion of the string left after removing it. If the prefix does not match or there is no remainder, the result will be Nothing.

stripPrefix (Pattern "http:") (NonEmptyString "http://purescript.org") == Just (NonEmptyString "//purescript.org")
stripPrefix (Pattern "http:") (NonEmptyString "https://purescript.org") == Nothing
stripPrefix (Pattern "Hello!") (NonEmptyString "Hello!") == Nothing

stripSuffix :: Pattern -> NonEmptyString -> Maybe NonEmptyString

If the string ends with the given suffix, return the portion of the string left after removing it. If the suffix does not match or there is no remainder, the result will be Nothing.

stripSuffix (Pattern ".exe") (NonEmptyString "purs.exe") == Just (NonEmptyString "purs")
stripSuffix (Pattern ".exe") (NonEmptyString "purs") == Nothing
stripSuffix (Pattern "Hello!") (NonEmptyString "Hello!") == Nothing

count :: (Char -> Boolean) -> NonEmptyString -> Int

Returns the number of contiguous characters at the beginning of the string for which the predicate holds.

count (_ /= 'o') (NonEmptyString "Hello World") == 4

splitAt :: Int -> NonEmptyString -> Maybe { after :: Maybe NonEmptyString, before :: Maybe NonEmptyString }

Returns the substrings of a split at the given index, if the index is within bounds.

splitAt 2 (NonEmptyString "Hello World") == Just { before: Just (NonEmptyString "He"), after: Just (NonEmptyString "llo World") }
splitAt 10 (NonEmptyString "Hi") == Nothing

toLower :: NonEmptyString -> NonEmptyString

Returns the argument converted to lowercase.

toLower (NonEmptyString "hElLo") == NonEmptyString "hello"

toUpper :: NonEmptyString -> NonEmptyString

Returns the argument converted to uppercase.

toUpper (NonEmptyString "Hello") == NonEmptyString "HELLO"

trim :: NonEmptyString -> Maybe NonEmptyString

Removes whitespace from the beginning and end of a string, including whitespace characters and line terminators. If the string is entirely made up of whitespace the result will be Nothing.

trim (NonEmptyString "   Hello  \n World\n\t    ") == Just (NonEmptyString "Hello  \n World")
trim (NonEmptyString "   \n") == Nothing

joinWith :: forall f. Foldable f => String -> f NonEmptyString -> String

Joins the strings in a container together as a new string, inserting the first argument as separator between them. The result is not guaranteed to be non-empty.

joinWith ", " [NonEmptyString "apple", NonEmptyString "banana"] == "apple, banana"
joinWith ", " [] == ""

join1With :: forall f. Foldable1 f => String -> f NonEmptyString -> NonEmptyString

Joins non-empty strings in a non-empty container together as a new non-empty string, inserting a possibly empty string as separator between them. The result is guaranteed to be non-empty.

-- array syntax is used for demonstration here, it would need to be a real `Foldable1`
join1With ", " [NonEmptyString "apple", NonEmptyString "banana"] == NonEmptyString "apple, banana"
join1With "" [NonEmptyString "apple", NonEmptyString "banana"] == NonEmptyString "applebanana"

joinWith1 :: forall f. Foldable1 f => NonEmptyString -> f String -> NonEmptyString

Joins possibly empty strings in a non-empty container together as a new non-empty string, inserting a non-empty string as a separator between them. The result is guaranteed to be non-empty.

-- array syntax is used for demonstration here, it would need to be a real `Foldable1`
joinWith1 (NonEmptyString ", ") ["apple", "banana"] == NonEmptyString "apple, banana"
joinWith1 (NonEmptyString "/") ["a", "b", "", "c", ""] == NonEmptyString "a/b//c/"

newtype Pattern

A newtype used in cases where there is a string to be matched.

pursPattern = Pattern ".purs"
--can be used like this:
contains pursPattern "Test.purs"
   == true

Constructors

• Pattern String

Instances

• Eq Pattern
• Ord Pattern
• Newtype Pattern _
• Show Pattern