WIP

Author: jamesdbrock

src/Parsing/String/Replace.purs

@@ -277,20 +277,28 @@ splitCapT input sep = do
   -- 2. The sep parser succeeds but does not consume any input
   runParserT input (Tuple <$> (splitCapCombinator sep) <*> rest) >>= case _ of
     Left _ -> pure (singleton (Left input))
-    Right (Tuple (Tuple rlist _) remain) -> case uncons rlist of
+    Right (Tuple {carry,rlist} remain) -> case uncons rlist of
       Nothing -> pure (singleton (Left input))
       Just {head: Tuple hunmatched hmatched ,tail} ->
         let term =
               if String.null remain then
                 if String.null hunmatched then
-                  (Right hmatched : Nil)
+                  case carry of
+                    Nothing -> Right hmatched : Nil
+                    Just cp -> Right hmatched : Left (CodePoint.singleton cp) : Nil
                 else
-                  (Left hunmatched : Right hmatched : Nil)
+                  case carry of
+                    Nothing -> Left hunmatched : Right hmatched : Nil
+                    Just cp -> Left hunmatched : Right hmatched : Left (CodePoint.singleton cp) : Nil
               else
                 if String.null hunmatched then
-                  (Right hmatched : Left remain : Nil)
+                  case carry of
+                    Nothing -> Right hmatched : Left remain : Nil
+                    Just cp -> Right hmatched : Left (CodePoint.singleton cp <> remain) : Nil
                 else
-                  (Left hunmatched : Right hmatched : Left remain : Nil)
+                  case carry of
+                    Nothing -> Left hunmatched : Right hmatched : Left remain : Nil
+                    Just cp -> Left hunmatched : Right hmatched : Left (CodePoint.singleton cp <> remain) : Nil
             list = foldl (\ls (Tuple unmatched matched) ->
               if String.null unmatched then
                 (Right matched : ls)
@@ -301,43 +309,47 @@ splitCapT input sep = do
         pure $ unsafePartial $ fromJust $ fromList list
 
 -- | Internal splitCap helper combinator. Returns
--- | - the reversed `many anyTill` List
--- | - the length of the nonempty tuple elements in the List.
+-- | - The reversed `many anyTill` List.
+-- | - The length of the nonempty tuple elements in the List.
+-- | - One CodePoint carried over from the last parser match, in case the
+-- |   parser succeeded without consuming any input. This is where most
+-- |   of the complexity comes from.
 splitCapCombinator
   :: forall m a
    . Monad m
   => ParserT String m a
-  -> ParserT String m (Tuple (List (Tuple String a)) Int)
-splitCapCombinator sep = tailRecM accum {lastPosIndex:0,carry:Nothing,list:Nil,arraySize:0}
+  -> ParserT String m {carry::Maybe CodePoint,rlist::List (Tuple String a),arraySize::Int}
+
+splitCapCombinator sep = tailRecM accum {lastPosIndex:0,carry:Nothing,rlist:Nil,arraySize:0}
   where
-    accum :: {lastPosIndex::Int,carry::Maybe CodePoint,list::List (Tuple String a),arraySize::Int} -> ParserT String m (Step {lastPosIndex::Int,carry::Maybe CodePoint,list::List (Tuple String a),arraySize::Int} (Tuple (List (Tuple String a)) Int))
-    accum {lastPosIndex,carry,list,arraySize} = do
+    accum :: {lastPosIndex::Int,carry::Maybe CodePoint,rlist::List (Tuple String a),arraySize::Int} -> ParserT String m (Step {lastPosIndex::Int,carry::Maybe CodePoint,rlist::List (Tuple String a),arraySize::Int} {carry::Maybe CodePoint,rlist::List (Tuple String a),arraySize::Int})
+    accum {lastPosIndex,carry,rlist,arraySize} = do
       optionMaybe (try $ anyTill sep) >>= case _ of
         Just (Tuple unmatched matched) -> do
+          Position {index:posIndex} <- position
           let
             carry_unmatched = case carry of
               Nothing -> unmatched
               Just cp -> CodePoint.singleton cp <> unmatched
-          Position {index:posIndex} <- position
           if posIndex == lastPosIndex then do
             -- sep succeeded but consumed no input, so advance by one codepoint and
             -- carry the codepoint over to cons to the next unmatched
-            carryNext <- anyCodePoint
+            carryNext <- optionMaybe anyCodePoint
             pure $ Loop
               { lastPosIndex: posIndex+1
-              , carry: Just carryNext
-              , list: (Tuple carry_unmatched matched : list)
-              , arraySize: if String.null unmatched then arraySize + 1 else arraySize + 2
+              , carry: carryNext
+              , rlist: (Tuple carry_unmatched matched : rlist)
+              , arraySize: if String.null carry_unmatched then arraySize + 1 else arraySize + 2
               }
           else
             pure $ Loop
               { lastPosIndex: posIndex
               , carry: Nothing
-              , list: (Tuple carry_unmatched matched : list)
-              , arraySize: if String.null unmatched then arraySize + 1 else arraySize + 2
+              , rlist: (Tuple carry_unmatched matched : rlist)
+              , arraySize: if String.null carry_unmatched then arraySize + 1 else arraySize + 2
               }
         Nothing -> -- no pattern found, so we're done
-          pure (Done (Tuple list arraySize))
+          pure (Done {carry,rlist,arraySize})
 
 
 -- | #### Split on and capture all patterns

test/Main.purs

@@ -925,20 +925,17 @@ main = do
       , expected: "aBaBa"
       }
   assertEqual' "splitCap8"
-    { actual: splitCap "aa" (lookAhead $ string "a")
-    , expected: NonEmptyList $ Right "a" :| Left "a" : Right "a" : Left "a" : Nil
+    { actual: splitCap "aa" (lookAhead $ string "a" *> pure unit)
+    , expected: NonEmptyList $ Right unit :| Left "a" : Right unit : Left "a" : Nil
     }
   assertEqual' "splitCap8B"
-    { actual: splitCap "BaBa" (lookAhead $ string "B")
-    , expected: NonEmptyList $ Right "B" :| Left "Ba" : Right "B" : Left "Ba" : Nil
+    { actual: splitCap "BaBa" (lookAhead $ string "B" *> pure unit)
+    , expected: NonEmptyList $ Right unit :| Left "Ba" : Right unit : Left "Ba" : Nil
     }
   assertEqual' "splitCap9" $
-    let
-      output = splitCap "aBaBa" (match $ lookAhead $ string "B")
-    in
-      { actual: fold (either identity fst <$> output)
-      , expected: "aaa"
-      }
+    { actual: splitCap "aBaBa" (match $ lookAhead $ string "B" *> pure unit)
+    , expected: NonEmptyList $ Left "a" :| Right (Tuple "" unit) : Left "Ba" : Right (Tuple "" unit) : Left "Ba" : Nil
+    }
   assertEqual' "streamEdit1"
     { actual: streamEdit "aBa" (match $ string "B") fst
     , expected: "aBa"