Haskell takeWhile + 1

Question

How can I write a takeWhile that would keep the first element that doesn't match the condition?

Example (obviously my example is trickier than this) :

Instead of takeWhile (\\× - > x! = 3) [1..10] to return [1,2] I need [1,2,3] .

I thought of (takeWhile myFunc myList) ++ [find myFunc myList] but it means I need to go through my list 2 times...

Any idea?

Answer 1

You can use span or break .

λ> span (/=3) [1..10]
([1,2],[3,4,5,6,7,8,9,10])

So you can do something like this:

takeWhileInc :: (a -> Bool) -> [a] -> [a]
takeWhileInc p xs = case zs of [] -> error "not found"
                               (z:_) -> ys ++ [z]
  where
    (ys, zs) = span p xs

(Or whatever you want to happen when zs is empty because no 3 was found.)

Answer 2

You can roll your own.

takeWhileOneMore :: (a -> Bool) -> [a] -> [a]
takeWhileOneMore p = foldr (\x ys -> if p x then x:ys else [x]) []

Compare it with

takeWhile :: (a -> Bool) -> [a] -> [a]
takeWhile p = foldr (\x ys -> if p x then x:ys else []) []

Explicit recursion would also be fine for this.

takeWhileOneMore :: (a -> Bool) -> [a] -> [a]
takeWhileOneMore p [] = []
takeWhileOneMore p (x:xs) = 
   if p x
   then x : takeWhileOneMore p xs
   else [x]

Answer 3

I like to use the base function more than many people do, such as re-using takeWhile in an intelligent way to get the desired result. For example, you can create a new list of predicates with the first element being True and takeWhile this list is true:

takeWhileP1 p xs = map snd (takeWhile fst (zip (True:map p xs) xs)

This generalizes nicely as well (not necessarily efficient in this form):

takeWhilePlusN n p xs = map snd (takeWhile fst (zip (replicate n True ++ map p xs) xs))

Or perhaps easier to read:

takeWhilePlusN n p xs =
  let preds     = replicate n True ++ map p xs
      annotated = zip preds xs
  in map snd (takeWhile fst annotated)

And the result:

*Main> takeWhilePlusN 3 (<5) [1..10]
[1,2,3,4,5,6,7]
*Main> takeWhilePlusN 1 (<5) [1..10]
[1,2,3,4,5]
*Main> takeWhileP1 (<5) [1..10]
[1,2,3,4,5]
*Main> takeWhile (<5) [1..10]
[1,2,3,4]

Answer 4

When the condition fails for a element, instead of terminating with empty list, we can return the element.

takeWhileInclusive :: (a->Bool)  -> [a] -> [a]
takeWhileInclusive _ [] = []
takeWhileInclusive predicate (x:xs) = if predicate x 
                                         then do (x: takeWhileInclusive predicate xs)
                                            else [x]