[BREAKING] Make splitAt return a record, fixes #69

src/Data/String.js

@@ -149,7 +149,8 @@ exports._splitAt = function (just) {
     return function (i) {
       return function (s) {
         return i >= 0 && i < s.length ?
-               just([s.substring(0, i), s.substring(i)]) : nothing;
+               just({ before: s.substring(0, i), after: s.substring(i) }) :
+               nothing;
       };
     };
   };

src/Data/String.purs

@@ -232,14 +232,14 @@ foreign import count :: (Char -> Boolean) -> String -> Int
 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 (Array String)
+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 (Array String)
+                        -> Maybe { 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(..), (==), ($), bind, negate, not, (/=), (&&))
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (CONSOLE, log)
 
-import Data.Maybe (Maybe(..), isNothing)
+import Data.Maybe (Maybe(..), isNothing, maybe)
 import Data.String
 
 import Test.Assert (ASSERT, assert)
@@ -160,11 +160,19 @@ testString = do
   assert $ split (Pattern "d") "abc" == ["abc"]
 
   log "splitAt"
-  assert $ splitAt 1 "" == Nothing
-  assert $ splitAt 0 "a" == Just ["", "a"]
-  assert $ splitAt 1 "ab" == Just ["a", "b"]
-  assert $ splitAt 3 "aabcc" == Just ["aab", "cc"]
-  assert $ splitAt (-1) "abc" == Nothing
+  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 "" == []