git.iko.soy/streamly
on master help sign in
Make splitOnSuffixSeq fuse
cad13b0Harendra Kumar
src/Streamly/Internal/Data/Stream/StreamD.hs+96−73
compare with master
unifiedsplit
@@ -1793,7 +1793,6 @@ data SplitOnSeqState rb rh ck w fs s b x =
1793
1793
1794 | SplitOnSeqEmpty s
1794 | SplitOnSeqEmpty s
1795
1795
1796− | SplitOnSeqSingleInit s x
1797 | SplitOnSeqSingle !fs s x
1796 | SplitOnSeqSingle !fs s x
1798
1797
1799 | SplitOnSeqWordInit s
1798 | SplitOnSeqWordInit s
@@ -1890,9 +1889,6 @@ splitOnSeq patArr (Fold fstep initial done) (Stream step state) =
1890 -- Single Pattern
1889 -- Single Pattern
1891 -----------------
1890 -----------------
1892
1891
1893− stepOuter _ (SplitOnSeqSingleInit _ _) =
1894− error "This branch should not have hit"
1895−
1896 stepOuter gst (SplitOnSeqSingle fs st pat) = do
1892 stepOuter gst (SplitOnSeqSingle fs st pat) = do
1897 res <- step (adaptState gst) st
1893 res <- step (adaptState gst) st
1898 case res of
1894 case res of
@@ -2063,6 +2059,27 @@ splitOnSeq patArr (Fold fstep initial done) (Stream step state) =
2063 fs1 <- fstep fs old
2059 fs1 <- fstep fs old
2064 skip $ SplitOnSeqKRDone (n - 1) fs1 rb rh1
2060 skip $ SplitOnSeqKRDone (n - 1) fs1 rb rh1
2065
2061
2062+{-# ANN type SplitOnSuffixSeqState Fuse #-}
2063+data SplitOnSuffixSeqState rb rh ck w fs s b x =
2064+ SplitOnSuffixSeqInit
2065+ | SplitOnSuffixSeqYield b (SplitOnSuffixSeqState rb rh ck w fs s b x)
2066+ | SplitOnSuffixSeqDone
2067+
2068+ | SplitOnSuffixSeqEmpty s
2069+
2070+ | SplitOnSuffixSeqSingleInit s x
2071+ | SplitOnSuffixSeqSingle !fs s x
2072+
2073+ | SplitOnSuffixSeqWordInit s
2074+ | SplitOnSuffixSeqWordLoop !w s !fs
2075+ | SplitOnSuffixSeqWordDone Int !fs !w
2076+
2077+ | SplitOnSuffixSeqKRInit Int s rb !rh
2078+ | SplitOnSuffixSeqKRInit1 !fs s rb !rh
2079+ | SplitOnSuffixSeqKRLoop fs s rb !rh !ck
2080+ | SplitOnSuffixSeqKRCheck fs s rb !rh
2081+ | SplitOnSuffixSeqKRDone Int !fs rb !rh
2082+
2066{-# INLINE_NORMAL splitSuffixOn #-}
2083{-# INLINE_NORMAL splitSuffixOn #-}
2067splitSuffixOn
2084splitSuffixOn
2068 :: forall m a b. (MonadIO m, Storable a, Enum a, Eq a)
2085 :: forall m a b. (MonadIO m, Storable a, Enum a, Eq a)
@@ -2072,7 +2089,7 @@ splitSuffixOn
2072 -> Stream m a
2089 -> Stream m a
2073 -> Stream m b
2090 -> Stream m b
2074splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2091splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2075− Stream stepOuter SplitOnSeqInit
2092+ Stream stepOuter SplitOnSuffixSeqInit
2076
2093
2077 where
2094 where
2078
2095
@@ -2107,48 +2124,48 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2107 skip = return . Skip
2124 skip = return . Skip
2108
2125
2109 {-# INLINE_LATE stepOuter #-}
2126 {-# INLINE_LATE stepOuter #-}
2110− stepOuter _ SplitOnSeqInit =
2127+ stepOuter _ SplitOnSuffixSeqInit =
2111 if patLen == 0
2128 if patLen == 0
2112− then return $ Skip $ SplitOnSeqEmpty state
2129+ then return $ Skip $ SplitOnSuffixSeqEmpty state
2113 else if patLen == 1
2130 else if patLen == 1
2114 then do
2131 then do
2115 let !pat = A.unsafeIndex patArr 0
2132 let !pat = A.unsafeIndex patArr 0
2116− return $ Skip $ SplitOnSeqSingleInit state pat
2133+ return $ Skip $ SplitOnSuffixSeqSingleInit state pat
2117 else if sizeOf (undefined :: a) * patLen
2134 else if sizeOf (undefined :: a) * patLen
2118 <= sizeOf (undefined :: Word)
2135 <= sizeOf (undefined :: Word)
2119− then return $ Skip $ SplitOnSeqWordInit state
2136+ then return $ Skip $ SplitOnSuffixSeqWordInit state
2120 else do
2137 else do
2121 (rb, rhead) <- liftIO $ RB.new patLen
2138 (rb, rhead) <- liftIO $ RB.new patLen
2122− skip $ SplitOnSeqKRInit 0 state rb rhead
2139+ skip $ SplitOnSuffixSeqKRInit 0 state rb rhead
2123
2140
2124− stepOuter _ (SplitOnSeqYield x next) = return $ Yield x next
2141+ stepOuter _ (SplitOnSuffixSeqYield x next) = return $ Yield x next
2125
2142
2126 ---------------------------
2143 ---------------------------
2127 -- Empty pattern
2144 -- Empty pattern
2128 ---------------------------
2145 ---------------------------
2129
2146
2130− stepOuter gst (SplitOnSeqEmpty st) = do
2147+ stepOuter gst (SplitOnSuffixSeqEmpty st) = do
2131 res <- step (adaptState gst) st
2148 res <- step (adaptState gst) st
2132 case res of
2149 case res of
2133 Yield x s -> do
2150 Yield x s -> do
2134 acc <- initial
2151 acc <- initial
2135 acc1 <- fstep acc x
2152 acc1 <- fstep acc x
2136 r <- done acc1
2153 r <- done acc1
2137− skip $ SplitOnSeqYield r (SplitOnSeqEmpty s)
2154+ skip $ SplitOnSuffixSeqYield r (SplitOnSuffixSeqEmpty s)
2138− Skip s -> return $ Skip (SplitOnSeqEmpty s)
2155+ Skip s -> return $ Skip (SplitOnSuffixSeqEmpty s)
2139 Stop -> return Stop
2156 Stop -> return Stop
2140
2157
2141 -----------------
2158 -----------------
2142 -- Done
2159 -- Done
2143 -----------------
2160 -----------------
2144
2161
2145− stepOuter _ SplitOnSeqDone = return Stop
2162+ stepOuter _ SplitOnSuffixSeqDone = return Stop
2146
2163
2147 -----------------
2164 -----------------
2148 -- Single Pattern
2165 -- Single Pattern
2149 -----------------
2166 -----------------
2150
2167
2151− stepOuter gst (SplitOnSeqSingleInit st pat) = do
2168+ stepOuter gst (SplitOnSuffixSeqSingleInit st pat) = do
2152 res <- step (adaptState gst) st
2169 res <- step (adaptState gst) st
2153 case res of
2170 case res of
2154 Yield x s -> do
2171 Yield x s -> do
@@ -2159,19 +2176,19 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2159 then do
2176 then do
2160 fs1 <- fstep fs x
2177 fs1 <- fstep fs x
2161 r <- done fs1
2178 r <- done fs1
2162− let next = SplitOnSeqSingleInit s pat
2179+ let next = SplitOnSuffixSeqSingleInit s pat
2163− skip $ SplitOnSeqYield r next
2180+ skip $ SplitOnSuffixSeqYield r next
2164 else do
2181 else do
2165 r <- done fs
2182 r <- done fs
2166− let next = SplitOnSeqSingleInit s pat
2183+ let next = SplitOnSuffixSeqSingleInit s pat
2167− skip $ SplitOnSeqYield r next
2184+ skip $ SplitOnSuffixSeqYield r next
2168 else do
2185 else do
2169 fs1 <- fstep fs x
2186 fs1 <- fstep fs x
2170− skip $ SplitOnSeqSingle fs1 s pat
2187+ skip $ SplitOnSuffixSeqSingle fs1 s pat
2171− Skip s -> return $ Skip $ (SplitOnSeqSingleInit s pat)
2188+ Skip s -> return $ Skip $ (SplitOnSuffixSeqSingleInit s pat)
2172 Stop -> return Stop
2189 Stop -> return Stop
2173
2190
2174− stepOuter gst (SplitOnSeqSingle fs st pat) = do
2191+ stepOuter gst (SplitOnSuffixSeqSingle fs st pat) = do
2175 res <- step (adaptState gst) st
2192 res <- step (adaptState gst) st
2176 case res of
2193 case res of
2177 Yield x s -> do
2194 Yield x s -> do
@@ -2181,33 +2198,33 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2181 then do
2198 then do
2182 fs1 <- fstep fs x
2199 fs1 <- fstep fs x
2183 r <- done fs1
2200 r <- done fs1
2184− let next = SplitOnSeqSingleInit s pat
2201+ let next = SplitOnSuffixSeqSingleInit s pat
2185− skip $ SplitOnSeqYield r next
2202+ skip $ SplitOnSuffixSeqYield r next
2186 else do
2203 else do
2187 r <- done fs
2204 r <- done fs
2188− let next = SplitOnSeqSingleInit s pat
2205+ let next = SplitOnSuffixSeqSingleInit s pat
2189− skip $ SplitOnSeqYield r next
2206+ skip $ SplitOnSuffixSeqYield r next
2190 else do
2207 else do
2191 fs1 <- fstep fs x
2208 fs1 <- fstep fs x
2192− return $ Skip $ (SplitOnSeqSingle fs1 s pat)
2209+ return $ Skip $ (SplitOnSuffixSeqSingle fs1 s pat)
2193− Skip s -> return $ Skip $ SplitOnSeqSingle fs s pat
2210+ Skip s -> return $ Skip $ SplitOnSuffixSeqSingle fs s pat
2194 Stop -> do
2211 Stop -> do
2195 r <- done fs
2212 r <- done fs
2196− return $ Skip $ SplitOnSeqYield r SplitOnSeqDone
2213+ return $ Skip $ SplitOnSuffixSeqYield r SplitOnSuffixSeqDone
2197
2214
2198 ---------------------------
2215 ---------------------------
2199 -- Short Pattern - Shift Or
2216 -- Short Pattern - Shift Or
2200 ---------------------------
2217 ---------------------------
2201
2218
2202− stepOuter _ (SplitOnSeqWordDone 0 fs _) = do
2219+ stepOuter _ (SplitOnSuffixSeqWordDone 0 fs _) = do
2203 r <- done fs
2220 r <- done fs
2204− skip $ SplitOnSeqYield r SplitOnSeqDone
2221+ skip $ SplitOnSuffixSeqYield r SplitOnSuffixSeqDone
2205− stepOuter _ (SplitOnSeqWordDone n fs wrd) = do
2222+ stepOuter _ (SplitOnSuffixSeqWordDone n fs wrd) = do
2206 let old = elemMask .&. (wrd `shiftR` (elemBits * (n - 1)))
2223 let old = elemMask .&. (wrd `shiftR` (elemBits * (n - 1)))
2207 fs1 <- fstep fs (toEnum $ fromIntegral old)
2224 fs1 <- fstep fs (toEnum $ fromIntegral old)
2208− skip $ SplitOnSeqWordDone (n - 1) fs1 wrd
2225+ skip $ SplitOnSuffixSeqWordDone (n - 1) fs1 wrd
2209
2226
2210− stepOuter gst (SplitOnSeqWordInit st0) = do
2227+ stepOuter gst (SplitOnSuffixSeqWordInit st0) = do
2211 res <- step (adaptState gst) st0
2228 res <- step (adaptState gst) st0
2212 case res of
2229 case res of
2213 Yield x s -> do
2230 Yield x s -> do
@@ -2218,7 +2235,7 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2218 fs1 <- fstep fs x
2235 fs1 <- fstep fs x
2219 go SPEC 1 wrd s fs1
2236 go SPEC 1 wrd s fs1
2220 else go SPEC 1 wrd s fs
2237 else go SPEC 1 wrd s fs
2221− Skip s -> return $ Skip (SplitOnSeqWordInit s)
2238+ Skip s -> return $ Skip (SplitOnSuffixSeqWordInit s)
2222 Stop -> return Stop
2239 Stop -> return Stop
2223
2240
2224 where
2241 where
@@ -2237,9 +2254,9 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2237 if wrd1 .&. wordMask == wordPat
2254 if wrd1 .&. wordMask == wordPat
2238 then do
2255 then do
2239 r <- done fs
2256 r <- done fs
2240− let next = SplitOnSeqWordInit s
2257+ let next = SplitOnSuffixSeqWordInit s
2241− skip $ SplitOnSeqYield r next
2258+ skip $ SplitOnSuffixSeqYield r next
2242− else skip $ SplitOnSeqWordLoop wrd1 s fs1
2259+ else skip $ SplitOnSuffixSeqWordLoop wrd1 s fs1
2243 else go SPEC (idx + 1) wrd1 s fs1
2260 else go SPEC (idx + 1) wrd1 s fs1
2244 else do
2261 else do
2245 if idx == maxIndex
2262 if idx == maxIndex
@@ -2247,14 +2264,14 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2247 if wrd1 .&. wordMask == wordPat
2264 if wrd1 .&. wordMask == wordPat
2248 then do
2265 then do
2249 r <- done fs
2266 r <- done fs
2250− let next = SplitOnSeqWordInit s
2267+ let next = SplitOnSuffixSeqWordInit s
2251− skip $ SplitOnSeqYield r next
2268+ skip $ SplitOnSuffixSeqYield r next
2252− else skip $ SplitOnSeqWordLoop wrd1 s fs
2269+ else skip $ SplitOnSuffixSeqWordLoop wrd1 s fs
2253 else go SPEC (idx + 1) wrd1 s fs
2270 else go SPEC (idx + 1) wrd1 s fs
2254 Skip s -> go SPEC idx wrd s fs
2271 Skip s -> go SPEC idx wrd s fs
2255− Stop -> skip $ SplitOnSeqWordDone idx fs wrd
2272+ Stop -> skip $ SplitOnSuffixSeqWordDone idx fs wrd
2256
2273
2257− stepOuter gst (SplitOnSeqWordLoop wrd0 st0 fs0) =
2274+ stepOuter gst (SplitOnSuffixSeqWordLoop wrd0 st0 fs0) =
2258 go SPEC wrd0 st0 fs0
2275 go SPEC wrd0 st0 fs0
2259
2276
2260 where
2277 where
@@ -2273,16 +2290,16 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2273 if wrd1 .&. wordMask == wordPat
2290 if wrd1 .&. wordMask == wordPat
2274 then do
2291 then do
2275 r <- done fs1
2292 r <- done fs1
2276− let next = SplitOnSeqWordInit s
2293+ let next = SplitOnSuffixSeqWordInit s
2277− skip $ SplitOnSeqYield r next
2294+ skip $ SplitOnSuffixSeqYield r next
2278 else go SPEC wrd1 s fs1
2295 else go SPEC wrd1 s fs1
2279 else do
2296 else do
2280 fs1 <- fstep fs (toEnum $ fromIntegral old)
2297 fs1 <- fstep fs (toEnum $ fromIntegral old)
2281 if wrd1 .&. wordMask == wordPat
2298 if wrd1 .&. wordMask == wordPat
2282 then do
2299 then do
2283 r <- done fs1
2300 r <- done fs1
2284− let next = SplitOnSeqWordInit s
2301+ let next = SplitOnSuffixSeqWordInit s
2285− skip $ SplitOnSeqYield r next
2302+ skip $ SplitOnSuffixSeqYield r next
2286 else go SPEC wrd1 s fs1
2303 else go SPEC wrd1 s fs1
2287 Skip s -> go SPEC wrd s fs
2304 Skip s -> go SPEC wrd s fs
2288 Stop ->
2305 Stop ->
@@ -2292,14 +2309,14 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2292 if withSep
2309 if withSep
2293 then do
2310 then do
2294 r <- done fs
2311 r <- done fs
2295− skip $ SplitOnSeqYield r SplitOnSeqDone
2312+ skip $ SplitOnSuffixSeqYield r SplitOnSuffixSeqDone
2296− else skip $ SplitOnSeqWordDone patLen fs wrd
2313+ else skip $ SplitOnSuffixSeqWordDone patLen fs wrd
2297
2314
2298 -------------------------------
2315 -------------------------------
2299 -- General Pattern - Karp Rabin
2316 -- General Pattern - Karp Rabin
2300 -------------------------------
2317 -------------------------------
2301
2318
2302− stepOuter gst (SplitOnSeqKRInit idx0 st0 rb rh0) = do
2319+ stepOuter gst (SplitOnSuffixSeqKRInit idx0 st0 rb rh0) = do
2303 res <- step (adaptState gst) st0
2320 res <- step (adaptState gst) st0
2304 case res of
2321 case res of
2305 Yield x s -> do
2322 Yield x s -> do
@@ -2308,11 +2325,14 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2308 if withSep
2325 if withSep
2309 then do
2326 then do
2310 fs1 <- fstep fs x
2327 fs1 <- fstep fs x
2311− go SPEC 1 rh1 s fs1
2328+ skip $ SplitOnSuffixSeqKRInit1 fs1 s rb rh1
2312− else go SPEC 1 rh1 s fs
2329+ else skip $ SplitOnSuffixSeqKRInit1 fs s rb rh1
2313− Skip s -> skip $ SplitOnSeqKRInit idx0 s rb rh0
2330+ Skip s -> skip $ SplitOnSuffixSeqKRInit idx0 s rb rh0
2314 Stop -> return Stop
2331 Stop -> return Stop
2315
2332
2333+ stepOuter gst (SplitOnSuffixSeqKRInit1 fs0 st0 rb rh0) = do
2334+ go SPEC (1 :: Int) rh0 st0 fs0
2335+
2316 where
2336 where
2317
2337
2318 go !_ !idx !rh st !fs = do
2338 go !_ !idx !rh st !fs = do
@@ -2328,8 +2348,9 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2328 let fold = RB.unsafeFoldRing (RB.ringBound rb)
2348 let fold = RB.unsafeFoldRing (RB.ringBound rb)
2329 let !ringHash = fold addCksum 0 rb
2349 let !ringHash = fold addCksum 0 rb
2330 if ringHash == patHash
2350 if ringHash == patHash
2331− then skip $ SplitOnSeqKRCheck fs1 s rb rh1
2351+ then skip $ SplitOnSuffixSeqKRCheck fs1 s rb rh1
2352+ else skip $ SplitOnSuffixSeqKRLoop
2332− else skip $ SplitOnSeqKRLoop fs1 s rb rh1 ringHash
2353+ fs1 s rb rh1 ringHash
2333 else go SPEC (idx + 1) rh1 s fs1
2354 else go SPEC (idx + 1) rh1 s fs1
2334 else
2355 else
2335 if idx == maxIndex
2356 if idx == maxIndex
@@ -2337,8 +2358,9 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2337 let fold = RB.unsafeFoldRing (RB.ringBound rb)
2358 let fold = RB.unsafeFoldRing (RB.ringBound rb)
2338 let !ringHash = fold addCksum 0 rb
2359 let !ringHash = fold addCksum 0 rb
2339 if ringHash == patHash
2360 if ringHash == patHash
2340− then skip $ SplitOnSeqKRCheck fs s rb rh1
2361+ then skip $ SplitOnSuffixSeqKRCheck fs s rb rh1
2362+ else skip $ SplitOnSuffixSeqKRLoop
2341− else skip $ SplitOnSeqKRLoop fs s rb rh1 ringHash
2363+ fs s rb rh1 ringHash
2342 else go SPEC (idx + 1) rh1 s fs
2364 else go SPEC (idx + 1) rh1 s fs
2343 Skip s -> go SPEC idx rh s fs
2365 Skip s -> go SPEC idx rh s fs
2344 Stop -> do
2366 Stop -> do
@@ -2349,14 +2371,15 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2349 if withSep
2371 if withSep
2350 then do
2372 then do
2351 r <- done fs
2373 r <- done fs
2352− skip $ SplitOnSeqYield r SplitOnSeqDone
2374+ skip $ SplitOnSuffixSeqYield r SplitOnSuffixSeqDone
2375+ else skip $ SplitOnSuffixSeqKRDone
2353− else skip $ SplitOnSeqKRDone idx fs rb (RB.startOf rb)
2376+ idx fs rb (RB.startOf rb)
2354
2377
2355 -- XXX The recursive "go" is more efficient than the state based recursion
2378 -- XXX The recursive "go" is more efficient than the state based recursion
2356 -- code commented out below. Perhaps its more efficient because of
2379 -- code commented out below. Perhaps its more efficient because of
2357 -- factoring out "rb" outside the loop.
2380 -- factoring out "rb" outside the loop.
2358 --
2381 --
2359− stepOuter gst (SplitOnSeqKRLoop fs0 st0 rb rh0 cksum0) =
2382+ stepOuter gst (SplitOnSuffixSeqKRLoop fs0 st0 rb rh0 cksum0) =
2360 go SPEC fs0 st0 rh0 cksum0
2383 go SPEC fs0 st0 rh0 cksum0
2361
2384
2362 where
2385 where
@@ -2372,12 +2395,12 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2372 then do
2395 then do
2373 fs1 <- fstep fs x
2396 fs1 <- fstep fs x
2374 if (cksum1 == patHash)
2397 if (cksum1 == patHash)
2375− then skip $ SplitOnSeqKRCheck fs1 s rb rh1
2398+ then skip $ SplitOnSuffixSeqKRCheck fs1 s rb rh1
2376 else go SPEC fs1 s rh1 cksum1
2399 else go SPEC fs1 s rh1 cksum1
2377 else do
2400 else do
2378 fs1 <- fstep fs old
2401 fs1 <- fstep fs old
2379 if (cksum1 == patHash)
2402 if (cksum1 == patHash)
2380− then skip $ SplitOnSeqKRCheck fs1 s rb rh1
2403+ then skip $ SplitOnSuffixSeqKRCheck fs1 s rb rh1
2381 else go SPEC fs1 s rh1 cksum1
2404 else go SPEC fs1 s rh1 cksum1
2382 Skip s -> go SPEC fs s rh cksum
2405 Skip s -> go SPEC fs s rh cksum
2383 Stop ->
2406 Stop ->
@@ -2387,25 +2410,25 @@ splitSuffixOn withSep patArr (Fold fstep initial done) (Stream step state) =
2387 if withSep
2410 if withSep
2388 then do
2411 then do
2389 r <- done fs
2412 r <- done fs
2390− skip $ SplitOnSeqYield r SplitOnSeqDone
2413+ skip $ SplitOnSuffixSeqYield r SplitOnSuffixSeqDone
2391− else skip $ SplitOnSeqKRDone patLen fs rb rh
2414+ else skip $ SplitOnSuffixSeqKRDone patLen fs rb rh
2392
2415
2393− stepOuter _ (SplitOnSeqKRCheck fs st rb rh) = do
2416+ stepOuter _ (SplitOnSuffixSeqKRCheck fs st rb rh) = do
2394 if RB.unsafeEqArray rb rh patArr
2417 if RB.unsafeEqArray rb rh patArr
2395 then do
2418 then do
2396 r <- done fs
2419 r <- done fs
2397− let next = SplitOnSeqKRInit 0 st rb (RB.startOf rb)
2420+ let next = SplitOnSuffixSeqKRInit 0 st rb (RB.startOf rb)
2398− skip $ SplitOnSeqYield r next
2421+ skip $ SplitOnSuffixSeqYield r next
2399− else skip $ SplitOnSeqKRLoop fs st rb rh patHash
2422+ else skip $ SplitOnSuffixSeqKRLoop fs st rb rh patHash
2400
2423
2401− stepOuter _ (SplitOnSeqKRDone 0 fs _ _) = do
2424+ stepOuter _ (SplitOnSuffixSeqKRDone 0 fs _ _) = do
2402 r <- done fs
2425 r <- done fs
2403− skip $ SplitOnSeqYield r SplitOnSeqDone
2426+ skip $ SplitOnSuffixSeqYield r SplitOnSuffixSeqDone
2404− stepOuter _ (SplitOnSeqKRDone n fs rb rh) = do
2427+ stepOuter _ (SplitOnSuffixSeqKRDone n fs rb rh) = do
2405 old <- liftIO $ peek rh
2428 old <- liftIO $ peek rh
2406 let rh1 = RB.advance rb rh
2429 let rh1 = RB.advance rb rh
2407 fs1 <- fstep fs old
2430 fs1 <- fstep fs old
2408− skip $ SplitOnSeqKRDone (n - 1) fs1 rb rh1
2431+ skip $ SplitOnSuffixSeqKRDone (n - 1) fs1 rb rh1
2409
2432
2410data SplitState s arr
2433data SplitState s arr
2411 = SplitInitial s
2434 = SplitInitial s