列表理解递归[Haskell]

Question

I have the following function, which divides a list of Maybes with an Int input.

divideList :: Int -> [Maybe Int] -> [Maybe Double]

ie

 divideList 100 [Just 5, Just 4, Nothing]   == [Just 20, Just 25.0, Nothing]

As a reminder the Maybe datatype is defined as follows:

 data Maybe a = Nothing | Just a

My code looks(and works) as followings:

divideList m xs = [ div2 x | x <- xs]
    where
        div2 (Just n) | n > 0   = Just (fromIntegral m / fromIntegral n)
        div2 _                  = Nothing

Now I'm trying to write the same function again, but this time just with recursion and without list comprehensions. However I can't seem to get it working.

Here's my (wrong) guess:

divideList m xs = div2  x 
    where
        div2 (Just x) | x > 0   = Just (fromIntegral m / fromIntegral x)
        div2 _                  = Nothing

Answer 1

You are almost there.

1. First define the division function separately

    div3 :: Int -> Maybe Int -> Maybe Double div3 i (Just n) | n > 0 = Just (fromIntegral i / fromIntegral n) div3 i _ = Nothing 

2. Then, for each item in the list, call the div3 and concatenate it with the result of the recursive call to divideList , like this

    divideList :: Int -> [Maybe Int] -> [Maybe Double] divideList _ [] = [] divideList m (x:xs) = (div3 mx):(divideList m xs) 

Here,

divideList _ [] = []

is called the base condition of your recursion. That decides when your recursion ends.

Answer 2

What I always recommend is this: do not write direct recursive solutions like what you're trying to do. They're not idiomatic, they're harder to read, and they get pretty hard to write once you're doing anything complex.

Instead, figure out how to write your solution with standard library functions like map , filter and so on. Then, as an exercise, write your own versions of those library functions. In this case:

divideList m xs = map div2 xs
    where
        div2 (Just n) | n > 0   = Just (fromIntegral m / fromIntegral n)
        div2 _                  = Nothing

-- Apply the function `f` to each element of the list, returning a list of the results,
-- in the order of the corresponding arguments.
map f []     = _   -- Fill me in
map f (x:xs) = _   -- Fill me in

Answer 3

I'd suggest to write first a function for the division of two integral numbers. It must return a Maybe Double , as the calculation isn't always possible.

div2 m n = if n <= 0 then Nothing else Just (fromIntegral m / fromIntegral n)

Then you just need to apply this function to every element of the list, which can be done with map . However, as the number is "hidden" in a Maybe , you can use the function (>>=) to "unwrap" it (when it isn't a Nothing , which stays a Nothing , as we want).

divideList m xs = map (>>= div2 m) xs

Or shorter:

divideList m = map (>>= div2 m)