Make splitAt total

Author: MonoidMusician

src/Data/String.js

@@ -145,15 +145,9 @@ exports.split = function (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.splitAt = function (i) {
+  return function (s) {
+    return { before: s.substring(0, i), after: s.substring(i) };
   };
 };
 

src/Data/String.purs

@@ -231,15 +231,10 @@ foreign import count :: (Char -> Boolean) -> String -> Int
 -- | * `split (Pattern " ") "hello world" == ["hello", "world"]`
 foreign import split :: Pattern -> String -> Array String
 
--- | Returns the substrings of split at the given index, if the index is within bounds.
-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 }
+-- | Returns a string split into two substrings at the given index, where
+-- | `before` includes all of the characters up to the given index, and `after`
+-- | is the rest of the string, from the given index on.
+foreign import splitAt :: Int -> String -> { before :: String, after :: String }
 
 -- | Converts the string into an array of characters.
 foreign import toCharArray :: String -> Array Char

test/Test/Data/String.purs

@@ -5,7 +5,7 @@ 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.Maybe (Maybe(..), isNothing)
 import Data.String
 
 import Test.Assert (ASSERT, assert)
@@ -160,19 +160,17 @@ testString = do
   assert $ split (Pattern "d") "abc" == ["abc"]
 
   log "splitAt"
-  let testSplitAt i str res =
+  let testSplitAt i str r =
         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
+          { before, after } ->
+            r.before == before && r.after == after
+
+  testSplitAt 1 "" { before: "", after: "" }
+  testSplitAt 0 "a" { before: "", after: "a" }
+  testSplitAt 1 "a" { before: "a", after: "" }
+  testSplitAt 1 "ab" { before: "a", after: "b" }
+  testSplitAt 3 "aabcc" { before: "aab", after: "cc" }
+  testSplitAt (-1) "abc" { before: "", after: "abc" }
 
   log "toCharArray"
   assert $ toCharArray "" == []