Add startsWith and endsWith

CHANGELOG.md

@@ -7,6 +7,7 @@ Notable changes to this project are documented in this file. The format is based
 Breaking changes:
 
 New features:
+- Added `startsWith` and `endsWith` (#147)
 
 Bugfixes:
 

src/Data/String/CodePoints.purs

@@ -34,7 +34,7 @@ import Data.Array as Array
 import Data.Enum (class BoundedEnum, class Enum, Cardinality(..), defaultPred, defaultSucc, fromEnum, toEnum, toEnumWithDefaults)
 import Data.Int (hexadecimal, toStringAs)
 import Data.Maybe (Maybe(..))
-import Data.String.CodeUnits (contains, stripPrefix, stripSuffix) as Exports
+import Data.String.CodeUnits (contains, stripPrefix, stripSuffix, startsWith, endsWith) as Exports
 import Data.String.CodeUnits as CU
 import Data.String.Common (toUpper)
 import Data.String.Pattern (Pattern)

src/Data/String/CodeUnits.purs

@@ -22,6 +22,8 @@ module Data.String.CodeUnits
   , dropWhile
   , slice
   , splitAt
+  , startsWith
+  , endsWith
   ) where
 
 import Prelude
@@ -31,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
@@ -61,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

src/Data/String/NonEmpty.purs

@@ -4,6 +4,6 @@ module Data.String.NonEmpty
   , module Data.String.NonEmpty.CodePoints
   ) where
 
-import Data.String.NonEmpty.Internal (NonEmptyString, class MakeNonEmpty, NonEmptyReplacement(..), appendString, contains, fromString, join1With, joinWith, joinWith1, localeCompare, nes, prependString, replace, replaceAll, stripPrefix, stripSuffix, toLower, toString, toUpper, trim, unsafeFromString)
+import Data.String.NonEmpty.Internal (NonEmptyString, class MakeNonEmpty, NonEmptyReplacement(..), appendString, contains, fromString, join1With, joinWith, joinWith1, localeCompare, nes, prependString, replace, replaceAll, stripPrefix, stripSuffix, startsWith, endsWith, toLower, toString, toUpper, trim, unsafeFromString)
 import Data.String.Pattern (Pattern(..))
 import Data.String.NonEmpty.CodePoints

src/Data/String/NonEmpty/Internal.purs

@@ -123,6 +123,31 @@ stripPrefix pat = fromString <=< liftS (String.stripPrefix pat)
 stripSuffix :: Pattern -> NonEmptyString -> Maybe NonEmptyString
 stripSuffix pat = fromString <=< liftS (String.stripSuffix pat)
 
+
+-- | 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") (NonEmptyString "foobar") == true
+-- | startsWith (Pattern "bar") (NonEmptyString "foobar") == false
+-- | ```
+startsWith :: Pattern -> NonEmptyString -> Boolean
+startsWith = liftS <<< String.startsWith
+
+-- | 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") (NonEmptyString "foobar") == true
+-- | endsWith (Pattern "foo") (NonEmptyString "foobar") == false
+-- | ```
+endsWith :: Pattern -> NonEmptyString -> Boolean
+endsWith = liftS <<< String.endsWith
+
 -- | Checks whether the pattern appears in the given string.
 -- |
 -- | ```purescript

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 ""

test/Test/Data/String/NonEmpty.purs

@@ -144,6 +144,19 @@ testNonEmptyString = do
     , expected: Nothing
     }
 
+  log "startsWith"
+  assert $ NES.startsWith (Pattern "foo") (nes (Proxy :: Proxy "foobar"))
+  assert $ NES.startsWith (Pattern "foo") (nes (Proxy :: Proxy "foo"))
+  assert $ NES.startsWith (Pattern "") (nes (Proxy :: Proxy "foo"))
+  assert $ not $ NES.startsWith (Pattern "foo") (nes (Proxy :: Proxy "f"))
+
+  log "endsWith"
+  assert $ NES.endsWith (Pattern "bar") (nes (Proxy :: Proxy "foobar"))
+  assert $ NES.endsWith (Pattern "bar") (nes (Proxy :: Proxy "bar"))
+  assert $ NES.endsWith (Pattern "") (nes (Proxy :: Proxy "f"))
+  assert $ NES.endsWith (Pattern "") (nes (Proxy :: Proxy "bar"))
+  assert $ not $ NES.endsWith (Pattern "bar") (nes (Proxy :: Proxy "b"))
+
   log "toLower"
   assertEqual
     { actual: NES.toLower (nes (Proxy :: Proxy "bAtMaN"))