update splitting functions

exercises/practice/alphametics/.meta/Example.roc

@@ -72,6 +72,6 @@ parse : Str -> Result { addends : List (List U8), sum : List U8 } _
 parse = \problem ->
     { before, after } = Str.splitFirst? problem " == "
     addends =
-        Str.split before " + "
+        Str.splitOn before " + "
         |> List.map Str.toUtf8
     Ok { addends, sum: Str.toUtf8 after }

exercises/practice/connect/.meta/Example.roc

@@ -9,10 +9,10 @@ parse : Str -> Result Board [InvalidCharacter U8]
 parse = \boardStr ->
     boardStr
     |> Str.trim
-    |> Str.split "\n"
+    |> Str.toUtf8
+    |> List.splitOn '\n'
     |> List.mapTry \row ->
         row
-        |> Str.toUtf8
         |> List.dropIf \char -> char == ' '
         |> List.mapTry \char ->
             when char is
@@ -99,4 +99,3 @@ hasNorthSouthPath = \board, stone ->
                 Empty -> Err NotPlayerStone
         |> List.keepOks \id -> id
     hasPathToSouth northStones (Set.empty {})
-

exercises/practice/forth/.meta/Example.roc

@@ -102,11 +102,11 @@ step = \stack, op ->
 # Parsing
 parse : Str -> Result (List Op) _
 parse = \str ->
-    when Str.split (Str.trim str) "\n" is
+    when Str.splitOn (Str.trim str) "\n" is
         [.. as defLines, program] ->
             defs = parseDefs? defLines
 
-            Str.split program " "
+            Str.splitOn program " "
             |> flattenDefs defs
             |> List.mapTry toOp
 
@@ -115,7 +115,7 @@ parse = \str ->
 parseDefs : List Str -> Result Defs _
 parseDefs = \lines ->
     List.walkTry lines (Dict.empty {}) \defs, line ->
-        when Str.split line " " is
+        when Str.splitOn line " " is
             [":", name, .. as tokens, ";"] ->
                 ops = parseDef? tokens defs
                 Dict.insert defs name ops |> Ok

exercises/practice/go-counting/.meta/Example.roc

@@ -29,10 +29,10 @@ parse = \boardStr ->
 
     rows =
         boardStr
-            |> Str.split "\n"
+            |> Str.toUtf8
+            |> List.splitOn '\n'
             |> List.mapTry? \row ->
                 row
-                |> Str.toUtf8
                 |> List.mapTry \char ->
                     when char is
                         'B' -> Ok Black
@@ -125,4 +125,3 @@ territories = \boardStr ->
                 White -> { black: state.black, white: state.white |> Set.union newTerritory.territory, none: state.none }
                 None -> { black: state.black, white: state.white, none: state.none |> Set.union newTerritory.territory }
     |> Ok
-

exercises/practice/grep/.meta/Example.roc

@@ -31,7 +31,7 @@ grep = \pattern, flags, fileNames ->
 
 findMatches : Config, Str, Str -> List { line : Str, index : U64 }
 findMatches = \config, pattern, text ->
-    Str.split text "\n"
+    Str.splitOn text "\n"
     |> List.mapWithIndex \line, index ->
         { line, index }
     |> List.keepIf \{ line } ->

exercises/practice/kindergarten-garden/.meta/Example.roc

@@ -22,12 +22,7 @@ studentIndex = \student ->
 plants : Str, Student -> Result (List Plant) _
 plants = \diagram, student ->
     startIndex = 2 * studentIndex student
-    grid =
-        diagram
-        |> Str.trim
-        |> Str.split "\n"
-        |> List.map \row ->
-            row |> Str.trim |> Str.toUtf8
+    grid = diagram |> Str.toUtf8 |> List.splitOn '\n'
     [(0, 0), (0, 1), (1, 0), (1, 1)]
         |> List.mapTry \(row, column) ->
             plant = grid |> List.get? row |> List.get? (startIndex + column)

exercises/practice/matrix/.meta/Example.roc

@@ -4,16 +4,15 @@ parseRow : Str -> Result (List I64) [InvalidNumStr]
 parseRow = \rowStr ->
     rowStr
     |> Str.trim
-    |> Str.split " "
+    |> Str.splitOn " "
     |> List.map Str.trim
     |> List.dropIf Str.isEmpty
     |> List.mapTry Str.toI64
 
 parseMatrix : Str -> Result (List (List I64)) [InvalidNumStr]
 parseMatrix = \matrixStr ->
     matrixStr
-    |> Str.trim
-    |> Str.split "\n"
+    |> Str.splitOn "\n"
     |> List.mapTry parseRow
 
 column : Str, U64 -> Result (List I64) [InvalidNumStr, OutOfBounds]

exercises/practice/minesweeper/.meta/Example.roc

@@ -24,7 +24,7 @@ countNeighbors = \rows, x, y ->
 
 annotate : Str -> Str
 annotate = \minefield ->
