How to filter an infinite list in Haskell [duplicate]

Answer 1

You've simply asked for every number less than 1000 in a list. You know that the list is sorted, but your algorithm doesn't take advantage of this. The compiler does not automatically realize you're working with sorted data, and cannot infer that once you've seen a number that is at least 1000, you can never again see one that is less than that.

As others have pointed out, takeWhile (< 1000) [1..] leverages your knowledge of how special your list is by specifially stopping its examination of the list once the predicate has failed for an element (in this case, once a number that is at least 1000 has been encountered). Notice how this is an optimization available because [1..] isn't "just a list"; it's a list with special properties (in particular, it's sorted).

Answer 2

The check x<1000 is used to decide what to include in the filtered list, not to stop the evaluation. In other words, you are giving to ghci an infinite list and it will do x<1000 for every element of the list. If you want to take elements until a predicate is True, use takeWhile. It doesn't matter that Haskell is lazy, the filtered list is evaluated because ghci print it. If you want to avoid this, use let

let l = [x | x <- [1..], x < 1000]

Answer 3

Since you produce an infinite with [1..], every element of this list is checked with your condition x < 1000. This also means that every element greater than 1000 of this list is checked with this condition.

But you can write your function like this:

myFilteredList :: [Int] -> [Int]
myFilteredList [] = []
myFilteredList (x:xs) = if x < 1000 then x: myFilteredList xs else []

For a more general behaviour, you can take the condition as argument as well.

myFilteredList :: (a -> Bool) -> [a] -> [a]
myFilteredList cond [] = []
myFilteredList cond (x:xs) = if cond x then x: myFilteredList cond xs else []

myFilteredList (< 1000) [1..]

And this is exactly what the predefined function takeWhile does. It takes a condition (a -> Bool) and a list [a] as arguments and returns the prefix of the list that fit the condition. Like in the definition of myFilteredList, the function terminates if it processed the whole list or if it reaches the first element in the list, that does not hold the condition.

Answer 4

[x | x <- [1..], x < 1000] is equivalent to filter (< 1000) [1..]; you want takeWhile (< 1000) [1..] instead.

So what's the difference between filter and takeWhile?

Well, if you try to evaluate the entire result --- and that's what ghci does, in order to print it --- then filter will test each and every element in the input list to determine whether it should be in the output list. After the first thousand elements? It carries on testing. filter doesn't know that it isn't suddenly going to encounter ..., 12345, 12346, -7, 12348, ....

Another way of looking at it is that filter can only say "the output list ends here" once it's reached the end of the input list. If you feed it an infinite list, it can never be sure it has generated all elements of the output list. So it will appear to hang.

takeWhile, on the other hand, stops and terminates its output list as soon as it reaches an element that fails the condition.