Evan Laforge wrote:
>> I think that in every particular case you have to find out how to avoid
>> 'reverse'. Especially if you have two 'reverse's like in
>> reverse . dropWhile p . reverse
>> there are more efficient solutions.
>
> Just from curiosity, what *is* an efficient way to do rDropWhile?
> Here's something which at least avoids 2 reverses:
>
> rDropWhile = doRDropWhile []
>
> doRDropWhile accum f [] = []
> doRDropWhile accum f (x:xs)
> | f x = doRDropWhile (x:accum) f xs
> | otherwise = reverse (x:accum) ++ doRDropWhile [] f xs
How about a fold?
rDropWhile f = either (const []) id . foldr g (Left ())
where
g x (Left _ ) = if f x then Left () else Right [x]
g x (Right xs) = Right (x:xs)
> I assume this is not in Data.List to discourage people from doing
> things to the right side of lists... it's still useful for string
> stuff where ByteString would be overkill though.
Indeed, the list data structure is intended to be used from the left
only. For double-end access, there are queues and Data.Sequence.
Regards,
apfelmus
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
