pax_global_header00006660000000000000000000000064132403475010014511gustar00rootroot0000000000000052 comment=06e048c1a6026e3fd6dd9aff0a2d26da23cec783 purescript-strings-3.5.0/000077500000000000000000000000001324034750100154055ustar00rootroot00000000000000purescript-strings-3.5.0/.eslintrc.json000066400000000000000000000011111324034750100201730ustar00rootroot00000000000000{ "parserOptions": { "ecmaVersion": 5 }, "extends": "eslint:recommended", "env": { "commonjs": true }, "rules": { "strict": [2, "global"], "block-scoped-var": 2, "consistent-return": 2, "eqeqeq": [2, "smart"], "guard-for-in": 2, "no-caller": 2, "no-extend-native": 2, "no-loop-func": 2, "no-new": 2, "no-param-reassign": 2, "no-return-assign": 2, "no-unused-expressions": 2, "no-use-before-define": 2, "radix": [2, "always"], "indent": [2, 2], "quotes": [2, "double"], "semi": [2, "always"] } } purescript-strings-3.5.0/.gitignore000066400000000000000000000001551324034750100173760ustar00rootroot00000000000000/.* !/.gitignore !/.eslintrc.json !/.travis.yml /bower_components/ /node_modules/ /output/ package-lock.json purescript-strings-3.5.0/.travis.yml000066400000000000000000000013041324034750100175140ustar00rootroot00000000000000language: node_js dist: trusty sudo: required node_js: stable env: - PATH=$HOME/purescript:$PATH install: - TAG=$(wget -q -O - https://github.com/purescript/purescript/releases/latest --server-response --max-redirect 0 2>&1 | sed -n -e 's/.*Location:.*tag\///p') - wget -O $HOME/purescript.tar.gz https://github.com/purescript/purescript/releases/download/$TAG/linux64.tar.gz - tar -xvf $HOME/purescript.tar.gz -C $HOME/ - chmod a+x $HOME/purescript - npm install -g bower - npm install script: - bower install --production - npm run -s build - bower install - npm -s test after_success: - >- test $TRAVIS_TAG && echo $GITHUB_TOKEN | pulp login && echo y | pulp publish --no-push purescript-strings-3.5.0/LICENSE000066400000000000000000000020651324034750100164150ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2014 PureScript Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. purescript-strings-3.5.0/README.md000066400000000000000000000010551324034750100166650ustar00rootroot00000000000000# purescript-strings [![Latest release](http://img.shields.io/github/release/purescript/purescript-strings.svg)](https://github.com/purescript/purescript-strings/releases) [![Build status](https://travis-ci.org/purescript/purescript-strings.svg?branch=master)](https://travis-ci.org/purescript/purescript-strings) String and char utility functions, regular expressions. ## Installation ``` bower install purescript-strings ``` ## Documentation Module documentation is [published on Pursuit](http://pursuit.purescript.org/packages/purescript-strings). purescript-strings-3.5.0/bower.json000066400000000000000000000014541324034750100174220ustar00rootroot00000000000000{ "name": "purescript-strings", "homepage": "https://github.com/purescript/purescript-strings", "description": "String and char utility functions, regular expressions.", "license": "MIT", "repository": { "type": "git", "url": "git://github.com/purescript/purescript-strings.git" }, "ignore": [ "**/.*", "bower_components", "node_modules", "output", "test", "bower.json", "package.json" ], "dependencies": { "purescript-either": "^3.0.0", "purescript-gen": "^1.1.0", "purescript-maybe": "^3.0.0", "purescript-partial": "^1.2.0", "purescript-unfoldable": "^3.0.0", "purescript-arrays": "^4.0.1", "purescript-integers": "^3.2.0" }, "devDependencies": { "purescript-assert": "^3.0.0", "purescript-console": "^3.0.0" } } purescript-strings-3.5.0/package.json000066400000000000000000000005001324034750100176660ustar00rootroot00000000000000{ "private": true, "scripts": { "clean": "rimraf output && rimraf .pulp-cache", "build": "eslint src && pulp build -- --censor-lib --strict", "test": "pulp test" }, "devDependencies": { "eslint": "^3.17.1", "pulp": "^10.0.4", "purescript-psa": "^0.5.0-rc.1", "rimraf": "^2.6.1" } } purescript-strings-3.5.0/src/000077500000000000000000000000001324034750100161745ustar00rootroot00000000000000purescript-strings-3.5.0/src/Data/000077500000000000000000000000001324034750100170455ustar00rootroot00000000000000purescript-strings-3.5.0/src/Data/Char.js000066400000000000000000000004311324034750100202560ustar00rootroot00000000000000"use strict"; exports.toCharCode = function (c) { return c.charCodeAt(0); }; exports.fromCharCode = function (c) { return String.fromCharCode(c); }; exports.toLower = function (c) { return c.toLowerCase(); }; exports.toUpper = function (c) { return c.toUpperCase(); }; purescript-strings-3.5.0/src/Data/Char.purs000066400000000000000000000007651324034750100206450ustar00rootroot00000000000000-- | A type and functions for single characters. module Data.Char ( fromCharCode , toCharCode , toLower , toUpper ) where -- | Returns the numeric Unicode value of the character. foreign import toCharCode :: Char -> Int -- | Constructs a character from the given Unicode numeric value. foreign import fromCharCode :: Int -> Char -- | Converts a character to lowercase. foreign import toLower :: Char -> Char -- | Converts a character to uppercase. foreign import toUpper :: Char -> Char purescript-strings-3.5.0/src/Data/Char/000077500000000000000000000000001324034750100177225ustar00rootroot00000000000000purescript-strings-3.5.0/src/Data/Char/Gen.purs000066400000000000000000000024561324034750100213550ustar00rootroot00000000000000module Data.Char.Gen where import Prelude import Control.Monad.Gen (class MonadGen, chooseInt, oneOf) import Data.Char as C import Data.NonEmpty ((:|)) -- | Generates a character of the Unicode basic multilingual plane. genUnicodeChar :: forall m. MonadGen m => m Char genUnicodeChar = C.fromCharCode <$> chooseInt 0 65536 -- | Generates a character in the ASCII character set, excluding control codes. genAsciiChar :: forall m. MonadGen m => m Char genAsciiChar = C.fromCharCode <$> chooseInt 32 127 -- | Generates a character in the ASCII character set. genAsciiChar' :: forall m. MonadGen m => m Char genAsciiChar' = C.fromCharCode <$> chooseInt 0 127 -- | Generates a character that is a numeric digit. genDigitChar :: forall m. MonadGen m => m Char genDigitChar = C.fromCharCode <$> chooseInt 48 57 -- | Generates a character from the basic latin alphabet. genAlpha :: forall m. MonadGen m => m Char genAlpha = oneOf (genAlphaLowercase :| [genAlphaUppercase]) -- | Generates a lowercase character from the basic latin alphabet. genAlphaLowercase :: forall m. MonadGen m => m Char genAlphaLowercase = C.fromCharCode <$> chooseInt 97 122 -- | Generates an uppercase character from the basic latin alphabet. genAlphaUppercase :: forall m. MonadGen m => m Char genAlphaUppercase = C.fromCharCode <$> chooseInt 65 90 purescript-strings-3.5.0/src/Data/String.js000066400000000000000000000070051324034750100206530ustar00rootroot00000000000000"use strict"; exports._charAt = function (just) { return function (nothing) { return function (i) { return function (s) { return i >= 0 && i < s.length ? just(s.charAt(i)) : nothing; }; }; }; }; exports.singleton = function (c) { return c; }; exports._charCodeAt = function (just) { return function (nothing) { return function (i) { return function (s) { return i >= 0 && i < s.length ? just(s.charCodeAt(i)) : nothing; }; }; }; }; exports._toChar = function (just) { return function (nothing) { return function (s) { return s.length === 1 ? just(s) : nothing; }; }; }; exports.fromCharArray = function (a) { return a.join(""); }; exports._indexOf = function (just) { return function (nothing) { return function (x) { return function (s) { var i = s.indexOf(x); return i === -1 ? nothing : just(i); }; }; }; }; exports["_indexOf'"] = function (just) { return function (nothing) { return function (x) { return function (startAt) { return function (s) { if (startAt < 0 || startAt > s.length) return nothing; var i = s.indexOf(x, startAt); return i === -1 ? nothing : just(i); }; }; }; }; }; exports._lastIndexOf = function (just) { return function (nothing) { return function (x) { return function (s) { var i = s.lastIndexOf(x); return i === -1 ? nothing : just(i); }; }; }; }; exports["_lastIndexOf'"] = function (just) { return function (nothing) { return function (x) { return function (startAt) { return function (s) { if (startAt < 0 || startAt > s.length) return nothing; var i = s.lastIndexOf(x, startAt); return i === -1 ? nothing : just(i); }; }; }; }; }; exports.length = function (s) { return s.length; }; exports._localeCompare = function (lt) { return function (eq) { return function (gt) { return function (s1) { return function (s2) { var result = s1.localeCompare(s2); return result < 0 ? lt : result > 0 ? gt : eq; }; }; }; }; }; exports.replace = function (s1) { return function (s2) { return function (s3) { return s3.replace(s1, s2); }; }; }; exports.replaceAll = function (s1) { return function (s2) { return function (s3) { return s3.replace(new RegExp(s1.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"), "g"), s2); }; }; }; exports.take = function (n) { return function (s) { return s.substr(0, n); }; }; exports.drop = function (n) { return function (s) { return s.substring(n); }; }; exports.count = function (p) { return function (s) { var i = 0; while (i < s.length && p(s.charAt(i))) i++; return i; }; }; exports.split = function (sep) { return function (s) { return s.split(sep); }; }; exports._splitAt = function (just) { return function (nothing) { return function (i) { return function (s) { return i >= 0 && i < s.length ? just({ before: s.substring(0, i), after: s.substring(i) }) : nothing; }; }; }; }; exports.toCharArray = function (s) { return s.split(""); }; exports.toLower = function (s) { return s.toLowerCase(); }; exports.toUpper = function (s) { return s.toUpperCase(); }; exports.trim = function (s) { return s.trim(); }; exports.joinWith = function (s) { return function (xs) { return xs.join(s); }; }; purescript-strings-3.5.0/src/Data/String.purs000066400000000000000000000274361324034750100212420ustar00rootroot00000000000000-- | Wraps the functions of Javascript's `String` object. -- | A String represents a sequence of characters. -- | For details of the underlying implementation, see [String Reference at MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String). module Data.String ( Pattern(..) , Replacement(..) , charAt , charCodeAt , fromCharArray , toChar , contains , indexOf , indexOf' , lastIndexOf , lastIndexOf' , null , uncons , length , singleton , localeCompare , replace , replaceAll , take , takeRight , takeWhile , drop , dropRight , dropWhile , stripPrefix , stripSuffix , count , split , splitAt , toCharArray , toLower , toUpper , trim , joinWith ) where import Prelude import Data.Maybe (Maybe(..), isJust) import Data.Newtype (class Newtype) import Data.String.Unsafe as U -- | A newtype used in cases where there is a string to be matched. -- | -- | ```purescript -- | pursPattern = Pattern ".purs" -- | --can be used like this: -- | contains pursPattern "Test.purs" -- | == true -- | ``` -- | newtype Pattern = Pattern String derive instance eqPattern :: Eq Pattern derive instance ordPattern :: Ord Pattern derive instance newtypePattern :: Newtype Pattern _ instance showPattern :: Show Pattern where show (Pattern s) = "(Pattern " <> show s <> ")" -- | A newtype used in cases to specify a replacement for a pattern. newtype Replacement = Replacement String derive instance eqReplacement :: Eq Replacement derive instance ordReplacement :: Ord Replacement derive instance newtypeReplacement :: Newtype Replacement _ instance showReplacement :: Show Replacement where show (Replacement s) = "(Replacement " <> show s <> ")" -- | Returns the character at the given index, if the index is within bounds. -- | -- | ```purescript -- | charAt 2 "Hello" == Just 'l' -- | charAt 10 "Hello" == Nothing -- | ``` -- | charAt :: Int -> String -> Maybe Char charAt = _charAt Just Nothing foreign import _charAt :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Int -> String -> Maybe Char -- | Returns a string of length `1` containing the given character. -- | -- | ```purescript -- | singleton 'l' == "l" -- | ``` -- | foreign import singleton :: Char -> String -- | Returns the numeric Unicode value of the character at the given index, -- | if the index is within bounds. -- | ```purescript -- | charCodeAt 2 "5 €" == Just 0x20AC -- | charCodeAt 10 "5 €" == Nothing -- | ``` -- | charCodeAt :: Int -> String -> Maybe Int charCodeAt = _charCodeAt Just Nothing foreign import _charCodeAt :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Int -> String -> Maybe Int -- | Converts the string to a character, if the length of the string is -- | exactly `1`. -- | -- | ```purescript -- | toChar "l" == Just 'l' -- | toChar "Hi" == Nothing -- since length is not 1 -- | ``` -- | toChar :: String -> Maybe Char toChar = _toChar Just Nothing foreign import _toChar :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> String -> Maybe Char -- | Returns `true` if the given string is empty. -- | -- | ```purescript -- | null "" == true -- | null "Hi" == false -- | ``` -- | null :: String -> Boolean null s = s == "" -- | Returns the first character and the rest of the string, -- | if the string is not empty. -- | -- | ```purescript -- | uncons "" == Nothing -- | uncons "Hello World" == Just { head: 'H', tail: "ello World" } -- | ``` -- | uncons :: String -> Maybe { head :: Char, tail :: String } uncons "" = Nothing uncons s = Just { head: U.charAt zero s, tail: drop one s } -- | Returns the longest prefix (possibly empty) of characters that satisfy -- | the predicate. -- | -- | ```purescript -- | takeWhile (_ /= ':') "http://purescript.org" == "http" -- | ``` -- | takeWhile :: (Char -> Boolean) -> String -> String takeWhile p s = take (count p s) s -- | Returns the suffix remaining after `takeWhile`. -- | -- | ```purescript -- | dropWhile (_ /= '.') "Test.purs" == ".purs" -- | ``` -- | dropWhile :: (Char -> Boolean) -> String -> String dropWhile p s = drop (count p s) s -- | If the string starts with the given prefix, return the portion of the -- | string left after removing it, as a Just value. Otherwise, return Nothing. -- | -- | ```purescript -- | stripPrefix (Pattern "http:") "http://purescript.org" == Just "//purescript.org" -- | stripPrefix (Pattern "http:") "https://purescript.org" == Nothing -- | ``` -- | stripPrefix :: Pattern -> String -> Maybe String stripPrefix prefix@(Pattern prefixS) str = case indexOf prefix str of Just 0 -> Just $ drop (length prefixS) str _ -> Nothing -- | If the string ends with the given suffix, return the portion of the -- | string left after removing it, as a `Just` value. Otherwise, return -- | `Nothing`. -- | -- | ```purescript -- | stripSuffix (Pattern ".exe") "psc.exe" == Just "psc" -- | stripSuffix (Pattern ".exe") "psc" == Nothing -- | ``` -- | stripSuffix :: Pattern -> String -> Maybe String stripSuffix suffix@(Pattern suffixS) str = case lastIndexOf suffix str of Just x | x == length str - length suffixS -> Just $ take x str _ -> Nothing -- | Converts an array of characters into a string. -- | -- | ```purescript -- | fromCharArray ['H', 'e', 'l', 'l', 'o'] == "Hello" -- | ``` -- | foreign import fromCharArray :: Array Char -> String -- | Checks whether the pattern appears in the given string. -- | -- | ```purescript -- | contains (Pattern "needle") "haystack with needle" == true -- | contains (Pattern "needle") "haystack" == false -- | ``` -- | contains :: Pattern -> String -> Boolean contains pat = isJust <<< indexOf pat -- | Returns the index of the first occurrence of the pattern in the -- | given string. Returns `Nothing` if there is no match. -- | -- | ```purescript -- | indexOf (Pattern "c") "abcdc" == Just 2 -- | indexOf (Pattern "c") "aaa" == Nothing -- | ``` -- | indexOf :: Pattern -> String -> Maybe Int indexOf = _indexOf Just Nothing foreign import _indexOf :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Pattern -> String -> 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. -- | -- | ```purescript -- | indexOf' (Pattern "a") 2 "ababa" == Just 2 -- | indexOf' (Pattern "a") 3 "ababa" == Just 4 -- | ``` -- | indexOf' :: Pattern -> Int -> String -> Maybe Int indexOf' = _indexOf' Just Nothing foreign import _indexOf' :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Pattern -> Int -> String -> Maybe Int -- | Returns the index of the last occurrence of the pattern in the -- | given string. Returns `Nothing` if there is no match. -- | -- | ```purescript -- | lastIndexOf (Pattern "c") "abcdc" == Just 4 -- | lastIndexOf (Pattern "c") "aaa" == Nothing -- | ``` -- | lastIndexOf :: Pattern -> String -> Maybe Int lastIndexOf = _lastIndexOf Just Nothing foreign import _lastIndexOf :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Pattern -> String -> 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. -- | -- | ```purescript -- | lastIndexOf' (Pattern "a") 1 "ababa" == Just 0 -- | lastIndexOf' (Pattern "a") 3 "ababa" == Just 2 -- | lastIndexOf' (Pattern "a") 4 "ababa" == Just 4 -- | ``` -- | lastIndexOf' :: Pattern -> Int -> String -> Maybe Int lastIndexOf' = _lastIndexOf' Just Nothing foreign import _lastIndexOf' :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Pattern -> Int -> String -> Maybe Int -- | Returns the number of characters the string is composed of. -- | -- | ```purescript -- | length "Hello World" == 11 -- | ``` -- | foreign import length :: String -> Int -- | 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: -- | -- | ```purescript -- | "ä" `localeCompare` "b" == LT -- | "ä" `compare` "b" == GT -- | ``` -- | localeCompare :: String -> String -> Ordering localeCompare = _localeCompare LT EQ GT foreign import _localeCompare :: Ordering -> Ordering -> Ordering -> String -> String -> Ordering -- | Replaces the first occurence of the pattern with the replacement string. -- | -- | ```purescript -- | replace (Pattern "<=") (Replacement "≤") "a <= b <= c" == "a ≤ b <= c" -- | ``` -- | foreign import replace :: Pattern -> Replacement -> String -> String -- | Replaces all occurences of the pattern with the replacement string. -- | -- | ```purescript -- | replaceAll (Pattern "<=") (Replacement "≤") "a <= b <= c" == "a ≤ b ≤ c" -- | ``` -- | foreign import replaceAll :: Pattern -> Replacement -> String -> String -- | Returns the first `n` characters of the string. -- | -- | ```purescript -- | take 5 "Hello World" == "Hello" -- | ``` -- | foreign import take :: Int -> String -> String -- | Returns the last `n` characters of the string. -- | -- | ```purescript -- | take 5 "Hello World" == "World" -- | ``` -- | takeRight :: Int -> String -> String takeRight i s = drop (length s - i) s -- | Returns the string without the first `n` characters. -- | -- | ```purescript -- | drop 6 "Hello World" == "World" -- | ``` -- | foreign import drop :: Int -> String -> String -- | Returns the string without the last `n` characters. -- | -- | ```purescript -- | dropRight 6 "Hello World" == "Hello" -- | ``` -- | dropRight :: Int -> String -> String dropRight i s = take (length s - i) s -- | Returns the number of contiguous characters at the beginning -- | of the string for which the predicate holds. -- | -- | ```purescript -- | count (_ /= ' ') "Hello World" == 5 -- since length "Hello" == 5 -- | ``` -- | foreign import count :: (Char -> Boolean) -> String -> Int -- | Returns the substrings of the second string separated along occurences -- | of the first string. -- | -- | ```purescript -- | split (Pattern " ") "hello world" == ["hello", "world"] -- | ``` -- | foreign import split :: Pattern -> String -> Array String -- | Returns the substrings of a split at the given index, if the index is within bounds. -- | -- | ```purescript -- | splitAt 2 "Hello World" == Just { before: "He", after: "llo World"} -- | splitAt 10 "Hi" == Nothing -- | ``` -- | splitAt :: Int -> String -> Maybe { before :: String, after :: String } splitAt = _splitAt Just Nothing foreign import _splitAt :: (forall a. a -> Maybe a) -> (forall a. Maybe a) -> Int -> String -> Maybe { before :: String, after :: String } -- | Converts the string into an array of characters. -- | -- | ```purescript -- | toCharArray "Hello☺\n" == ['H','e','l','l','o','☺','\n'] -- | ``` -- | foreign import toCharArray :: String -> Array Char -- | Returns the argument converted to lowercase. -- | -- | ```purescript -- | toLower "hElLo" == "hello" -- | ``` -- | foreign import toLower :: String -> String -- | Returns the argument converted to uppercase. -- | -- | ```purescript -- | toUpper "Hello" == "HELLO" -- | ``` -- | foreign import toUpper :: String -> String -- | Removes whitespace from the beginning and end of a string, including -- | [whitespace characters](http://www.ecma-international.org/ecma-262/5.1/#sec-7.2) -- | and [line terminators](http://www.ecma-international.org/ecma-262/5.1/#sec-7.3). -- | -- | ```purescript -- | trim " Hello \n World\n\t " == "Hello \n World" -- | ``` -- | foreign import trim :: String -> String -- | Joins the strings in the array together, inserting the first argument -- | as separator between them. -- | -- | ```purescript -- | joinWith ", " ["apple", "banana", "orange"] == "apple, banana, orange" -- | ``` -- | foreign import joinWith :: String -> Array String -> String purescript-strings-3.5.0/src/Data/String/000077500000000000000000000000001324034750100203135ustar00rootroot00000000000000purescript-strings-3.5.0/src/Data/String/CaseInsensitiveString.purs000066400000000000000000000014611324034750100255130ustar00rootroot00000000000000module Data.String.CaseInsensitive where import Prelude import Data.Newtype (class Newtype) import Data.String (toLower) -- | A newtype for case insensitive string comparisons and ordering. newtype CaseInsensitiveString = CaseInsensitiveString String instance eqCaseInsensitiveString :: Eq CaseInsensitiveString where eq (CaseInsensitiveString s1) (CaseInsensitiveString s2) = toLower s1 == toLower s2 instance ordCaseInsensitiveString :: Ord CaseInsensitiveString where compare (CaseInsensitiveString s1) (CaseInsensitiveString s2) = compare (toLower s1) (toLower s2) instance showCaseInsensitiveString :: Show CaseInsensitiveString where show (CaseInsensitiveString s) = "(CaseInsensitiveString " <> show s <> ")" derive instance newtypeCaseInsensitiveString :: Newtype CaseInsensitiveString _ purescript-strings-3.5.0/src/Data/String/CodePoints.js000066400000000000000000000056701324034750100227300ustar00rootroot00000000000000"use strict"; /* global Symbol */ var hasArrayFrom = typeof Array.from === "function"; var hasStringIterator = typeof Symbol !== "undefined" && Symbol != null && typeof Symbol.iterator !== "undefined" && typeof String.prototype[Symbol.iterator] === "function"; var hasFromCodePoint = typeof String.prototype.fromCodePoint === "function"; var hasCodePointAt = typeof String.prototype.codePointAt === "function"; exports._unsafeCodePointAt0 = function (fallback) { return hasCodePointAt ? function (str) { return str.codePointAt(0); } : fallback; }; exports._codePointAt = function (fallback) { return function (Just) { return function (Nothing) { return function (unsafeCodePointAt0) { return function (index) { return function (str) { var length = str.length; if (index < 0 || index >= length) return Nothing; if (hasStringIterator) { var iter = str[Symbol.iterator](); for (var i = index;; --i) { var o = iter.next(); if (o.done) return Nothing; if (i === 0) return Just(unsafeCodePointAt0(o.value)); } } return fallback(index)(str); }; }; }; }; }; }; exports._count = function (fallback) { return function (unsafeCodePointAt0) { if (hasStringIterator) { return function (pred) { return function (str) { var iter = str[Symbol.iterator](); for (var cpCount = 0; ; ++cpCount) { var o = iter.next(); if (o.done) return cpCount; var cp = unsafeCodePointAt0(o.value); if (!pred(cp)) return cpCount; } }; }; } return fallback; }; }; exports._fromCodePointArray = function (singleton) { return hasFromCodePoint ? function (cps) { // Function.prototype.apply will fail for very large second parameters, // so we don't use it for arrays with 10,000 or more entries. if (cps.length < 10e3) { return String.fromCodePoint.apply(String, cps); } return cps.map(singleton).join(""); } : function (cps) { return cps.map(singleton).join(""); }; }; exports._singleton = function (fallback) { return hasFromCodePoint ? String.fromCodePoint : fallback; }; exports._take = function (fallback) { return function (n) { if (hasStringIterator) { return function (str) { var accum = ""; var iter = str[Symbol.iterator](); for (var i = 0; i < n; ++i) { var o = iter.next(); if (o.done) return accum; accum += o.value; } return accum; }; } return fallback(n); }; }; exports._toCodePointArray = function (fallback) { return function (unsafeCodePointAt0) { if (hasArrayFrom) { return function (str) { return Array.from(str, unsafeCodePointAt0); }; } return fallback; }; }; purescript-strings-3.5.0/src/Data/String/CodePoints.purs000066400000000000000000000332541324034750100233040ustar00rootroot00000000000000-- | These functions allow PureScript strings to be treated as if they were -- | sequences of Unicode code points instead of their true underlying -- | implementation (sequences of UTF-16 code units). For nearly all uses of -- | strings, these functions should be preferred over the ones in `Data.String`. module Data.String.CodePoints ( module StringReExports , CodePoint() , codePointAt , codePointFromInt , codePointToInt , codePointFromChar , count , drop , dropWhile , fromCodePointArray , indexOf , indexOf' , lastIndexOf , lastIndexOf' , length , singleton , splitAt , take , takeWhile , toCodePointArray , uncons ) where import Prelude import Data.Array as Array import Data.Char (toCharCode) import Data.Char as Char import Data.Int (hexadecimal, toStringAs) import Data.Maybe (Maybe(Just, Nothing)) import Data.String as String import Data.String.Unsafe as Unsafe -- WARN: If a new function is added to Data.String, a version of that function -- should be exported from this module, which should be the same except that it -- should operate on the code point level rather than the code unit level. If -- the function's behaviour does not change based on whether we consider -- strings as sequences of code points or code units, it can simply be -- re-exported from Data.String. import Data.String (Pattern(..), Replacement(..), charAt, charCodeAt, contains, fromCharArray, joinWith, localeCompare, null, replace, replaceAll, split, stripPrefix, stripSuffix, toChar, toCharArray, toLower, toUpper, trim) as StringReExports import Data.Tuple (Tuple(Tuple)) import Data.Unfoldable (unfoldr) -- | CodePoint is an Int bounded between 0 and 0x10FFFF, corresponding to -- | Unicode code points. newtype CodePoint = CodePoint Int derive instance eqCodePoint :: Eq CodePoint derive instance ordCodePoint :: Ord CodePoint instance showCodePoint :: Show CodePoint where show (CodePoint i) = "(CodePoint 0x" <> String.toUpper (toStringAs hexadecimal i) <> ")" -- I would prefer that this smart constructor not need to exist and instead -- CodePoint just implements Enum, but the Enum module already depends on this -- one. To avoid the circular dependency, we just expose these two functions. -- | -- | ```purescript -- | >>> it = codePointFromInt 0x1D400 -- U+1D400 MATHEMATICAL BOLD CAPITAL A -- | Just (CodePoint 0x1D400) -- | -- | >>> map singleton it -- | Just "𝐀" -- | -- | >>> codePointFromInt 0x110000 -- does not correspond to a Unicode code point -- | Nothing -- | ``` -- | codePointFromInt :: Int -> Maybe CodePoint codePointFromInt n | 0 <= n && n <= 0x10FFFF = Just (CodePoint n) codePointFromInt n = Nothing -- | -- | ```purescript -- | >>> codePointToInt (codePointFromChar 'B') -- | 66 -- | -- | >>> boldA = codePointFromInt 0x1D400 -- | >>> boldA -- | Just (CodePoint 0x1D400) -- | >>> map codePointToInt boldA -- | Just 119808 -- is the same as 0x1D400 -- | ``` -- | codePointToInt :: CodePoint -> Int codePointToInt (CodePoint n) = n -- | Creates a CodePoint from a given Char. -- | -- | ```purescript -- | >>> codePointFromChar 'B' -- | CodePoint 0x42 -- represents 'B' -- | ``` -- | codePointFromChar :: Char -> CodePoint codePointFromChar = toCharCode >>> CodePoint unsurrogate :: Int -> Int -> CodePoint unsurrogate lead trail = CodePoint ((lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000) isLead :: Int -> Boolean isLead cu = 0xD800 <= cu && cu <= 0xDBFF isTrail :: Int -> Boolean isTrail cu = 0xDC00 <= cu && cu <= 0xDFFF fromCharCode :: Int -> String fromCharCode = String.singleton <<< Char.fromCharCode -- WARN: this function expects the String parameter to be non-empty unsafeCodePointAt0 :: String -> CodePoint unsafeCodePointAt0 = _unsafeCodePointAt0 unsafeCodePointAt0Fallback foreign import _unsafeCodePointAt0 :: (String -> CodePoint) -> String -> CodePoint unsafeCodePointAt0Fallback :: String -> CodePoint unsafeCodePointAt0Fallback s = let cu0 = Unsafe.charCodeAt 0 s in let cu1 = Unsafe.charCodeAt 1 s in if isLead cu0 && isTrail cu1 then unsurrogate cu0 cu1 else CodePoint cu0 -- | Returns the first code point of the string after dropping the given number -- | of code points from the beginning, if there is such a code point. Operates -- | in constant space and in time linear to the given index. -- | -- | ```purescript -- | >>> codePointAt 1 "𝐀𝐀𝐀𝐀" -- | Just (CodePoint 0x1D400) -- represents "𝐀" -- | -- compare to Data.String: -- | >>> charAt 1 "𝐀𝐀𝐀𝐀" -- | Just '�' -- | ``` -- | codePointAt :: Int -> String -> Maybe CodePoint codePointAt n _ | n < 0 = Nothing codePointAt 0 "" = Nothing codePointAt 0 s = Just (unsafeCodePointAt0 s) codePointAt n s = _codePointAt codePointAtFallback Just Nothing unsafeCodePointAt0 n s foreign import _codePointAt :: (Int -> String -> Maybe CodePoint) -> (forall a. a -> Maybe a) -> (forall a. Maybe a) -> (String -> CodePoint) -> Int -> String -> Maybe CodePoint codePointAtFallback :: Int -> String -> Maybe CodePoint codePointAtFallback n s = case uncons s of Just { head, tail } -> if n == 0 then Just head else codePointAtFallback (n - 1) tail _ -> Nothing -- | Returns the number of code points in the leading sequence of code points -- | which all match the given predicate. Operates in constant space and in -- | time linear to the length of the string. -- | -- | ```purescript -- | >>> count (\c -> codePointToInt c == 0x1D400) "𝐀𝐀 b c 𝐀" -- | 2 -- | ``` -- | count :: (CodePoint -> Boolean) -> String -> Int count = _count countFallback unsafeCodePointAt0 foreign import _count :: ((CodePoint -> Boolean) -> String -> Int) -> (String -> CodePoint) -> (CodePoint -> Boolean) -> String -> Int countFallback :: (CodePoint -> Boolean) -> String -> Int countFallback p s = countTail p s 0 countTail :: (CodePoint -> Boolean) -> String -> Int -> Int countTail p s accum = case uncons s of Just { head, tail } -> if p head then countTail p tail (accum + 1) else accum _ -> accum -- | Drops the given number of code points from the beginning of the string. If -- | the string does not have that many code points, returns the empty string. -- | Operates in constant space and in time linear to the given number. -- | -- | ```purescript -- | >>> drop 5 "𝐀𝐀 b c" -- | "c" -- | -- compared to Data.String: -- | >>> drop 5 "𝐀𝐀 b c" -- | "b c" -- because "𝐀" occupies 2 code units -- | ``` -- | drop :: Int -> String -> String drop n s = String.drop (String.length (take n s)) s -- | Drops the leading sequence of code points which all match the given -- | predicate from the string. Operates in constant space and in time linear -- | to the length of the string. -- | -- | ```purescript -- | >>> dropWhile (\c -> codePointToInt c == 0x1D400) "𝐀𝐀 b c 𝐀" -- | " b c 𝐀" -- | ``` -- | dropWhile :: (CodePoint -> Boolean) -> String -> String dropWhile p s = drop (count p s) s -- | Creates a string from an array of code points. Operates in space and time -- | linear to the length of the array. -- | -- | ```purescript -- | >>> codePointArray = toCodePointArray "c 𝐀" -- | >>> codePointArray -- | [CodePoint 0x63, CodePoint 0x20, CodePoint 0x1D400] -- | >>> fromCodePointArray codePointArray -- | "c 𝐀" -- | ``` -- | fromCodePointArray :: Array CodePoint -> String fromCodePointArray = _fromCodePointArray singletonFallback foreign import _fromCodePointArray :: (CodePoint -> String) -> Array CodePoint -> String -- | Returns the number of code points preceding the first match of the given -- | pattern in the string. Returns Nothing when no matches are found. -- | -- | ```purescript -- | >>> indexOf (Pattern "𝐀") "b 𝐀𝐀 c 𝐀" -- | Just 2 -- | >>> indexOf (Pattern "o") "b 𝐀𝐀 c 𝐀" -- | Nothing -- | ``` -- | indexOf :: String.Pattern -> String -> Maybe Int indexOf p s = (\i -> length (String.take i s)) <$> String.indexOf p s -- | Returns the number of code points preceding the first match of the given -- | pattern in the string. Pattern matches preceding the given index will be -- | ignored. Returns Nothing when no matches are found. -- | -- | ```purescript -- | >>> indexOf' (Pattern "𝐀") 4 "b 𝐀𝐀 c 𝐀" -- | Just 7 -- | >>> indexOf' (Pattern "o") 4 "b 𝐀𝐀 c 𝐀" -- | Nothing -- | ``` -- | indexOf' :: String.Pattern -> Int -> String -> Maybe Int indexOf' p i s = let s' = drop i s in (\k -> i + length (String.take k s')) <$> String.indexOf p s' -- | Returns the number of code points preceding the last match of the given -- | pattern in the string. Returns Nothing when no matches are found. -- | -- | ```purescript -- | >>> lastIndexOf (Pattern "𝐀") "b 𝐀𝐀 c 𝐀" -- | Just 7 -- | >>> lastIndexOf (Pattern "o") "b 𝐀𝐀 c 𝐀" -- | Nothing -- | ``` -- | lastIndexOf :: String.Pattern -> String -> Maybe Int lastIndexOf p s = (\i -> length (String.take i s)) <$> String.lastIndexOf p s -- | Returns the number of code points preceding the first match of the given -- | pattern in the string. Pattern matches following the given index will be -- | ignored. Returns Nothing when no matches are found. -- | -- | ```purescript -- | >>> lastIndexOf' (Pattern "𝐀") 5 "b 𝐀𝐀 c 𝐀" -- | Just 3 -- | >>> lastIndexOf' (Pattern "o") 5 "b 𝐀𝐀 c 𝐀" -- | Nothing -- | ``` -- | lastIndexOf' :: String.Pattern -> Int -> String -> Maybe Int lastIndexOf' p i s = let i' = String.length (take i s) in (\k -> length (String.take k s)) <$> String.lastIndexOf' p i' s -- | Returns the number of code points in the string. Operates in constant -- | space and in time linear to the length of the string. -- | -- | ```purescript -- | >>> length "b 𝐀𝐀 c 𝐀" -- | 8 -- | -- compare to Data.String: -- | >>> length "b 𝐀𝐀 c 𝐀" -- | 11 -- | ``` -- | length :: String -> Int length = Array.length <<< toCodePointArray -- | Creates a string containing just the given code point. Operates in -- | constant space and time. -- | -- | ```purescript -- | >>> map singleton (codePointFromInt 0x1D400) -- | Just "𝐀" -- | ``` -- | singleton :: CodePoint -> String singleton = _singleton singletonFallback foreign import _singleton :: (CodePoint -> String) -> CodePoint -> String singletonFallback :: CodePoint -> String singletonFallback (CodePoint cp) | cp <= 0xFFFF = fromCharCode cp singletonFallback (CodePoint cp) = let lead = ((cp - 0x10000) / 0x400) + 0xD800 in let trail = (cp - 0x10000) `mod` 0x400 + 0xDC00 in fromCharCode lead <> fromCharCode trail -- | Returns a record with strings created from the code points on either side -- | of the given index. If the index is not within the string, Nothing is -- | returned. -- | -- | ```purescript -- | >>> splitAt 3 "b 𝐀𝐀 c 𝐀" -- | Just { before: "b 𝐀", after: "𝐀 c 𝐀" } -- | ``` -- | splitAt :: Int -> String -> Maybe { before :: String, after :: String } splitAt i s = let cps = toCodePointArray s in if i < 0 || Array.length cps < i then Nothing else Just { before: fromCodePointArray (Array.take i cps), after: fromCodePointArray (Array.drop i cps) } -- | Returns a string containing the given number of code points from the -- | beginning of the given string. If the string does not have that many code -- | points, returns the empty string. Operates in constant space and in time -- | linear to the given number. -- | -- | ```purescript -- | >>> take 3 "b 𝐀𝐀 c 𝐀" -- | "b 𝐀" -- | -- compare to Data.String: -- | >>> take 3 "b 𝐀𝐀 c 𝐀" -- | "b �" -- | ``` -- | take :: Int -> String -> String take = _take takeFallback foreign import _take :: (Int -> String -> String) -> Int -> String -> String takeFallback :: Int -> String -> String takeFallback n _ | n < 1 = "" takeFallback n s = case uncons s of Just { head, tail } -> singleton head <> takeFallback (n - 1) tail _ -> s -- | Returns a string containing the leading sequence of code points which all -- | match the given predicate from the string. Operates in constant space and -- | in time linear to the length of the string. -- | -- | ```purescript -- | >>> takeWhile (\c -> codePointToInt c == 0x1D400) "𝐀𝐀 b c 𝐀" -- | "𝐀𝐀" -- | ``` -- | takeWhile :: (CodePoint -> Boolean) -> String -> String takeWhile p s = take (count p s) s -- | Creates an array of code points from a string. Operates in space and time -- | linear to the length of the string. -- | -- | ```purescript -- | >>> codePointArray = toCodePointArray "b 𝐀𝐀" -- | >>> codePointArray -- | [CodePoint 0x62, CodePoint 0x20, CodePoint 0x1D400, CodePoint 0x1D400] -- | >>> map singleton codePointArray -- | ["b", " ", "𝐀", "𝐀"] -- | ``` -- | toCodePointArray :: String -> Array CodePoint toCodePointArray = _toCodePointArray toCodePointArrayFallback unsafeCodePointAt0 foreign import _toCodePointArray :: (String -> Array CodePoint) -> (String -> CodePoint) -> String -> Array CodePoint toCodePointArrayFallback :: String -> Array CodePoint toCodePointArrayFallback s = unfoldr unconsButWithTuple s unconsButWithTuple :: String -> Maybe (Tuple CodePoint String) unconsButWithTuple s = (\{ head, tail } -> Tuple head tail) <$> uncons s -- | Returns a record with the first code point and the remaining code points -- | of the string. Returns Nothing if the string is empty. Operates in -- | constant space and time. -- | -- | ```purescript -- | >>> uncons "𝐀𝐀 c 𝐀" -- | Just { head: CodePoint 0x1D400, tail: "𝐀 c 𝐀" } -- | >>> uncons "" -- | Nothing -- | ``` -- | uncons :: String -> Maybe { head :: CodePoint, tail :: String } uncons s = case String.length s of 0 -> Nothing 1 -> Just { head: CodePoint (Unsafe.charCodeAt 0 s), tail: "" } _ -> let cu0 = Unsafe.charCodeAt 0 s in let cu1 = Unsafe.charCodeAt 1 s in if isLead cu0 && isTrail cu1 then Just { head: unsurrogate cu0 cu1, tail: String.drop 2 s } else Just { head: CodePoint cu0, tail: String.drop 1 s } purescript-strings-3.5.0/src/Data/String/Gen.purs000066400000000000000000000023071324034750100217410ustar00rootroot00000000000000module Data.String.Gen where import Prelude import Control.Monad.Gen (class MonadGen, chooseInt, unfoldable, sized, resize) import Control.Monad.Rec.Class (class MonadRec) import Data.Char.Gen as CG import Data.String as S -- | Generates a string using the specified character generator. genString :: forall m. MonadRec m => MonadGen m => m Char -> m String genString genChar = sized \size -> do newSize <- chooseInt 1 (max 1 size) resize (const newSize) $ S.fromCharArray <$> unfoldable genChar -- | Generates a string using characters from the Unicode basic multilingual -- | plain. genUnicodeString :: forall m. MonadRec m => MonadGen m => m String genUnicodeString = genString CG.genUnicodeChar -- | Generates a string using the ASCII character set, excluding control codes. genAsciiString :: forall m. MonadRec m => MonadGen m => m String genAsciiString = genString CG.genAsciiChar -- | Generates a string using the ASCII character set. genAsciiString' :: forall m. MonadRec m => MonadGen m => m String genAsciiString' = genString CG.genAsciiChar' -- | Generates a string made up of numeric digits. genDigitString :: forall m. MonadRec m => MonadGen m => m String genDigitString = genString CG.genDigitChar purescript-strings-3.5.0/src/Data/String/NonEmpty.purs000066400000000000000000000433371324034750100230110ustar00rootroot00000000000000-- | Non-empty strings. -- | -- | Please note that the examples in this documentation use a notation like -- | `NonEmptyString "..."` for demonstration purposes, `NonEmptyString` cannot -- | be created directly like that, as we can't prove the string is non-empty to -- | the compiler at compile-time. module Data.String.NonEmpty ( NonEmptyString , NonEmptyReplacement(..) , fromString , unsafeFromString , fromCharArray , singleton , cons , snoc , fromFoldable1 , toString , toCharArray , charAt , charCodeAt , toChar , appendString , prependString , contains , indexOf , indexOf' , lastIndexOf , lastIndexOf' , uncons , length , localeCompare , replace , replaceAll , take , takeRight , takeWhile , drop , dropRight , dropWhile , stripPrefix , stripSuffix , count , splitAt , toLower , toUpper , trim , joinWith , join1With , joinWith1 , module Data.String ) where import Prelude import Data.Foldable (class Foldable) import Data.Foldable as F import Data.Maybe (Maybe(..), fromJust) import Data.Semigroup.Foldable (class Foldable1) import Data.Semigroup.Foldable as F1 import Data.String (Pattern(..)) import Data.String as String import Data.String.Unsafe as U import Unsafe.Coerce (unsafeCoerce) -- | A string that is known not to be empty. newtype NonEmptyString = NonEmptyString String derive newtype instance eqNonEmptyString ∷ Eq NonEmptyString derive newtype instance ordNonEmptyString ∷ Ord NonEmptyString derive newtype instance semigroupNonEmptyString ∷ Semigroup NonEmptyString instance showNonEmptyString :: Show NonEmptyString where show (NonEmptyString s) = "(NonEmptyString.unsafeFromString " <> show s <> ")" -- | A newtype used in cases to specify a non-empty replacement for a pattern. newtype NonEmptyReplacement = NonEmptyReplacement NonEmptyString derive newtype instance eqNonEmptyReplacement :: Eq NonEmptyReplacement derive newtype instance ordNonEmptyReplacement :: Ord NonEmptyReplacement derive newtype instance semigroupNonEmptyReplacement ∷ Semigroup NonEmptyReplacement instance showNonEmptyReplacement :: Show NonEmptyReplacement where show (NonEmptyReplacement s) = "(NonEmptyReplacement " <> show s <> ")" -- | Creates a `NonEmptyString` from a `String`, returning `Nothing` if the -- | input is empty. -- | -- | ```purescript -- | fromString "" = Nothing -- | fromString "hello" = Just (NonEmptyString "hello") -- | ``` fromString :: String -> Maybe NonEmptyString fromString = case _ of "" -> Nothing s -> Just (NonEmptyString s) -- | A partial version of `fromString`. unsafeFromString :: Partial => String -> NonEmptyString unsafeFromString = fromJust <<< fromString -- | Creates a `NonEmptyString` from a character array `String`, returning -- | `Nothing` if the input is empty. -- | -- | ```purescript -- | fromCharArray [] = Nothing -- | fromCharArray ['a', 'b', 'c'] = Just (NonEmptyString "abc") -- | ``` fromCharArray :: Array Char -> Maybe NonEmptyString fromCharArray = case _ of [] -> Nothing cs -> Just (NonEmptyString (String.fromCharArray cs)) -- | Creates a `NonEmptyString` from a character. singleton :: Char -> NonEmptyString singleton = NonEmptyString <<< String.singleton -- | Creates a `NonEmptyString` from a string by prepending a character. -- | -- | ```purescript -- | cons 'a' "bc" = NonEmptyString "abc" -- | cons 'a' "" = NonEmptyString "a" -- | ``` cons :: Char -> String -> NonEmptyString cons c s = NonEmptyString (String.singleton c <> s) -- | Creates a `NonEmptyString` from a string by appending a character. -- | -- | ```purescript -- | snoc 'c' "ab" = NonEmptyString "abc" -- | snoc 'a' "" = NonEmptyString "a" -- | ``` snoc :: Char -> String -> NonEmptyString snoc c s = NonEmptyString (s <> String.singleton c) -- | Creates a `NonEmptyString` from a `Foldable1` container carrying -- | characters. fromFoldable1 :: forall f. Foldable1 f => f Char -> NonEmptyString fromFoldable1 = F1.fold1 <<< coe where coe ∷ f Char -> f NonEmptyString coe = unsafeCoerce -- | Converts a `NonEmptyString` back into a standard `String`. toString :: NonEmptyString -> String toString (NonEmptyString s) = s -- | Returns the character at the given index, if the index is within bounds. -- | -- | ```purescript -- | charAt 2 (NonEmptyString "Hello") == Just 'l' -- | charAt 10 (NonEmptyString "Hello") == Nothing -- | ``` charAt :: Int -> NonEmptyString -> Maybe Char charAt = liftS <<< String.charAt -- | Returns the numeric Unicode value of the character at the given index, -- | if the index is within bounds. -- | -- | ```purescript -- | charCodeAt 2 (NonEmptyString "5 €") == Just 0x20AC -- | charCodeAt 10 (NonEmptyString "5 €") == Nothing -- | ``` charCodeAt :: Int -> NonEmptyString -> Maybe Int charCodeAt = liftS <<< String.charCodeAt -- | Converts the `NonEmptyString` to a character, if the length of the string -- | is exactly `1`. -- | -- | ```purescript -- | toChar "H" == Just 'H' -- | toChar "Hi" == Nothing -- | ``` toChar :: NonEmptyString -> Maybe Char toChar (NonEmptyString s) = String.toChar s -- | Converts the `NonEmptyString` into an array of characters. -- | -- | ```purescript -- | toCharArray (NonEmptyString "Hello☺\n") == ['H','e','l','l','o','☺','\n'] -- | ``` toCharArray :: NonEmptyString -> Array Char toCharArray (NonEmptyString s) = String.toCharArray s -- | Appends a string to this non-empty string. Since one of the strings is -- | non-empty we know the result will be too. -- | -- | ```purescript -- | appendString (NonEmptyString "Hello") " world" == NonEmptyString "Hello world" -- | appendString (NonEmptyString "Hello") "" == NonEmptyString "Hello" -- | ``` appendString :: NonEmptyString -> String -> NonEmptyString appendString (NonEmptyString s1) s2 = NonEmptyString (s1 <> s2) -- | Prepends a string to this non-empty string. Since one of the strings is -- | non-empty we know the result will be too. -- | -- | ```purescript -- | prependString "be" (NonEmptyString "fore") == NonEmptyString "before" -- | prependString "" (NonEmptyString "fore") == NonEmptyString "fore" -- | ``` prependString :: String -> NonEmptyString -> NonEmptyString prependString s1 (NonEmptyString s2) = NonEmptyString (s1 <> s2) -- | Returns the first character and the rest of the string. -- | -- | ```purescript -- | uncons "a" == { head: 'a', tail: Nothing } -- | uncons "Hello World" == { head: 'H', tail: Just (NonEmptyString "ello World") } -- | ``` uncons :: NonEmptyString -> { head :: Char, tail :: Maybe NonEmptyString } uncons (NonEmptyString s) = { head: U.charAt 0 s , tail: fromString (String.drop 1 s) } -- | Returns the longest prefix of characters that satisfy the predicate. -- | `Nothing` is returned if there is no matching prefix. -- | -- | ```purescript -- | takeWhile (_ /= ':') (NonEmptyString "http://purescript.org") == Just (NonEmptyString "http") -- | takeWhile (_ == 'a') (NonEmptyString "xyz") == Nothing -- | ``` takeWhile :: (Char -> Boolean) -> NonEmptyString -> Maybe NonEmptyString takeWhile f = fromString <<< liftS (String.takeWhile f) -- | Returns the suffix remaining after `takeWhile`. -- | -- | ```purescript -- | dropWhile (_ /= '.') (NonEmptyString "Test.purs") == Just (NonEmptyString ".purs") -- | ``` dropWhile :: (Char -> Boolean) -> NonEmptyString -> Maybe NonEmptyString dropWhile f = fromString <<< liftS (String.dropWhile f) -- | 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`. -- | -- | ```purescript -- | 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 -- | ``` stripPrefix :: Pattern -> NonEmptyString -> Maybe NonEmptyString stripPrefix pat = fromString <=< liftS (String.stripPrefix pat) -- | 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`. -- | -- | ```purescript -- | stripSuffix (Pattern ".exe") (NonEmptyString "purs.exe") == Just (NonEmptyString "purs") -- | stripSuffix (Pattern ".exe") (NonEmptyString "purs") == Nothing -- | stripSuffix (Pattern "Hello!") (NonEmptyString "Hello!") == Nothing -- | ``` stripSuffix :: Pattern -> NonEmptyString -> Maybe NonEmptyString stripSuffix pat = fromString <=< liftS (String.stripSuffix pat) -- | Checks whether the pattern appears in the given string. -- | -- | ```purescript -- | contains (Pattern "needle") (NonEmptyString "haystack with needle") == true -- | contains (Pattern "needle") (NonEmptyString "haystack") == false -- | ``` contains :: Pattern -> NonEmptyString -> Boolean contains = liftS <<< String.contains -- | Returns the index of the first occurrence of the pattern in the -- | given string. Returns `Nothing` if there is no match. -- | -- | ```purescript -- | indexOf (Pattern "c") (NonEmptyString "abcdc") == Just 2 -- | indexOf (Pattern "c") (NonEmptyString "aaa") == Nothing -- | ``` indexOf :: Pattern -> NonEmptyString -> Maybe Int indexOf = liftS <<< String.indexOf -- | 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. -- | -- | ```purescript -- | indexOf' (Pattern "a") 2 (NonEmptyString "ababa") == Just 2 -- | indexOf' (Pattern "a") 3 (NonEmptyString "ababa") == Just 4 -- | ``` indexOf' :: Pattern -> Int -> NonEmptyString -> Maybe Int indexOf' pat = liftS <<< String.indexOf' pat -- | Returns the index of the last occurrence of the pattern in the -- | given string. Returns `Nothing` if there is no match. -- | -- | ```purescript -- | lastIndexOf (Pattern "c") (NonEmptyString "abcdc") == Just 4 -- | lastIndexOf (Pattern "c") (NonEmptyString "aaa") == Nothing -- | ``` lastIndexOf :: Pattern -> NonEmptyString -> Maybe Int lastIndexOf = liftS <<< String.lastIndexOf -- | 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. -- | -- | ```purescript -- | lastIndexOf' (Pattern "a") 1 (NonEmptyString "ababa") == Just 0 -- | lastIndexOf' (Pattern "a") 3 (NonEmptyString "ababa") == Just 2 -- | lastIndexOf' (Pattern "a") 4 (NonEmptyString "ababa") == Just 4 -- | ``` lastIndexOf' :: Pattern -> Int -> NonEmptyString -> Maybe Int lastIndexOf' pat = liftS <<< String.lastIndexOf' pat -- | Returns the number of characters the string is composed of. -- | -- | ```purescript -- | length (NonEmptyString "Hello World") == 11 -- | ``` length :: NonEmptyString -> Int length (NonEmptyString s) = String.length s -- | 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: -- | -- | ```purescript -- | NonEmptyString "ä" `localeCompare` NonEmptyString "b" == LT -- | NonEmptyString "ä" `compare` NonEmptyString "b" == GT -- | ``` localeCompare :: NonEmptyString -> NonEmptyString -> Ordering localeCompare (NonEmptyString a) (NonEmptyString b) = String.localeCompare a b -- | Replaces the first occurence of the pattern with the replacement string. -- | -- | ```purescript -- | replace (Pattern "<=") (NonEmptyReplacement "≤") (NonEmptyString "a <= b <= c") == NonEmptyString "a ≤ b <= c" -- | ``` replace :: Pattern -> NonEmptyReplacement -> NonEmptyString -> NonEmptyString replace pat (NonEmptyReplacement (NonEmptyString rep)) (NonEmptyString s) = NonEmptyString (String.replace pat (String.Replacement rep) s) -- | Replaces all occurences of the pattern with the replacement string. -- | -- | ```purescript -- | replaceAll (Pattern "<=") (NonEmptyReplacement "≤") (NonEmptyString "a <= b <= c") == NonEmptyString "a ≤ b ≤ c" -- | ``` replaceAll :: Pattern -> NonEmptyReplacement -> NonEmptyString -> NonEmptyString replaceAll pat (NonEmptyReplacement (NonEmptyString rep)) (NonEmptyString s) = NonEmptyString (String.replaceAll pat (String.Replacement rep) s) -- | Returns the first `n` characters of the string. Returns `Nothing` if `n` is -- | less than 1. -- | -- | ```purescript -- | take 5 (NonEmptyString "Hello World") == Just (NonEmptyString "Hello") -- | take 0 (NonEmptyString "Hello World") == Nothing -- | ``` take :: Int -> NonEmptyString -> Maybe NonEmptyString take i (NonEmptyString s) | i < 1 = Nothing | otherwise = Just (NonEmptyString (String.take i s)) -- | Returns the last `n` characters of the string. Returns `Nothing` if `n` is -- | less than 1. -- | -- | ```purescript -- | take 5 (NonEmptyString "Hello World") == Just (NonEmptyString "World") -- | take 0 (NonEmptyString "Hello World") == Nothing -- | ``` takeRight :: Int -> NonEmptyString -> Maybe NonEmptyString takeRight i (NonEmptyString s) | i < 1 = Nothing | otherwise = Just (NonEmptyString (String.takeRight i s)) -- | Returns the string without the first `n` characters. Returns `Nothing` if -- | more characters are dropped than the string is long. -- | -- | ```purescript -- | drop 6 (NonEmptyString "Hello World") == Just (NonEmptyString "World") -- | drop 20 (NonEmptyString "Hello World") == Nothing -- | ``` drop :: Int -> NonEmptyString -> Maybe NonEmptyString drop i (NonEmptyString s) | i >= String.length s = Nothing | otherwise = Just (NonEmptyString (String.drop i s)) -- | Returns the string without the last `n` characters. Returns `Nothing` if -- | more characters are dropped than the string is long. -- | -- | ```purescript -- | dropRight 6 (NonEmptyString "Hello World") == Just (NonEmptyString "Hello") -- | dropRight 20 (NonEmptyString "Hello World") == Nothing -- | ``` dropRight :: Int -> NonEmptyString -> Maybe NonEmptyString dropRight i (NonEmptyString s) | i >= String.length s = Nothing | otherwise = Just (NonEmptyString (String.dropRight i s)) -- | Returns the number of contiguous characters at the beginning of the string -- | for which the predicate holds. -- | -- | ```purescript -- | count (_ /= 'o') (NonEmptyString "Hello World") == 4 -- | ``` count :: (Char -> Boolean) -> NonEmptyString -> Int count = liftS <<< String.count -- | Returns the substrings of a split at the given index, if the index is -- | within bounds. -- | -- | ```purescript -- | splitAt 2 (NonEmptyString "Hello World") == Just { before: Just (NonEmptyString "He"), after: Just (NonEmptyString "llo World") } -- | splitAt 10 (NonEmptyString "Hi") == Nothing -- | ``` splitAt :: Int -> NonEmptyString -> Maybe { before :: Maybe NonEmptyString, after :: Maybe NonEmptyString } splitAt i (NonEmptyString s) = case String.splitAt i s of Just { before, after } -> Just { before: fromString before, after: fromString after } Nothing -> Nothing -- | Returns the argument converted to lowercase. -- | -- | ```purescript -- | toLower (NonEmptyString "hElLo") == NonEmptyString "hello" -- | ``` toLower :: NonEmptyString -> NonEmptyString toLower (NonEmptyString s) = NonEmptyString (String.toLower s) -- | Returns the argument converted to uppercase. -- | -- | ```purescript -- | toUpper (NonEmptyString "Hello") == NonEmptyString "HELLO" -- | ``` toUpper :: NonEmptyString -> NonEmptyString toUpper (NonEmptyString s) = NonEmptyString (String.toUpper s) -- | Removes whitespace from the beginning and end of a string, including -- | [whitespace characters](http://www.ecma-international.org/ecma-262/5.1/#sec-7.2) -- | and [line terminators](http://www.ecma-international.org/ecma-262/5.1/#sec-7.3). -- | If the string is entirely made up of whitespace the result will be Nothing. -- | -- | ```purescript -- | trim (NonEmptyString " Hello \n World\n\t ") == Just (NonEmptyString "Hello \n World") -- | trim (NonEmptyString " \n") == Nothing -- | ``` trim :: NonEmptyString -> Maybe NonEmptyString trim (NonEmptyString s) = fromString (String.trim s) -- | 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. -- | -- | ```purescript -- | joinWith ", " [NonEmptyString "apple", NonEmptyString "banana"] == "apple, banana" -- | joinWith ", " [] == "" -- | ``` joinWith :: forall f. Foldable f => String -> f NonEmptyString -> String joinWith splice = F.intercalate splice <<< coe where coe :: f NonEmptyString -> f String coe = unsafeCoerce -- | 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. -- | -- | ```purescript -- | -- 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" -- | ``` join1With :: forall f. Foldable1 f => String -> f NonEmptyString -> NonEmptyString join1With splice = NonEmptyString <<< joinWith splice -- | 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. -- | -- | ```purescript -- | -- 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/" -- | ``` joinWith1 :: forall f. Foldable1 f => NonEmptyString -> f String -> NonEmptyString joinWith1 (NonEmptyString splice) = NonEmptyString <<< F.intercalate splice liftS :: forall r. (String -> r) -> NonEmptyString -> r liftS f (NonEmptyString s) = f s purescript-strings-3.5.0/src/Data/String/Regex.js000066400000000000000000000034731324034750100217320ustar00rootroot00000000000000"use strict"; exports["showRegex'"] = function (r) { return "" + r; }; exports["regex'"] = function (left) { return function (right) { return function (s1) { return function (s2) { try { return right(new RegExp(s1, s2)); } catch (e) { return left(e.message); } }; }; }; }; exports.source = function (r) { return r.source; }; exports["flags'"] = function (r) { return { multiline: r.multiline, ignoreCase: r.ignoreCase, global: r.global, sticky: !!r.sticky, unicode: !!r.unicode }; }; exports.test = function (r) { return function (s) { var lastIndex = r.lastIndex; var result = r.test(s); r.lastIndex = lastIndex; return result; }; }; exports._match = function (just) { return function (nothing) { return function (r) { return function (s) { var m = s.match(r); if (m == null) { return nothing; } else { for (var i = 0; i < m.length; i++) { m[i] = m[i] == null ? nothing : just(m[i]); } return just(m); } }; }; }; }; exports.replace = function (r) { return function (s1) { return function (s2) { return s2.replace(r, s1); }; }; }; exports["replace'"] = function (r) { return function (f) { return function (s2) { return s2.replace(r, function (match) { return f(match)(Array.prototype.splice.call(arguments, 1, arguments.length - 3)); }); }; }; }; exports._search = function (just) { return function (nothing) { return function (r) { return function (s) { var result = s.search(r); return result === -1 ? nothing : just(result); }; }; }; }; exports.split = function (r) { return function (s) { return s.split(r); }; }; purescript-strings-3.5.0/src/Data/String/Regex.purs000066400000000000000000000100541324034750100223000ustar00rootroot00000000000000-- | Wraps Javascript's `RegExp` object that enables matching strings with -- | patternes defined by regular expressions. -- | For details of the underlying implementation, see [RegExp Reference at MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp). module Data.String.Regex ( Regex(..) , regex , source , flags , renderFlags , parseFlags , test , match , replace , replace' , search , split ) where import Prelude import Data.Either (Either(..)) import Data.Maybe (Maybe(..)) import Data.String (Pattern(..), contains) import Data.String.Regex.Flags (RegexFlags(..), RegexFlagsRec) -- | Wraps Javascript `RegExp` objects. foreign import data Regex :: Type foreign import showRegex' :: Regex -> String instance showRegex :: Show Regex where show = showRegex' foreign import regex' :: (String -> Either String Regex) -> (Regex -> Either String Regex) -> String -> String -> Either String Regex -- | Constructs a `Regex` from a pattern string and flags. Fails with -- | `Left error` if the pattern contains a syntax error. regex :: String -> RegexFlags -> Either String Regex regex s f = regex' Left Right s $ renderFlags f -- | Returns the pattern string used to construct the given `Regex`. foreign import source :: Regex -> String -- | Returns the `RegexFlags` used to construct the given `Regex`. flags :: Regex -> RegexFlags flags = RegexFlags <<< flags' -- | Returns the `RegexFlags` inner record used to construct the given `Regex`. foreign import flags' :: Regex -> RegexFlagsRec -- | Returns the string representation of the given `RegexFlags`. renderFlags :: RegexFlags -> String renderFlags (RegexFlags f) = (if f.global then "g" else "") <> (if f.ignoreCase then "i" else "") <> (if f.multiline then "m" else "") <> (if f.sticky then "y" else "") <> (if f.unicode then "u" else "") -- | Parses the string representation of `RegexFlags`. parseFlags :: String -> RegexFlags parseFlags s = RegexFlags { global: contains (Pattern "g") s , ignoreCase: contains (Pattern "i") s , multiline: contains (Pattern "m") s , sticky: contains (Pattern "y") s , unicode: contains (Pattern "u") s } -- | Returns `true` if the `Regex` matches the string. In contrast to -- | `RegExp.prototype.test()` in JavaScript, `test` does not affect -- | the `lastIndex` property of the Regex. foreign import test :: Regex -> String -> Boolean foreign import _match :: (forall r. r -> Maybe r) -> (forall r. Maybe r) -> Regex -> String -> Maybe (Array (Maybe String)) -- | Matches the string against the `Regex` and returns an array of matches -- | if there were any. Each match has type `Maybe String`, where `Nothing` -- | represents an unmatched optional capturing group. -- | See [reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match). match :: Regex -> String -> Maybe (Array (Maybe String)) match = _match Just Nothing -- | Replaces occurences of the `Regex` with the first string. The replacement -- | string can include special replacement patterns escaped with `"$"`. -- | See [reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace). foreign import replace :: Regex -> String -> String -> String -- | Transforms occurences of the `Regex` using a function of the matched -- | substring and a list of submatch strings. -- | See the [reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#Specifying_a_function_as_a_parameter). foreign import replace' :: Regex -> (String -> Array String -> String) -> String -> String foreign import _search :: (forall r. r -> Maybe r) -> (forall r. Maybe r) -> Regex -> String -> Maybe Int -- | Returns `Just` the index of the first match of the `Regex` in the string, -- | or `Nothing` if there is no match. search :: Regex -> String -> Maybe Int search = _search Just Nothing -- | Split the string into an array of substrings along occurences of the `Regex`. foreign import split :: Regex -> String -> Array String purescript-strings-3.5.0/src/Data/String/Regex/000077500000000000000000000000001324034750100213655ustar00rootroot00000000000000purescript-strings-3.5.0/src/Data/String/Regex/Flags.purs000066400000000000000000000047531324034750100233450ustar00rootroot00000000000000module Data.String.Regex.Flags where import Prelude import Control.MonadPlus (guard) import Data.Monoid (class Monoid) import Data.String (joinWith) type RegexFlagsRec = { global :: Boolean , ignoreCase :: Boolean , multiline :: Boolean , sticky :: Boolean , unicode :: Boolean } -- | Flags that control matching. data RegexFlags = RegexFlags RegexFlagsRec -- | All flags set to false. noFlags :: RegexFlags noFlags = RegexFlags { global: false , ignoreCase: false , multiline: false , sticky: false , unicode: false } -- | Only global flag set to true global :: RegexFlags global = RegexFlags { global: true , ignoreCase: false , multiline: false , sticky: false , unicode: false } -- | Only ignoreCase flag set to true ignoreCase :: RegexFlags ignoreCase = RegexFlags { global: false , ignoreCase: true , multiline: false , sticky: false , unicode: false } -- | Only multiline flag set to true multiline :: RegexFlags multiline = RegexFlags { global: false , ignoreCase: false , multiline: true , sticky: false , unicode: false } -- | Only sticky flag set to true sticky :: RegexFlags sticky = RegexFlags { global: false , ignoreCase: false , multiline: false , sticky: true , unicode: false } -- | Only unicode flag set to true unicode :: RegexFlags unicode = RegexFlags { global: false , ignoreCase: false , multiline: false , sticky: false , unicode: true } instance semigroupRegexFlags :: Semigroup RegexFlags where append (RegexFlags x) (RegexFlags y) = RegexFlags { global: x.global || y.global , ignoreCase: x.ignoreCase || y.ignoreCase , multiline: x.multiline || y.multiline , sticky: x.sticky || y.sticky , unicode: x.unicode || y.unicode } instance monoidRegexFlags :: Monoid RegexFlags where mempty = noFlags instance eqRegexFlags :: Eq RegexFlags where eq (RegexFlags x) (RegexFlags y) = x.global == y.global && x.ignoreCase == y.ignoreCase && x.multiline == y.multiline && x.sticky == y.sticky && x.unicode == y.unicode instance showRegexFlags :: Show RegexFlags where show (RegexFlags flags) = let usedFlags = [] <> (guard flags.global $> "global") <> (guard flags.ignoreCase $> "ignoreCase") <> (guard flags.multiline $> "multiline") <> (guard flags.sticky $> "sticky") <> (guard flags.unicode $> "unicode") in if usedFlags == [] then "noFlags" else "(" <> joinWith " <> " usedFlags <> ")" purescript-strings-3.5.0/src/Data/String/Regex/Unsafe.purs000066400000000000000000000007031324034750100235210ustar00rootroot00000000000000module Data.String.Regex.Unsafe ( unsafeRegex ) where import Data.Either (fromRight) import Data.String.Regex (Regex, regex) import Data.String.Regex.Flags (RegexFlags) import Partial.Unsafe (unsafePartial) -- | Constructs a `Regex` from a pattern string and flags. Fails with -- | an exception if the pattern contains a syntax error. unsafeRegex :: String -> RegexFlags -> Regex unsafeRegex s f = unsafePartial fromRight (regex s f) purescript-strings-3.5.0/src/Data/String/Unsafe.js000066400000000000000000000010401324034750100220650ustar00rootroot00000000000000"use strict"; exports.charCodeAt = function (i) { return function (s) { if (i >= 0 && i < s.length) return s.charCodeAt(i); throw new Error("Data.String.Unsafe.charCodeAt: Invalid index."); }; }; exports.charAt = function (i) { return function (s) { if (i >= 0 && i < s.length) return s.charAt(i); throw new Error("Data.String.Unsafe.charAt: Invalid index."); }; }; exports.char = function (s) { if (s.length === 1) return s.charAt(0); throw new Error("Data.String.Unsafe.char: Expected string of length 1."); }; purescript-strings-3.5.0/src/Data/String/Unsafe.purs000066400000000000000000000012161324034750100224470ustar00rootroot00000000000000-- | Unsafe string and character functions. module Data.String.Unsafe ( char , charAt , charCodeAt ) where -- | Returns the numeric Unicode value of the character at the given index. -- | -- | **Unsafe:** throws runtime exception if the index is out of bounds. foreign import charCodeAt :: Int -> String -> Int -- | Returns the character at the given index. -- | -- | **Unsafe:** throws runtime exception if the index is out of bounds. foreign import charAt :: Int -> String -> Char -- | Converts a string of length `1` to a character. -- | -- | **Unsafe:** throws runtime exception if length is not `1`. foreign import char :: String -> Char purescript-strings-3.5.0/test/000077500000000000000000000000001324034750100163645ustar00rootroot00000000000000purescript-strings-3.5.0/test/Test/000077500000000000000000000000001324034750100173035ustar00rootroot00000000000000purescript-strings-3.5.0/test/Test/Data/000077500000000000000000000000001324034750100201545ustar00rootroot00000000000000purescript-strings-3.5.0/test/Test/Data/Char.purs000066400000000000000000000011771324034750100217520ustar00rootroot00000000000000module Test.Data.Char (testChar) where import Prelude (Unit, (==), ($), discard) import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.Char import Test.Assert (ASSERT, assert) testChar :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testChar = do log "toCharCode" assert $ toCharCode 'a' == 97 assert $ toCharCode '\n' == 10 log "fromCharCode" assert $ fromCharCode 97 == 'a' assert $ fromCharCode 10 == '\n' log "toLower" assert $ toLower 'A' == 'a' assert $ toLower 'a' == 'a' log "toUpper" assert $ toUpper 'a' == 'A' assert $ toUpper 'A' == 'A' purescript-strings-3.5.0/test/Test/Data/String.purs000066400000000000000000000147311324034750100223430ustar00rootroot00000000000000module Test.Data.String (testString) where import Prelude (Unit, Ordering(..), (==), ($), discard, negate, not, (/=), (&&)) import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.Maybe (Maybe(..), isNothing, maybe) import Data.String import Test.Assert (ASSERT, assert) testString :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testString = do log "charAt" assert $ charAt 0 "" == Nothing assert $ charAt 0 "a" == Just 'a' assert $ charAt 1 "a" == Nothing assert $ charAt 0 "ab" == Just 'a' assert $ charAt 1 "ab" == Just 'b' assert $ charAt 2 "ab" == Nothing log "singleton" assert $ singleton 'a' == "a" log "charCodeAt" assert $ charCodeAt 0 "" == Nothing assert $ charCodeAt 0 "a" == Just 97 assert $ charCodeAt 1 "a" == Nothing assert $ charCodeAt 0 "ab" == Just 97 assert $ charCodeAt 1 "ab" == Just 98 assert $ charCodeAt 2 "ab" == Nothing log "toChar" assert $ toChar "" == Nothing assert $ toChar "a" == Just 'a' assert $ toChar "ab" == Nothing log "null" assert $ null "" assert $ not (null "a") log "uncons" assert $ isNothing (uncons "") assert $ case uncons "a" of Nothing -> false Just m -> m.head == 'a' && m.tail == "" assert $ case uncons "ab" of Nothing -> false Just m -> m.head == 'a' && m.tail == "b" log "takeWhile" assert $ takeWhile (\c -> true) "abc" == "abc" assert $ takeWhile (\c -> false) "abc" == "" assert $ takeWhile (\c -> c /= 'b') "aabbcc" == "aa" log "dropWhile" assert $ dropWhile (\c -> true) "abc" == "" assert $ dropWhile (\c -> false) "abc" == "abc" assert $ dropWhile (\c -> c /= 'b') "aabbcc" == "bbcc" log "stripPrefix" assert $ stripPrefix (Pattern "") "" == Just "" assert $ stripPrefix (Pattern "") "abc" == Just "abc" assert $ stripPrefix (Pattern "a") "abc" == Just "bc" assert $ stripPrefix (Pattern "!") "abc" == Nothing assert $ stripPrefix (Pattern "!") "" == Nothing log "fromCharArray" assert $ fromCharArray [] == "" assert $ fromCharArray ['a', 'b'] == "ab" log "contains" assert $ contains (Pattern "") "" assert $ contains (Pattern "") "abcd" assert $ contains (Pattern "bc") "abcd" assert $ not (contains (Pattern "cb") "abcd") log "indexOf" assert $ indexOf (Pattern "") "" == Just 0 assert $ indexOf (Pattern "") "abcd" == Just 0 assert $ indexOf (Pattern "bc") "abcd" == Just 1 assert $ indexOf (Pattern "cb") "abcd" == Nothing log "indexOf'" assert $ indexOf' (Pattern "") 0 "" == Just 0 assert $ indexOf' (Pattern "") (-1) "ab" == Nothing assert $ indexOf' (Pattern "") 0 "ab" == Just 0 assert $ indexOf' (Pattern "") 1 "ab" == Just 1 assert $ indexOf' (Pattern "") 2 "ab" == Just 2 assert $ indexOf' (Pattern "") 3 "ab" == Nothing assert $ indexOf' (Pattern "bc") 0 "abcd" == Just 1 assert $ indexOf' (Pattern "bc") 1 "abcd" == Just 1 assert $ indexOf' (Pattern "bc") 2 "abcd" == Nothing assert $ indexOf' (Pattern "cb") 0 "abcd" == Nothing log "lastIndexOf" assert $ lastIndexOf (Pattern "") "" == Just 0 assert $ lastIndexOf (Pattern "") "abcd" == Just 4 assert $ lastIndexOf (Pattern "bc") "abcd" == Just 1 assert $ lastIndexOf (Pattern "cb") "abcd" == Nothing log "lastIndexOf'" assert $ lastIndexOf' (Pattern "") 0 "" == Just 0 assert $ lastIndexOf' (Pattern "") (-1) "ab" == Nothing assert $ lastIndexOf' (Pattern "") 0 "ab" == Just 0 assert $ lastIndexOf' (Pattern "") 1 "ab" == Just 1 assert $ lastIndexOf' (Pattern "") 2 "ab" == Just 2 assert $ lastIndexOf' (Pattern "") 3 "ab" == Nothing assert $ lastIndexOf' (Pattern "bc") 0 "abcd" == Nothing assert $ lastIndexOf' (Pattern "bc") 1 "abcd" == Just 1 assert $ lastIndexOf' (Pattern "bc") 2 "abcd" == Just 1 assert $ lastIndexOf' (Pattern "cb") 0 "abcd" == Nothing log "length" assert $ length "" == 0 assert $ length "a" == 1 assert $ length "ab" == 2 log "localeCompare" assert $ localeCompare "" "" == EQ assert $ localeCompare "a" "a" == EQ assert $ localeCompare "a" "b" == LT assert $ localeCompare "b" "a" == GT log "replace" assert $ replace (Pattern "b") (Replacement "") "abc" == "ac" assert $ replace (Pattern "b") (Replacement "!") "abc" == "a!c" assert $ replace (Pattern "d") (Replacement "!") "abc" == "abc" log "replaceAll" assert $ replaceAll (Pattern "b") (Replacement "") "abbbbbc" == "ac" assert $ replaceAll (Pattern "[b]") (Replacement "!") "a[b]c" == "a!c" log "take" assert $ take 0 "ab" == "" assert $ take 1 "ab" == "a" assert $ take 2 "ab" == "ab" assert $ take 3 "ab" == "ab" assert $ take (-1) "ab" == "" log "takeRight" assert $ takeRight 0 "ab" == "" assert $ takeRight 1 "ab" == "b" assert $ takeRight 2 "ab" == "ab" assert $ takeRight 3 "ab" == "ab" assert $ takeRight (-1) "ab" == "" log "drop" assert $ drop 0 "ab" == "ab" assert $ drop 1 "ab" == "b" assert $ drop 2 "ab" == "" assert $ drop 3 "ab" == "" assert $ drop (-1) "ab" == "ab" log "dropRight" assert $ dropRight 0 "ab" == "ab" assert $ dropRight 1 "ab" == "a" assert $ dropRight 2 "ab" == "" assert $ dropRight 3 "ab" == "" assert $ dropRight (-1) "ab" == "ab" log "count" assert $ count (_ == 'a') "" == 0 assert $ count (_ == 'a') "ab" == 1 assert $ count (_ == 'a') "aaab" == 3 assert $ count (_ == 'a') "abaa" == 1 log "split" assert $ split (Pattern "") "" == [] assert $ split (Pattern "") "a" == ["a"] assert $ split (Pattern "") "ab" == ["a", "b"] assert $ split (Pattern "b") "aabcc" == ["aa", "cc"] assert $ split (Pattern "d") "abc" == ["abc"] log "splitAt" let testSplitAt i str res = assert $ case splitAt i str of Nothing -> isNothing res Just { before, after } -> maybe false (\r -> r.before == before && r.after == after) res testSplitAt 1 "" Nothing testSplitAt 0 "a" $ Just {before: "", after: "a"} testSplitAt 1 "ab" $ Just {before: "a", after: "b"} testSplitAt 3 "aabcc" $ Just {before: "aab", after: "cc"} testSplitAt (-1) "abc" $ Nothing log "toCharArray" assert $ toCharArray "" == [] assert $ toCharArray "a" == ['a'] assert $ toCharArray "ab" == ['a', 'b'] log "toLower" assert $ toLower "bAtMaN" == "batman" log "toUpper" assert $ toUpper "bAtMaN" == "BATMAN" log "trim" assert $ trim " abc " == "abc" log "joinWith" assert $ joinWith "" [] == "" assert $ joinWith "" ["a", "b"] == "ab" assert $ joinWith "--" ["a", "b", "c"] == "a--b--c" purescript-strings-3.5.0/test/Test/Data/String/000077500000000000000000000000001324034750100214225ustar00rootroot00000000000000purescript-strings-3.5.0/test/Test/Data/String/CaseInsensitive.purs000066400000000000000000000011501324034750100254260ustar00rootroot00000000000000module Test.Data.String.CaseInsensitive (testCaseInsensitiveString) where import Prelude (Unit, (==), ($), discard, compare, Ordering(..)) import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.String.CaseInsensitive import Test.Assert (ASSERT, assert) testCaseInsensitiveString :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testCaseInsensitiveString = do log "equality" assert $ CaseInsensitiveString "aB" == CaseInsensitiveString "AB" log "comparison" assert $ compare (CaseInsensitiveString "qwerty") (CaseInsensitiveString "QWERTY") == EQ purescript-strings-3.5.0/test/Test/Data/String/CodePoints.purs000066400000000000000000000221621324034750100244070ustar00rootroot00000000000000module Test.Data.String.CodePoints (testStringCodePoints) where import Prelude import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.Char (fromCharCode) import Data.Maybe (Maybe(..), isNothing, maybe) import Data.String.CodePoints import Test.Assert (ASSERT, assert) str :: String str = "a\xDC00\xD800\xD800\x16805\x16A06\&z" testStringCodePoints :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testStringCodePoints = do log "show" assert $ map show (codePointAt 0 str) == Just "(CodePoint 0x61)" assert $ map show (codePointAt 1 str) == Just "(CodePoint 0xDC00)" assert $ map show (codePointAt 2 str) == Just "(CodePoint 0xD800)" assert $ map show (codePointAt 3 str) == Just "(CodePoint 0xD800)" assert $ map show (codePointAt 4 str) == Just "(CodePoint 0x16805)" assert $ map show (codePointAt 5 str) == Just "(CodePoint 0x16A06)" assert $ map show (codePointAt 6 str) == Just "(CodePoint 0x7A)" log "codePointAt" assert $ codePointAt (-1) str == Nothing assert $ codePointAt 0 str == (codePointFromInt 0x61) assert $ codePointAt 1 str == (codePointFromInt 0xDC00) assert $ codePointAt 2 str == (codePointFromInt 0xD800) assert $ codePointAt 3 str == (codePointFromInt 0xD800) assert $ codePointAt 4 str == (codePointFromInt 0x16805) assert $ codePointAt 5 str == (codePointFromInt 0x16A06) assert $ codePointAt 6 str == (codePointFromInt 0x7A) assert $ codePointAt 7 str == Nothing log "codePointFromChar" assert $ Just (codePointFromChar 'A') == (codePointFromInt 65) assert $ Just (codePointFromChar $ fromCharCode 0) == codePointFromInt 0 assert $ Just (codePointFromChar $ fromCharCode 0xFFFF) == codePointFromInt 0xFFFF log "count" assert $ count (\_ -> true) "" == 0 assert $ count (\_ -> false) str == 0 assert $ count (\_ -> true) str == 7 assert $ count (\x -> codePointToInt x < 0xFFFF) str == 4 assert $ count (\x -> codePointToInt x < 0xDC00) str == 1 log "drop" assert $ drop (-1) str == str assert $ drop 0 str == str assert $ drop 1 str == "\xDC00\xD800\xD800\x16805\x16A06\&z" assert $ drop 2 str == "\xD800\xD800\x16805\x16A06\&z" assert $ drop 3 str == "\xD800\x16805\x16A06\&z" assert $ drop 4 str == "\x16805\x16A06\&z" assert $ drop 5 str == "\x16A06\&z" assert $ drop 6 str == "z" assert $ drop 7 str == "" assert $ drop 8 str == "" log "dropWhile" assert $ dropWhile (\_ -> true) str == "" assert $ dropWhile (\_ -> false) str == str assert $ dropWhile (\c -> codePointToInt c < 0xFFFF) str == "\x16805\x16A06\&z" assert $ dropWhile (\c -> codePointToInt c < 0xDC00) str == "\xDC00\xD800\xD800\x16805\x16A06\&z" log "indexOf" assert $ indexOf (Pattern "") "" == Just 0 assert $ indexOf (Pattern "") str == Just 0 assert $ indexOf (Pattern str) str == Just 0 assert $ indexOf (Pattern "a") str == Just 0 assert $ indexOf (Pattern "\xDC00\xD800\xD800") str == Just 1 assert $ indexOf (Pattern "\xD800") str == Just 2 assert $ indexOf (Pattern "\xD800\xD800") str == Just 2 assert $ indexOf (Pattern "\xD800\xD81A") str == Just 3 assert $ indexOf (Pattern "\xD800\x16805") str == Just 3 assert $ indexOf (Pattern "\x16805") str == Just 4 assert $ indexOf (Pattern "\x16A06") str == Just 5 assert $ indexOf (Pattern "z") str == Just 6 assert $ indexOf (Pattern "\0") str == Nothing assert $ indexOf (Pattern "\xD81A") str == Just 4 log "indexOf'" assert $ indexOf' (Pattern "") 0 "" == Just 0 assert $ indexOf' (Pattern str) 0 str == Just 0 assert $ indexOf' (Pattern str) 1 str == Nothing assert $ indexOf' (Pattern "a") 0 str == Just 0 assert $ indexOf' (Pattern "a") 1 str == Nothing assert $ indexOf' (Pattern "z") 0 str == Just 6 assert $ indexOf' (Pattern "z") 1 str == Just 6 assert $ indexOf' (Pattern "z") 2 str == Just 6 assert $ indexOf' (Pattern "z") 3 str == Just 6 assert $ indexOf' (Pattern "z") 4 str == Just 6 assert $ indexOf' (Pattern "z") 5 str == Just 6 assert $ indexOf' (Pattern "z") 6 str == Just 6 assert $ indexOf' (Pattern "z") 7 str == Nothing log "lastIndexOf" assert $ lastIndexOf (Pattern "") "" == Just 0 assert $ lastIndexOf (Pattern "") str == Just 7 assert $ lastIndexOf (Pattern str) str == Just 0 assert $ lastIndexOf (Pattern "a") str == Just 0 assert $ lastIndexOf (Pattern "\xDC00\xD800\xD800") str == Just 1 assert $ lastIndexOf (Pattern "\xD800") str == Just 3 assert $ lastIndexOf (Pattern "\xD800\xD800") str == Just 2 assert $ lastIndexOf (Pattern "\xD800\xD81A") str == Just 3 assert $ lastIndexOf (Pattern "\xD800\x16805") str == Just 3 assert $ lastIndexOf (Pattern "\x16805") str == Just 4 assert $ lastIndexOf (Pattern "\x16A06") str == Just 5 assert $ lastIndexOf (Pattern "z") str == Just 6 assert $ lastIndexOf (Pattern "\0") str == Nothing assert $ lastIndexOf (Pattern "\xD81A") str == Just 5 log "lastIndexOf'" assert $ lastIndexOf' (Pattern "") 0 "" == Just 0 assert $ lastIndexOf' (Pattern str) 0 str == Just 0 assert $ lastIndexOf' (Pattern str) 1 str == Just 0 assert $ lastIndexOf' (Pattern "a") 0 str == Just 0 assert $ lastIndexOf' (Pattern "a") 7 str == Just 0 assert $ lastIndexOf' (Pattern "z") 0 str == Nothing assert $ lastIndexOf' (Pattern "z") 1 str == Nothing assert $ lastIndexOf' (Pattern "z") 2 str == Nothing assert $ lastIndexOf' (Pattern "z") 3 str == Nothing assert $ lastIndexOf' (Pattern "z") 4 str == Nothing assert $ lastIndexOf' (Pattern "z") 5 str == Nothing assert $ lastIndexOf' (Pattern "z") 6 str == Just 6 assert $ lastIndexOf' (Pattern "z") 7 str == Just 6 assert $ lastIndexOf' (Pattern "\xD800") 7 str == Just 3 assert $ lastIndexOf' (Pattern "\xD800") 6 str == Just 3 assert $ lastIndexOf' (Pattern "\xD800") 5 str == Just 3 assert $ lastIndexOf' (Pattern "\xD800") 4 str == Just 3 assert $ lastIndexOf' (Pattern "\xD800") 3 str == Just 3 assert $ lastIndexOf' (Pattern "\xD800") 2 str == Just 2 assert $ lastIndexOf' (Pattern "\xD800") 1 str == Nothing assert $ lastIndexOf' (Pattern "\xD800") 0 str == Nothing assert $ lastIndexOf' (Pattern "\x16A06") 7 str == Just 5 assert $ lastIndexOf' (Pattern "\x16A06") 6 str == Just 5 assert $ lastIndexOf' (Pattern "\x16A06") 5 str == Just 5 assert $ lastIndexOf' (Pattern "\x16A06") 4 str == Nothing assert $ lastIndexOf' (Pattern "\x16A06") 3 str == Nothing log "length" assert $ length "" == 0 assert $ length "a" == 1 assert $ length "ab" == 2 assert $ length str == 7 log "singleton" assert $ (singleton <$> codePointFromInt 0x30) == Just "0" assert $ (singleton <$> codePointFromInt 0x16805) == Just "\x16805" log "splitAt" let testSplitAt i s res = assert $ case splitAt i s of Nothing -> isNothing res Just { before, after } -> maybe false (\r -> r.before == before && r.after == after) res testSplitAt 0 "" $ Just {before: "", after: ""} testSplitAt 1 "" Nothing testSplitAt 0 "a" $ Just {before: "", after: "a"} testSplitAt 1 "ab" $ Just {before: "a", after: "b"} testSplitAt 3 "aabcc" $ Just {before: "aab", after: "cc"} testSplitAt (-1) "abc" $ Nothing testSplitAt 0 str $ Just {before: "", after: str} testSplitAt 1 str $ Just {before: "a", after: "\xDC00\xD800\xD800\x16805\x16A06\&z"} testSplitAt 2 str $ Just {before: "a\xDC00", after: "\xD800\xD800\x16805\x16A06\&z"} testSplitAt 3 str $ Just {before: "a\xDC00\xD800", after: "\xD800\x16805\x16A06\&z"} testSplitAt 4 str $ Just {before: "a\xDC00\xD800\xD800", after: "\x16805\x16A06\&z"} testSplitAt 5 str $ Just {before: "a\xDC00\xD800\xD800\x16805", after: "\x16A06\&z"} testSplitAt 6 str $ Just {before: "a\xDC00\xD800\xD800\x16805\x16A06", after: "z"} testSplitAt 7 str $ Just {before: str, after: ""} testSplitAt 8 str $ Nothing log "take" assert $ take (-1) str == "" assert $ take 0 str == "" assert $ take 1 str == "a" assert $ take 2 str == "a\xDC00" assert $ take 3 str == "a\xDC00\xD800" assert $ take 4 str == "a\xDC00\xD800\xD800" assert $ take 5 str == "a\xDC00\xD800\xD800\x16805" assert $ take 6 str == "a\xDC00\xD800\xD800\x16805\x16A06" assert $ take 7 str == str assert $ take 8 str == str log "takeWhile" assert $ takeWhile (\_ -> true) str == str assert $ takeWhile (\_ -> false) str == "" assert $ takeWhile (\c -> codePointToInt c < 0xFFFF) str == "a\xDC00\xD800\xD800" assert $ takeWhile (\c -> codePointToInt c < 0xDC00) str == "a" log "uncons" let testUncons s res = assert $ case uncons s of Nothing -> isNothing res Just { head, tail } -> maybe false (\r -> r.head == codePointToInt head && r.tail == tail) res testUncons str $ Just {head: 0x61, tail: "\xDC00\xD800\xD800\x16805\x16A06\&z"} testUncons (drop 1 str) $ Just {head: 0xDC00, tail: "\xD800\xD800\x16805\x16A06\&z"} testUncons (drop 2 str) $ Just {head: 0xD800, tail: "\xD800\x16805\x16A06\&z"} testUncons (drop 3 str) $ Just {head: 0xD800, tail: "\x16805\x16A06\&z"} testUncons (drop 4 str) $ Just {head: 0x16805, tail: "\x16A06\&z"} testUncons (drop 5 str) $ Just {head: 0x16A06, tail: "z"} testUncons (drop 6 str) $ Just {head: 0x7A, tail: ""} testUncons "" Nothing purescript-strings-3.5.0/test/Test/Data/String/NonEmpty.purs000066400000000000000000000233231324034750100241110ustar00rootroot00000000000000module Test.Data.String.NonEmpty (testNonEmptyString) where import Data.String.NonEmpty import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.Array.Partial as AP import Data.Foldable (class Foldable, foldl) import Data.Maybe (Maybe(..), fromJust, isNothing, maybe) import Data.Semigroup.Foldable (class Foldable1, foldMap1Default) import Partial.Unsafe (unsafePartial) import Prelude (class Functor, Ordering(..), Unit, append, discard, negate, not, ($), (&&), (/=), (==)) import Test.Assert (ASSERT, assert) testNonEmptyString :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testNonEmptyString = do log "fromString" assert $ fromString "" == Nothing assert $ fromString "hello" == Just (nes "hello") log "fromCharArray" assert $ fromCharArray [] == Nothing assert $ fromCharArray ['a', 'b'] == Just (nes "ab") log "singleton" assert $ singleton 'a' == nes "a" log "cons" assert $ cons 'a' "bc" == nes "abc" assert $ cons 'a' "" == nes "a" log "snoc" assert $ snoc 'c' "ab" == nes "abc" assert $ snoc 'a' "" == nes "a" log "fromFoldable1" assert $ fromFoldable1 (NEA ['a']) == nes "a" assert $ fromFoldable1 (NEA ['a', 'b', 'c']) == nes "abc" log "charAt" assert $ charAt 0 (nes "a") == Just 'a' assert $ charAt 1 (nes "a") == Nothing assert $ charAt 0 (nes "ab") == Just 'a' assert $ charAt 1 (nes "ab") == Just 'b' assert $ charAt 2 (nes "ab") == Nothing assert $ charAt 2 (nes "Hello") == Just 'l' assert $ charAt 10 (nes "Hello") == Nothing log "charCodeAt" assert $ charCodeAt 0 (nes "a") == Just 97 assert $ charCodeAt 1 (nes "a") == Nothing assert $ charCodeAt 0 (nes "ab") == Just 97 assert $ charCodeAt 1 (nes "ab") == Just 98 assert $ charCodeAt 2 (nes "ab") == Nothing assert $ charCodeAt 2 (nes "5 €") == Just 0x20AC assert $ charCodeAt 10 (nes "5 €") == Nothing log "toChar" assert $ toChar (nes "a") == Just 'a' assert $ toChar (nes "ab") == Nothing log "toCharArray" assert $ toCharArray (nes "a") == ['a'] assert $ toCharArray (nes "ab") == ['a', 'b'] assert $ toCharArray (nes "Hello☺\n") == ['H','e','l','l','o','☺','\n'] log "appendString" assert $ appendString (nes "Hello") " world" == nes "Hello world" assert $ appendString (nes "Hello") "" == nes "Hello" log "prependString" assert $ prependString "be" (nes "fore") == nes "before" assert $ prependString "" (nes "fore") == nes "fore" log "uncons" assert let m = uncons (nes "a") in m.head == 'a' && m.tail == Nothing assert $ let m = uncons (nes "Hello World") in m.head == 'H' && m.tail == Just (nes "ello World") log "takeWhile" assert $ takeWhile (\c -> true) (nes "abc") == Just (nes "abc") assert $ takeWhile (\c -> false) (nes "abc") == Nothing assert $ takeWhile (\c -> c /= 'b') (nes "aabbcc") == Just (nes "aa") assert $ takeWhile (_ /= ':') (nes "http://purescript.org") == Just (nes "http") assert $ takeWhile (_ == 'a') (nes "xyz") == Nothing log "dropWhile" assert $ dropWhile (\c -> true) (nes "abc") == Nothing assert $ dropWhile (\c -> false) (nes "abc") == Just (nes "abc") assert $ dropWhile (\c -> c /= 'b') (nes "aabbcc") == Just (nes "bbcc") assert $ dropWhile (_ /= '.') (nes "Test.purs") == Just (nes ".purs") log "stripPrefix" assert $ stripPrefix (Pattern "") (nes "abc") == Just (nes "abc") assert $ stripPrefix (Pattern "a") (nes "abc") == Just (nes "bc") assert $ stripPrefix (Pattern "abc") (nes "abc") == Nothing assert $ stripPrefix (Pattern "!") (nes "abc") == Nothing assert $ stripPrefix (Pattern "http:") (nes "http://purescript.org") == Just (nes "//purescript.org") assert $ stripPrefix (Pattern "http:") (nes "https://purescript.org") == Nothing assert $ stripPrefix (Pattern "Hello!") (nes "Hello!") == Nothing log "stripSuffix" assert $ stripSuffix (Pattern ".exe") (nes "purs.exe") == Just (nes "purs") assert $ stripSuffix (Pattern ".exe") (nes "purs") == Nothing assert $ stripSuffix (Pattern "Hello!") (nes "Hello!") == Nothing log "contains" assert $ contains (Pattern "") (nes "abcd") assert $ contains (Pattern "bc") (nes "abcd") assert $ not (contains (Pattern "cb") (nes "abcd")) assert $ contains (Pattern "needle") (nes "haystack with needle") == true assert $ contains (Pattern "needle") (nes "haystack") == false log "indexOf" assert $ indexOf (Pattern "") (nes "abcd") == Just 0 assert $ indexOf (Pattern "bc") (nes "abcd") == Just 1 assert $ indexOf (Pattern "cb") (nes "abcd") == Nothing log "indexOf'" assert $ indexOf' (Pattern "") (-1) (nes "ab") == Nothing assert $ indexOf' (Pattern "") 0 (nes "ab") == Just 0 assert $ indexOf' (Pattern "") 1 (nes "ab") == Just 1 assert $ indexOf' (Pattern "") 2 (nes "ab") == Just 2 assert $ indexOf' (Pattern "") 3 (nes "ab") == Nothing assert $ indexOf' (Pattern "bc") 0 (nes "abcd") == Just 1 assert $ indexOf' (Pattern "bc") 1 (nes "abcd") == Just 1 assert $ indexOf' (Pattern "bc") 2 (nes "abcd") == Nothing assert $ indexOf' (Pattern "cb") 0 (nes "abcd") == Nothing log "lastIndexOf" assert $ lastIndexOf (Pattern "") (nes "abcd") == Just 4 assert $ lastIndexOf (Pattern "bc") (nes "abcd") == Just 1 assert $ lastIndexOf (Pattern "cb") (nes "abcd") == Nothing log "lastIndexOf'" assert $ lastIndexOf' (Pattern "") (-1) (nes "ab") == Nothing assert $ lastIndexOf' (Pattern "") 0 (nes "ab") == Just 0 assert $ lastIndexOf' (Pattern "") 1 (nes "ab") == Just 1 assert $ lastIndexOf' (Pattern "") 2 (nes "ab") == Just 2 assert $ lastIndexOf' (Pattern "") 3 (nes "ab") == Nothing assert $ lastIndexOf' (Pattern "bc") 0 (nes "abcd") == Nothing assert $ lastIndexOf' (Pattern "bc") 1 (nes "abcd") == Just 1 assert $ lastIndexOf' (Pattern "bc") 2 (nes "abcd") == Just 1 assert $ lastIndexOf' (Pattern "cb") 0 (nes "abcd") == Nothing log "length" assert $ length (nes "a") == 1 assert $ length (nes "ab") == 2 log "localeCompare" assert $ localeCompare (nes "a") (nes "a") == EQ assert $ localeCompare (nes "a") (nes "b") == LT assert $ localeCompare (nes "b") (nes "a") == GT log "replace" assert $ replace (Pattern "b") (NonEmptyReplacement (nes "!")) (nes "abc") == nes "a!c" assert $ replace (Pattern "b") (NonEmptyReplacement (nes "!")) (nes "abbc") == nes "a!bc" assert $ replace (Pattern "d") (NonEmptyReplacement (nes "!")) (nes "abc") == nes "abc" log "replaceAll" assert $ replaceAll (Pattern "[b]") (NonEmptyReplacement (nes "!")) (nes "a[b]c") == nes "a!c" assert $ replaceAll (Pattern "[b]") (NonEmptyReplacement (nes "!")) (nes "a[b]c[b]") == nes "a!c!" assert $ replaceAll (Pattern "x") (NonEmptyReplacement (nes "!")) (nes "abc") == nes "abc" log "take" assert $ take 0 (nes "ab") == Nothing assert $ take 1 (nes "ab") == Just (nes "a") assert $ take 2 (nes "ab") == Just (nes "ab") assert $ take 3 (nes "ab") == Just (nes "ab") assert $ take (-1) (nes "ab") == Nothing log "takeRight" assert $ takeRight 0 (nes "ab") == Nothing assert $ takeRight 1 (nes "ab") == Just (nes "b") assert $ takeRight 2 (nes "ab") == Just (nes "ab") assert $ takeRight 3 (nes "ab") == Just (nes "ab") assert $ takeRight (-1) (nes "ab") == Nothing log "drop" assert $ drop 0 (nes "ab") == Just (nes "ab") assert $ drop 1 (nes "ab") == Just (nes "b") assert $ drop 2 (nes "ab") == Nothing assert $ drop 3 (nes "ab") == Nothing assert $ drop (-1) (nes "ab") == Just (nes "ab") log "dropRight" assert $ dropRight 0 (nes "ab") == Just (nes "ab") assert $ dropRight 1 (nes "ab") == Just (nes "a") assert $ dropRight 2 (nes "ab") == Nothing assert $ dropRight 3 (nes "ab") == Nothing assert $ dropRight (-1) (nes "ab") == Just (nes "ab") log "count" assert $ count (_ == 'a') (nes "ab") == 1 assert $ count (_ == 'a') (nes "aaab") == 3 assert $ count (_ == 'a') (nes "abaa") == 1 assert $ count (_ == 'c') (nes "abaa") == 0 log "splitAt" let testSplitAt i str res = assert $ case splitAt i str of Nothing -> isNothing res Just { before, after } -> maybe false (\r -> r.before == before && r.after == after) res testSplitAt 0 (nes "a") (Just { before: Nothing, after: Just (nes "a") }) testSplitAt 1 (nes "ab") (Just { before: Just (nes "a"), after: Just (nes "b") }) testSplitAt 3 (nes "aabcc") (Just { before: Just (nes "aab"), after: Just (nes "cc") }) testSplitAt (-1) (nes "abc") Nothing log "toLower" assert $ toLower (nes "bAtMaN") == nes "batman" log "toUpper" assert $ toUpper (nes "bAtMaN") == nes "BATMAN" log "trim" assert $ trim (nes " abc ") == Just (nes "abc") assert $ trim (nes " \n") == Nothing log "joinWith" assert $ joinWith "" [] == "" assert $ joinWith "" [nes "a", nes "b"] == "ab" assert $ joinWith "--" [nes "a", nes "b", nes "c"] == "a--b--c" log "join1With" assert $ join1With "" (NEA [nes "a", nes "b"]) == nes "ab" assert $ join1With "--" (NEA [nes "a", nes "b", nes "c"]) == nes "a--b--c" assert $ join1With ", " (NEA [nes "apple", nes "banana"]) == nes "apple, banana" assert $ join1With "" (NEA [nes "apple", nes "banana"]) == nes "applebanana" log "joinWith1" assert $ joinWith1 (nes " ") (NEA ["a", "b"]) == nes "a b" assert $ joinWith1 (nes "--") (NEA ["a", "b", "c"]) == nes "a--b--c" assert $ joinWith1 (nes ", ") (NEA ["apple", "banana"]) == nes "apple, banana" assert $ joinWith1 (nes "/") (NEA ["a", "b", "", "c", ""]) == nes "a/b//c/" nes :: String -> NonEmptyString nes = unsafePartial unsafeFromString newtype NEA a = NEA (Array a) derive newtype instance functorNEA :: Functor NEA derive newtype instance foldableNEA :: Foldable NEA instance foldable1NEA :: Foldable1 NEA where foldMap1 a = foldMap1Default a fold1 (NEA as) = foldl append (unsafePartial AP.head as) (unsafePartial AP.tail as) purescript-strings-3.5.0/test/Test/Data/String/Regex.purs000066400000000000000000000035321324034750100234120ustar00rootroot00000000000000module Test.Data.String.Regex (testStringRegex) where import Prelude (Unit, ($), (<>), discard, (==), not) import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.Either (isLeft) import Data.Maybe (Maybe(..)) import Data.String.Regex import Data.String.Regex.Flags (global, ignoreCase, noFlags) import Data.String.Regex.Unsafe (unsafeRegex) import Test.Assert (ASSERT, assert) testStringRegex :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testStringRegex = do log "regex" assert $ test (unsafeRegex "^a" noFlags) "abc" assert $ not (test (unsafeRegex "^b" noFlags) "abc") assert $ isLeft (regex "+" noFlags) log "flags" assert $ "quxbarfoobaz" == replace (unsafeRegex "foo" noFlags) "qux" "foobarfoobaz" assert $ "quxbarquxbaz" == replace (unsafeRegex "foo" global) "qux" "foobarfoobaz" assert $ "quxbarquxbaz" == replace (unsafeRegex "foo" (global <> ignoreCase)) "qux" "foobarFOObaz" log "match" assert $ match (unsafeRegex "^abc$" noFlags) "abc" == Just [Just "abc"] log "replace" assert $ replace (unsafeRegex "-" noFlags) "!" "a-b-c" == "a!b-c" log "replace'" assert $ replace' (unsafeRegex "-" noFlags) (\s xs -> "!") "a-b-c" == "a!b-c" log "search" assert $ search (unsafeRegex "b" noFlags) "abc" == Just 1 assert $ search (unsafeRegex "d" noFlags) "abc" == Nothing log "split" assert $ split (unsafeRegex "" noFlags) "" == [] assert $ split (unsafeRegex "" noFlags) "abc" == ["a", "b", "c"] assert $ split (unsafeRegex "b" noFlags) "" == [""] assert $ split (unsafeRegex "b" noFlags) "abc" == ["a", "c"] log "test" -- Ensure that we have referential transparency for calls to 'test'. No -- global state should be maintained between these two calls: let pattern = unsafeRegex "a" (parseFlags "g") assert $ test pattern "a" assert $ test pattern "a" purescript-strings-3.5.0/test/Test/Data/String/Unsafe.purs000066400000000000000000000010621324034750100235550ustar00rootroot00000000000000module Test.Data.String.Unsafe (testStringUnsafe) where import Prelude (Unit, (==), ($), discard) import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Data.String.Unsafe import Test.Assert (ASSERT, assert) testStringUnsafe :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit testStringUnsafe = do log "charCodeAt" assert $ charCodeAt 0 "ab" == 97 assert $ charCodeAt 1 "ab" == 98 log "charAt" assert $ charAt 0 "ab" == 'a' assert $ charAt 1 "ab" == 'b' log "char" assert $ char "a" == 'a' purescript-strings-3.5.0/test/Test/Main.purs000066400000000000000000000017061324034750100211060ustar00rootroot00000000000000module Test.Main where import Prelude import Control.Monad.Eff (Eff) import Control.Monad.Eff.Console (CONSOLE, log) import Test.Assert (ASSERT) import Test.Data.Char (testChar) import Test.Data.String (testString) import Test.Data.String.CaseInsensitive (testCaseInsensitiveString) import Test.Data.String.CodePoints (testStringCodePoints) import Test.Data.String.NonEmpty (testNonEmptyString) import Test.Data.String.Regex (testStringRegex) import Test.Data.String.Unsafe (testStringUnsafe) main :: Eff (console :: CONSOLE, assert :: ASSERT) Unit main = do log "\n--- Data.Char ---\n" testChar log "\n--- Data.String ---\n" testString log "\n--- Data.String.CodePoints ---\n" testStringCodePoints log "\n--- Data.String.Unsafe ---\n" testStringUnsafe log "\n--- Data.String.Regex ---\n" testStringRegex log "\n--- Data.String.CaseInsensitive ---\n" testCaseInsensitiveString log "\n--- Data.String.NonEmpty ---\n" testNonEmptyString