Simplify haskell function

Question

I'm really struggling with Haskell atm.

It took me almost 6 hours to write a function that does what I want. Unfortunately I'm not satisfied with the look of it.

Could someone please give me any hints how to rewrite it?

get_connected_area :: Eq generic_type => [[generic_type]] -> (Int, Int) -> [(Int,Int)] -> generic_type -> [(Int,Int)]
get_connected_area habitat point area nullValue
  | elem point area = area
  | not ((fst point) >= 0) = area
  | not ((snd point) >= 0) = area
  | not ((fst point) < (length habitat)) = area
  | not ((snd point) < (length (habitat!!0))) = area
  | (((habitat!!(fst point))!!(snd point))) == nullValue = area
  | otherwise = 
    let new_area = point : area
    in 
    get_connected_area habitat (fst point+1, snd point) (
        get_connected_area habitat (fst point-1, snd point) (
            get_connected_area habitat (fst point, snd point+1) (
                get_connected_area habitat (fst point, snd point-1) new_area nullValue
                ) nullValue
            ) nullValue
    ) nullValue

The function get's a [[generic_type]] (representing a landscape-map) and searches the fully connected area around a point that isn't equal to the given nullValue.

Eg.:

If the function gets called like this:

get_connected_area [[0,1,0],[1,1,1],[0,1,0],[1,0,0]] (1,1) [] 0

That literally means

0 1 0
1 1 1
0 1 0
1 0 0

Represents a map (like google maps). Start from the point (coordinates) (1,1) I want to get all coordinates of the elements that form a connected area with the given point.

The result therefore should be:

0 1 0
1 1 1
0 1 0
1 0 0

And the corresponting return value (list of coordinates of bold 1s):

[(2,1),(0,1),(1,2),(1,0),(1,1)]

Answer 1

One small change is that you can use pattern matching for the variable point. This means you can use (x, y) instead of point in the function declaration:

get_connected_area habitat (x, y) area nullValue = ...

Now everywhere you have fst point, just put x, and everywhere you have snd point, put y.

Another modification is to use more variables for subexpressions. This can help with the nested recursive calls. For example, make a variable for the inner-most nested call:

....
where foo = get_connected_area habitat (x, y-1) new_area nullValue

Now just put foo instead of the call. This technique can now be repeated for the "new" inner-most call. (Note that you should pick a more descriptive name than foo. Maybe down?)

Note that not (x >= y) is the same as x < y. Use this to simplify all of the conditions. Since these conditions test if a point is inside a bounding rectangle, most of this logic can be factored to a function isIn :: (Int, Int) -> (Int, Int) -> (Int, Int) -> Bool which will make get_connected_area more readable.