Move startsWith and endsWith up

This is because like `stripPrefix` and `stripSuffix`, these functions
are CodeUnit/CodePoint-agnostic. The same was also done for tests.

src/Data/String/CodeUnits.purs

@@ -33,9 +33,10 @@ import Data.String.Pattern (Pattern(..))
 import Data.String.Unsafe as U
 
 -------------------------------------------------------------------------------
--- `stripPrefix`, `stripSuffix`, and `contains` are CodeUnit/CodePoint agnostic
--- as they are based on patterns rather than lengths/indices, but they need to
--- be defined in here to avoid a circular module dependency
+-- `stripPrefix`, `stripSuffix`, `startsWith`, `endsWith`, and `contains` are
+-- CodeUnit/CodePoint agnostic as they are based on patterns rather than
+-- lengths/indices, but they need to be defined in here to avoid a circular
+-- module dependency
 -------------------------------------------------------------------------------
 
 -- | If the string starts with the given prefix, return the portion of the
@@ -63,6 +64,30 @@ stripSuffix (Pattern suffix) str =
   let { before, after } = splitAt (length str - length suffix) str in
   if after == suffix then Just before else Nothing
 
+-- | Checks whether the given string starts with the pattern.
+-- |
+-- | **NOTE**: if you also want to get the string stripped of the pattern, see
+-- | `stripPrefix`.
+-- |
+-- | ```purescript
+-- | startsWith (Pattern "foo") "foobar" == true
+-- | startsWith (Pattern "bar") "foobar" == false
+-- | ```
+startsWith :: Pattern -> String -> Boolean
+startsWith pat = isJust <<< stripPrefix pat
+
+-- | Checks whether the given string ends with the pattern.
+-- |
+-- | **NOTE**: if you also want to get the string stripped of the pattern, see
+-- | `stripSuffix`.
+-- |
+-- | ```purescript
+-- | endsWith (Pattern "bar") "foobar" == true
+-- | endsWith (Pattern "foo") "foobar" == false
+-- | ```
+endsWith :: Pattern -> String -> Boolean
+endsWith pat = isJust <<< stripSuffix pat
+
 -- | Checks whether the pattern appears in the given string.
 -- |
 -- | ```purescript
@@ -345,27 +370,3 @@ foreign import _slice :: Int -> Int -> String -> String
 -- | splitAt i s == {before: take i s, after: drop i s}
 -- | ```
 foreign import splitAt :: Int -> String -> { before :: String, after :: String }
-
--- | Checks whether the given string starts with the pattern.
--- |
--- | **NOTE**: if you also want to get the string stripped of the pattern, see
--- | `stripPrefix`.
--- |
--- | ```purescript
--- | startsWith (Pattern "foo") "foobar" == true
--- | startsWith (Pattern "bar") "foobar" == false
--- | ```
-startsWith :: Pattern -> String -> Boolean
-startsWith pat = isJust <<< stripPrefix pat
-
--- | Checks whether the given string ends with the pattern.
--- |
--- | **NOTE**: if you also want to get the string stripped of the pattern, see
--- | `stripSuffix`.
--- |
--- | ```purescript
--- | endsWith (Pattern "bar") "foobar" == true
--- | endsWith (Pattern "foo") "foobar" == false
--- | ```
-endsWith :: Pattern -> String -> Boolean
-endsWith pat = isJust <<< stripSuffix pat

test/Test/Data/String/CodeUnits.purs

@@ -64,6 +64,20 @@ testStringCodeUnits = do
     , expected: Just ""
     }
 
+  log "startsWith"
+  assert $ SCU.startsWith (Pattern "foo") "foobar"
+  assert $ SCU.startsWith (Pattern "foo") "foo"
+  assert $ SCU.startsWith (Pattern "") ""
+  assert $ SCU.startsWith (Pattern "") "foo"
+  assert $ not $ SCU.startsWith (Pattern "foo") ""
+
+  log "endsWith"
+  assert $ SCU.endsWith (Pattern "bar") "foobar"
+  assert $ SCU.endsWith (Pattern "bar") "bar"
+  assert $ SCU.endsWith (Pattern "") ""
+  assert $ SCU.endsWith (Pattern "") "bar"
+  assert $ not $ SCU.endsWith (Pattern "bar") ""
+
   log "charAt"
   assertEqual
     { actual: SCU.charAt 0 ""
@@ -510,17 +524,3 @@ testStringCodeUnits = do
     { actual: SCU.slice 3 1000 "purescript"
     , expected: Nothing -- e > l
     }
-
-  log "startsWith"
-  assert $ SCU.startsWith (Pattern "foo") "foobar"
-  assert $ SCU.startsWith (Pattern "foo") "foo"
-  assert $ SCU.startsWith (Pattern "") ""
-  assert $ SCU.startsWith (Pattern "") "foo"
-  assert $ not $ SCU.startsWith (Pattern "foo") ""
-
-  log "endsWith"
-  assert $ SCU.endsWith (Pattern "bar") "foobar"
-  assert $ SCU.endsWith (Pattern "bar") "bar"
-  assert $ SCU.endsWith (Pattern "") ""
-  assert $ SCU.endsWith (Pattern "") "bar"
-  assert $ not $ SCU.endsWith (Pattern "bar") ""