-    rows = minefield |> Str.split "\n" |> List.map Str.toUtf8
+    rows = minefield |> Str.toUtf8 |> List.splitOn '\n'
     annotated =
         rows
         |> List.mapWithIndex \row, y ->

exercises/practice/ocr-numbers/.meta/Example.roc

@@ -8,7 +8,7 @@ convert = \grid ->
         Ok ""
         else
 
-    gridChars = grid |> Str.split "\n" |> List.map Str.toUtf8
+    gridChars = grid |> Str.toUtf8 |> List.splitOn '\n'
     size = checkSize? gridChars
     gridChars
     |> List.chunksOf 4 # split vertically into groups of 4 rows

exercises/practice/pig-latin/.meta/Example.roc

@@ -22,7 +22,7 @@ pigLatinSwap = \chars ->
                     (_, 'y') if index > 0 -> Break (0, index) # rule 4
                     (_, c) if isVowel c -> Break (0, index) # rule 2
                     _ -> Continue (char, index + 1)
-        { before, others } = chars |> List.split splitIndex
+        { before, others } = chars |> List.splitAt splitIndex
         others |> List.concat before
 
 translateWord : Str -> Str
@@ -40,6 +40,6 @@ translateWord = \word ->
 translate : Str -> Str
 translate = \phrase ->
     phrase
-    |> Str.split " "
+    |> Str.splitOn " "
     |> List.map translateWord
     |> Str.joinWith " "

exercises/practice/poker/.meta/Example.roc

@@ -18,7 +18,7 @@ bestHands = \hands ->
 
 parseHand : Str -> Result Hand HandParsingError
 parseHand = \handStr ->
-    cards = handStr |> Str.split " "
+    cards = handStr |> Str.splitOn " "
     numCards = List.len cards
     if numCards != 5 then
         Err (InvalidNumberOfCards numCards)

exercises/practice/rectangles/.meta/Example.roc

@@ -24,7 +24,7 @@ rectangles : Str -> U64
 rectangles = \diagram ->
     grid =
         diagram
-        |> Str.split "\n"
+        |> Str.splitOn "\n"
         |> List.map Str.toUtf8
     height = grid |> List.len
     grid
@@ -40,4 +40,3 @@ rectangles = \diagram ->
             |> List.sum
         |> List.sum
     |> List.sum
-

exercises/practice/tournament/.meta/Example.roc

@@ -10,9 +10,9 @@ tally = \table ->
         else
 
     table
-        |> Str.split "\n"
+        |> Str.splitOn "\n"
         |> List.mapTry? \row ->
-            when row |> Str.split ";" is
+            when row |> Str.splitOn ";" is
                 [team1, team2, resultStr] ->
                     result = resultStr |> parseResult?
                     Ok (team1, team2, result)

exercises/practice/transpose/.meta/Example.roc

@@ -3,10 +3,7 @@ module [transpose]
 ## Transpose the input string. Input string must be ASCII.
 transpose : Str -> Str
 transpose = \string ->
-    chars =
-        string
-        |> Str.split "\n"
-        |> List.map \row -> row |> Str.toUtf8
+    chars = string |> Str.toUtf8 |> List.splitOn '\n'
     getChar = \row, col ->
         chars |> List.get? row |> List.get col
     maxWidth = chars |> List.map List.len |> List.max |> Result.withDefault 0

exercises/practice/word-search/.meta/Example.roc

@@ -23,7 +23,7 @@ getChar = \grid, columnIndex, rowIndex ->
 
 search : Str, List Str -> Dict Str WordLocation
 search = \grid, wordsToSearchFor ->
-    { rows, width } = grid |> Str.split "\n" |> List.map Str.toUtf8 |> padRight
+    { rows, width } = grid |> Str.toUtf8 |> List.splitOn '\n' |> padRight
     height = List.len rows
     heightI64 = height |> Num.toI64
     widthI64 = width |> Num.toI64

exercises/practice/wordy/.meta/Example.roc

@@ -20,7 +20,7 @@ evaluateExpression = \accumulator, operations ->
 
 answer : Str -> Result I64 [QuestionArgHadAnUnknownOperation Str, QuestionArgHadASyntaxError Str]
 answer = \question ->
-    words = question |> Str.replaceEach "?" " ?" |> Str.split " "
+    words = question |> Str.replaceEach "?" " ?" |> Str.splitOn " "
     when words is
         ["What", "is", numberString, .. as operations, "?"] ->
             maybeStartNumber = Str.toI64 numberString
@@ -37,4 +37,3 @@ answer = \question ->
         [_, "is", _, .., "?"] -> Err (QuestionArgHadAnUnknownOperation question)
         [_, "are", .., "?"] -> Err (QuestionArgHadAnUnknownOperation question)
         _ -> Err (QuestionArgHadASyntaxError question)
-