Different Ways to Test if a List Contains Only Positive Integers
================================================================

The following is a series of Haskell_ functions that all solve the following
problem:

    Write a function that takes a list of integers as input, and returns
    ``True`` if all of them are greater than 0, and ``False`` otherwise. The
    empty list should return ``True``.

The purpose of this is to get practice with basic Haskell_ features. Some of
these functions are inefficient, or do things in a needlessly tricky way. But
that's okay for now: the point is to try to learn basic Haskell_ syntax and
techniques.

::

    -- equations with if/then/else
    all_pos1 :: [Int] -> Bool
    all_pos1 []     = True
    all_pos1 (x:xs) = if x <= 0 then False else all_pos1 xs

    -- guarded equations
    all_pos2 :: [Int] -> Bool
    all_pos2 []     = True
    all_pos2 (x:xs) | x <= 0    = False
                    | otherwise = all_pos2 xs

    -- Remove all numbers >= 0 from the list. If the resulting list is empty, then
    -- the numbers were all positive. Otherwise, there are some negatives.
    all_pos3 :: [Int] -> Bool
    all_pos3 lst = null (filter (<=0) lst)

    -- Same idea as all_pos3, but written in a point-free style, i.e. without an
    -- explicit name for the input list. The "." is the function compose operator.
    all_pos4 :: [Int] -> Bool
    all_pos4 = null . (filter (<=0))

    -- (all pred lst) is a prelude function that returns True if pred returns true
    -- for every element of lst
    all_pos5 :: [Int] -> Bool
    all_pos5 lst = all (>0) lst

    -- Point-free version of all_pos5.
    all_pos6 :: [Int] -> Bool
    all_pos6 = all (>0)

    -- Using a right fold.
    all_pos7 :: [Int] -> Bool
    all_pos7 lst = foldr (\x y -> x > 0 && y) True lst

    -- Using a left fold. Notice that the types of x and y in the folding function
    -- have changed.
    all_pos8 :: [Int] -> Bool
    all_pos8 lst = foldl (\x y -> x && y > 0) True lst

    -- Using a list comprehension. This is similar to the "filter" approach above,
    -- but with the filter function replaced by a list comprehension.
    all_pos9 :: [Int] -> Bool
    all_pos9 lst = null [x | x <- lst, x <= 0]

    -- Another solution using a list comprehension. The "and lst" functions
    -- returns True just when every element of lst evalautes to True.
    all_pos10 :: [Int] -> Bool
    all_pos10 lst = and [x > 0 | x <- lst]

    -- A variation of the previous function that uses map instead of a list
    -- comprehension.
    all_pos11 :: [Int] -> Bool
    all_pos11 lst = and (map (>0) lst)

    -- Point-free version of the previous function. "." is function composition.
    all_pos12 :: [Int] -> Bool
    all_pos12 = and . (map (>0))