# :: (a -> Bool) -> [a] -> [a]

filter, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,
```filter p xs = [ x | x <- xs, p x]
```
```>>> filter odd [1, 2, 3]
[1,3]
```
takeWhile, applied to a predicate p and a list xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p:
```takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
takeWhile (< 9) [1,2,3] == [1,2,3]
takeWhile (< 0) [1,2,3] == []
```
dropWhile p xs returns the suffix remaining after takeWhile p xs:
```dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
dropWhile (< 9) [1,2,3] == []
dropWhile (< 0) [1,2,3] == [1,2,3]
```
The dropWhileEnd function drops the largest suffix of a list in which the given predicate holds for all elements. For example:
```>>> dropWhileEnd isSpace "foo\n"
"foo"
```
```>>> dropWhileEnd isSpace "foo bar"
"foo bar"
```
```dropWhileEnd isSpace ("foo\n" ++ undefined) == "foo" ++ undefined
```
filter, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,
```filter p xs = [ x | x <- xs, p x]
```
dropWhile p xs returns the suffix remaining after takeWhile p xs:
```dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
dropWhile (< 9) [1,2,3] == []
dropWhile (< 0) [1,2,3] == [1,2,3]
```
takeWhile, applied to a predicate p and a list xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p:
```takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
takeWhile (< 9) [1,2,3] == [1,2,3]
takeWhile (< 0) [1,2,3] == []
```
dropWhileEndLE p is equivalent to reverse . dropWhile p . reverse, but quite a bit faster. The difference between "Data.List.dropWhileEnd" and this version is that the one in Data.List is strict in elements, but spine-lazy, while this one is spine-strict but lazy in elements. That's what LE stands for - "lazy in elements". Example:
```>>> safeTail \$ Data.List.dropWhileEnd (<3) [undefined, 5, 4, 3, 2, 1]
*** Exception: Prelude.undefined
...
```
```>>> safeTail \$ dropWhileEndLE (<3) [undefined, 5, 4, 3, 2, 1]
[5,4,3]
```
```>>> take 3 \$ Data.List.dropWhileEnd (<3) [5, 4, 3, 2, 1, undefined]
[5,4,3]
```
```>>> take 3 \$ dropWhileEndLE (<3) [5, 4, 3, 2, 1, undefined]
*** Exception: Prelude.undefined
...
```
takeWhileEndLE p is equivalent to reverse . takeWhile p . reverse, but is usually faster (as well as being easier to read).
A version of dropWhileEnd but with different strictness properties. The function dropWhileEnd can be used on an infinite list and tests the property on each character. In contrast, dropWhileEnd' is strict in the spine of the list but only tests the trailing suffix. This version usually outperforms dropWhileEnd if the list is short or the test is expensive. Note the tests below cover both the prime and non-prime variants.
```dropWhileEnd  isSpace "ab cde  " == "ab cde"
dropWhileEnd' isSpace "ab cde  " == "ab cde"
last (dropWhileEnd  even [undefined,3]) == undefined
last (dropWhileEnd' even [undefined,3]) == 3
head (dropWhileEnd  even (3:undefined)) == 3
head (dropWhileEnd' even (3:undefined)) == undefined
```
A version of takeWhile operating from the end.
```takeWhileEnd even [2,3,4,6] == [4,6]
```
Take all elements until one matches. The matching element is returned, too. This is the key difference to takeWhile (not . p). It holds takeUntil p xs == fst (breakAfter p xs).
Deprecated: Use dropWhile from Data.List.Reverse.StrictElement or Data.List.Reverse.StrictSpine instead
Deprecated: Use takeWhile from Data.List.Reverse.StrictElement or Data.List.Reverse.StrictSpine instead
Remove the longest suffix of elements satisfying p. In contrast to reverse . dropWhile p . reverse this works for infinite lists, too.
Alternative version of reverse . takeWhile p . reverse.
Like reverse . List.dropWhile p . reverse.
Like reverse . List.takeWhile p . reverse.
The dropWhileEnd function drops the largest suffix of a list in which the given predicate holds for all elements. For example:
```>>> dropWhileEnd isSpace "foo\n"
"foo"
```
```>>> dropWhileEnd isSpace "foo bar"
"foo bar"
```
```dropWhileEnd isSpace ("foo\n" ++ undefined) == "foo" ++ undefined
```
O(n). filter, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,
```filter p xs = [ x | x <- xs, p x]
```
```>>> filter odd [1, 2, 3]
[1,3]
```
Like filter, only it reverses the sense of the test