Add :next and :previous commands for vim keymap #1075
Conversation
…nd :bnext, etc for now)
…rs are actually added to list)
|
I'm not sure if we want to emulate vim's behavior exactly, but |
|
I suspect what I've ended up doing here is neither. |
| parse :: EventString -> Maybe ExCommand | ||
| parse = Common.parse $ do | ||
| void (P.char 'b') <|> return () | ||
| direction <- (fmap (const False) $ P.string "prev" <|> P.string "previous") <|> fmap (const True) (P.string "next") |
There was a problem hiding this comment.
P.string "prev" <|> P.string "previous" is redundant, because the "prev" parser also matches "previous". Maybe this behavior should be changed, because now "prevsomething" is also accepted.
There was a problem hiding this comment.
This can be solved by using the endOfInput parser
There was a problem hiding this comment.
I opened #1085 to track this issue for all parsers.
| cl' = if direction | ||
| then last cl : init cl | ||
| else tail cl ++ [head cl] | ||
| in forceSpine cl' `seq` window { bufkey = head cl', bufAccessList = tail cl' } |
There was a problem hiding this comment.
Can you explain how this would cause a memory leak without forceSpine? Isn't the entire list stored in memory anyway?
Edit: I think I see it, the reference to the old cl is kept.
Edit 2: Are you sure this works? I tried this:
main = do
print $ iterate f [1..100] !! 1000000
where
f x = forceSpine r `seq` r
where
r = tail x ++ [head x]
forceSpine = go
where
go [] = ()
go (_:xs) = go xsAnd that still has the leak.
Edit 3: Even this still has the leak:
import Data.List
main = do
print $ foldl' (\xs _ -> f xs) [1..100] (replicate 1000000 ())
where
f x = forceSpine r `seq` r
where
r = tail x ++ [head x]
forceSpine = go
where
go [] = ()
go (_:xs) = go xsEdit 4: This fixes it:
main = do
print $ iterate f [1..100] !! 1000000
where
f x = forceSpine r `seq` r
where
r = tail x ++ [head x]
forceSpine = go
where
go [] = ()
go (x:xs) = x `seq` go xs
No description provided.