Merge branch 'master' into add-starts-with-and-ends-with

Author: f-f

.eslintrc.json

@@ -1,11 +1,9 @@
 {
   "parserOptions": {
-    "ecmaVersion": 5
+    "ecmaVersion": 6,
+    "sourceType": "module"
   },
   "extends": "eslint:recommended",
-  "env": {
-    "commonjs": true
-  },
   "rules": {
     "strict": [2, "global"],
     "block-scoped-var": 2,

.github/workflows/ci.yml

@@ -13,10 +13,12 @@ jobs:
       - uses: actions/checkout@v2
 
       - uses: purescript-contrib/setup-purescript@main
+        with:
+          purescript: "unstable"
 
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v2
         with:
-          node-version: "12"
+          node-version: "14.x"
 
       - name: Install dependencies
         run: |

CHANGELOG.md

@@ -11,8 +11,28 @@ New features:
 
 Bugfixes:
 
+Other improvements:
+- Redefine `Data.String.NonEmpty.CodeUnits.fromFoldable1` in terms of `singleton` (#168 by @postsolar)
+
+## [v6.0.1](https://github.com/purescript/purescript-strings/releases/tag/v6.0.1) - 2022-08-16
+
+Bugfixes:
+- Fix `Char`'s `toEnum` implementation (#163 by @JordanMartinez)
+
+## [v6.0.0](https://github.com/purescript/purescript-strings/releases/tag/v6.0.0) - 2022-04-27
+
+Breaking changes:
+- Migrate FFI to ES modules (#158 by @kl0tl and @JordanMartinez)
+- Replaced polymorphic proxies with monomorphic `Proxy` (#158 by @JordanMartinez)
+- In `slice`, drop bounds checking and `Maybe` return type (#145 by Quelklef)
+
+New features:
+
+Bugfixes:
+
 Other improvements:
 - Surround code with backticks in documentation (#148)
+- Make `RegexFlags` a `newtype` and a `Newtype` instance for it(#159 by @mhmdanas)
 
 ## [v5.0.0](https://github.com/purescript/purescript-strings/releases/tag/v5.0.0) - 2021-02-26
 

bower.json

@@ -16,26 +16,26 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-arrays": "^6.0.0",
-    "purescript-control": "^5.0.0",
-    "purescript-either": "^5.0.0",
-    "purescript-enums": "^5.0.0",
-    "purescript-foldable-traversable": "^5.0.0",
-    "purescript-gen": "^3.0.0",
-    "purescript-integers": "^5.0.0",
-    "purescript-maybe": "^5.0.0",
-    "purescript-newtype": "^4.0.0",
-    "purescript-nonempty": "^6.0.0",
-    "purescript-partial": "^3.0.0",
-    "purescript-prelude": "^5.0.0",
-    "purescript-tailrec": "^5.0.0",
-    "purescript-tuples": "^6.0.0",
-    "purescript-unfoldable": "^5.0.0",
-    "purescript-unsafe-coerce": "^5.0.0"
+    "purescript-arrays": "^7.0.0",
+    "purescript-control": "^6.0.0",
+    "purescript-either": "^6.0.0",
+    "purescript-enums": "^6.0.1",
+    "purescript-foldable-traversable": "^6.0.0",
+    "purescript-gen": "^4.0.0",
+    "purescript-integers": "^6.0.0",
+    "purescript-maybe": "^6.0.0",
+    "purescript-newtype": "^5.0.0",
+    "purescript-nonempty": "^7.0.0",
+    "purescript-partial": "^4.0.0",
+    "purescript-prelude": "^6.0.0",
+    "purescript-tailrec": "^6.0.0",
+    "purescript-tuples": "^7.0.0",
+    "purescript-unfoldable": "^6.0.0",
+    "purescript-unsafe-coerce": "^6.0.0"
   },
   "devDependencies": {
-    "purescript-assert": "^5.0.0",
-    "purescript-console": "^5.0.0",
-    "purescript-minibench": "^3.0.0"
+    "purescript-assert": "^6.0.0",
+    "purescript-console": "^6.0.0",
+    "purescript-minibench": "^4.0.0"
   }
 }

package.json

@@ -4,15 +4,15 @@
     "clean": "rimraf output && rimraf .pulp-cache",
     "build": "eslint src && pulp build -- --censor-lib --strict",
     "test": "pulp test && npm run test:run:without_codePointAt",
-    "test:run:without_codePointAt": "node -e \"delete String.prototype.codePointAt; require('./output/Test.Main/index.js').main();\"",
+    "test:run:without_codePointAt": "node -e \"delete String.prototype.codePointAt; import('./output/Test.Main/index.js').then(m => m.main());\"",
     "bench:build": "purs compile 'bench/**/*.purs' 'src/**/*.purs' 'bower_components/*/src/**/*.purs'",
     "bench:run": "node --expose-gc -e 'require(\"./output/Bench.Main/index.js\").main()'",
     "bench": "npm run bench:build && npm run bench:run"
   },
   "devDependencies": {
     "eslint": "^7.15.0",
-    "pulp": "^15.0.0",
-    "purescript-psa": "^0.8.0",
+    "pulp": "16.0.0-0",
+    "purescript-psa": "^0.8.2",
     "rimraf": "^3.0.2"
   }
 }

src/Data/String/CodePoints.js

@@ -1,4 +1,3 @@
-"use strict";
 /* global Symbol */
 
 var hasArrayFrom = typeof Array.from === "function";
@@ -10,13 +9,13 @@ var hasStringIterator =
 var hasFromCodePoint = typeof String.prototype.fromCodePoint === "function";
 var hasCodePointAt = typeof String.prototype.codePointAt === "function";
 
-exports._unsafeCodePointAt0 = function (fallback) {
+export const _unsafeCodePointAt0 = function (fallback) {
   return hasCodePointAt
     ? function (str) { return str.codePointAt(0); }
     : fallback;
 };
 
-exports._codePointAt = function (fallback) {
+export const _codePointAt = function (fallback) {
   return function (Just) {
     return function (Nothing) {
       return function (unsafeCodePointAt0) {
@@ -40,7 +39,7 @@ exports._codePointAt = function (fallback) {
   };
 };
 
-exports._countPrefix = function (fallback) {
+export const _countPrefix = function (fallback) {
   return function (unsafeCodePointAt0) {
     if (hasStringIterator) {
       return function (pred) {
@@ -59,7 +58,7 @@ exports._countPrefix = function (fallback) {
   };
 };
 
-exports._fromCodePointArray = function (singleton) {
+export const _fromCodePointArray = function (singleton) {
   return hasFromCodePoint
     ? function (cps) {
       // Function.prototype.apply will fail for very large second parameters,
@@ -74,11 +73,11 @@ exports._fromCodePointArray = function (singleton) {
     };
 };
 
-exports._singleton = function (fallback) {
+export const _singleton = function (fallback) {
   return hasFromCodePoint ? String.fromCodePoint : fallback;
 };
 
-exports._take = function (fallback) {
+export const _take = function (fallback) {
   return function (n) {
     if (hasStringIterator) {
       return function (str) {
@@ -96,7 +95,7 @@ exports._take = function (fallback) {
   };
 };
 
-exports._toCodePointArray = function (fallback) {
+export const _toCodePointArray = function (fallback) {
   return function (unsafeCodePointAt0) {
     if (hasArrayFrom) {
       return function (str) {

src/Data/String/CodePoints.purs

@@ -207,7 +207,7 @@ uncons s = case CU.length s of
 -- | ```purescript
 -- | >>> length "b 𝐀𝐀 c 𝐀"
 -- | 8
--- | -- compare to Data.String:
+-- | -- compare to Data.String.CodeUnits:
 -- | >>> length "b 𝐀𝐀 c 𝐀"
 -- | 11
 -- | ```
@@ -314,7 +314,7 @@ lastIndexOf' p i s =
 
 -- | 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
+-- | points, returns the entire string. Operates in constant space and in time
 -- | linear to the given number.
 -- |
 -- | ```purescript

src/Data/String/CodeUnits.js

@@ -1,18 +1,16 @@
-"use strict";
-
-exports.fromCharArray = function (a) {
+export const fromCharArray = function (a) {
   return a.join("");
 };
 
-exports.toCharArray = function (s) {
+export const toCharArray = function (s) {
   return s.split("");
 };
 
-exports.singleton = function (c) {
+export const singleton = function (c) {
   return c;
 };
 
-exports._charAt = function (just) {
+export const _charAt = function (just) {
   return function (nothing) {
     return function (i) {
       return function (s) {
@@ -22,27 +20,27 @@ exports._charAt = function (just) {
   };
 };
 
-exports._toChar = function (just) {
+export const _toChar = function (just) {
   return function (nothing) {
     return function (s) {
       return s.length === 1 ? just(s) : nothing;
     };
   };
 };
 
-exports.length = function (s) {
+export const length = function (s) {
   return s.length;
 };
 
-exports.countPrefix = function (p) {
+export const countPrefix = function (p) {
   return function (s) {
     var i = 0;
     while (i < s.length && p(s.charAt(i))) i++;
     return i;
   };
 };
 
-exports._indexOf = function (just) {
+export const _indexOf = function (just) {
   return function (nothing) {
     return function (x) {
       return function (s) {
@@ -53,7 +51,7 @@ exports._indexOf = function (just) {
   };
 };
 
-exports._indexOfStartingAt = function (just) {
+export const _indexOfStartingAt = function (just) {
   return function (nothing) {
     return function (x) {
       return function (startAt) {
@@ -67,7 +65,7 @@ exports._indexOfStartingAt = function (just) {
   };
 };
 
-exports._lastIndexOf = function (just) {
+export const _lastIndexOf = function (just) {
   return function (nothing) {
     return function (x) {
       return function (s) {
@@ -78,7 +76,7 @@ exports._lastIndexOf = function (just) {
   };
 };
 
-exports._lastIndexOfStartingAt = function (just) {
+export const _lastIndexOfStartingAt = function (just) {
   return function (nothing) {
     return function (x) {
       return function (startAt) {
@@ -91,27 +89,27 @@ exports._lastIndexOfStartingAt = function (just) {
   };
 };
 
-exports.take = function (n) {
+export const take = function (n) {
   return function (s) {
     return s.substr(0, n);
   };
 };
 
-exports.drop = function (n) {
+export const drop = function (n) {
   return function (s) {
     return s.substring(n);
   };
 };
 
-exports._slice = function (b) {
+export const slice = function (b) {
   return function (e) {
     return function (s) {
       return s.slice(b,e);
     };
   };
 };
 
-exports.splitAt = function (i) {
+export const splitAt = function (i) {
   return function (s) {
     return { before: s.substring(0, i), after: s.substring(i) };
   };

src/Data/String/CodeUnits.purs

@@ -172,6 +172,10 @@ uncons s  = Just { head: U.charAt zero s, tail: drop one s }
 -- |
 -- | ```purescript
 -- | length "Hello World" == 11
+-- |
+-- | length "𝐀A" == 3
+-- | -- compare to Data.String.CodePoints:
+-- | length "𝐀A" == 2
 -- | ```
 -- |
 foreign import length :: String -> Int
@@ -325,30 +329,17 @@ dropWhile p s = drop (countPrefix p s) s
 
 -- | Returns the substring at indices `[begin, end)`.
 -- | If either index is negative, it is normalised to `length s - index`,
--- | where `s` is the input string. `Nothing` is returned if either
+-- | where `s` is the input string. `""` is returned if either
 -- | index is out of bounds or if `begin > end` after normalisation.
 -- |
 -- | ```purescript
--- | slice 0 0   "purescript" == Just ""
--- | slice 0 1   "purescript" == Just "p"
--- | slice 3 6   "purescript" == Just "esc"
--- | slice (-4) (-1) "purescript" == Just "rip"
--- | slice (-4) 3  "purescript" == Nothing
+-- | slice 0 0   "purescript" == ""
+-- | slice 0 1   "purescript" == "p"
+-- | slice 3 6   "purescript" == "esc"
+-- | slice (-4) (-1) "purescript" == "rip"
+-- | slice (-4) 3  "purescript" == ""
 -- | ```
-slice :: Int -> Int -> String -> Maybe String
-slice b e s = if b' < 0 || b' >= l ||
-                 e' < 0 || e' >  l ||
-                 b' > e'
-              then Nothing
-              else Just (_slice b e s)
-  where
-    l = length s
-    norm x | x < 0 = l + x
-           | otherwise = x
-    b' = norm b
-    e' = norm e
-
-foreign import _slice :: Int -> Int -> String -> String
+foreign import slice :: Int -> Int -> String -> String
 
 -- | Splits a string into two substrings, where `before` contains the
 -- | characters up to (but not including) the given index, and `after` contains