Hello,

> I'm trying to learn haskell, so here's is my first newbie question.
> I hope this list is appropriate for such help requests.
>
Yes.

> I'm trying to write a function with the signature [IO Int] -> IO [Int]
>
As other people have mentioned, the library function sequence has this type (actually a type which generalizes this type).

> conv2 :: [IO Int] -> IO [Int]
> conv2 l = do val <- (head l)
>              rest <- (conv2 (tail l))
>              return (val : rest)
>
> That works,
>
This doesn't quite work since you don't cover the case for empty lists. You need to add another clause:

    conv2 [] = return []

> but it won't work for infinite lists.
> How could I achieve the desired result ?
>
I don't think a function of this type makes sense for infinite lists. Even the library function sequence will diverge on an infinite list. The issue is that you must evaluate all of the input [IO Int] to get the pure [Int] output. In other words, the type IO [Int] means an IO action which results in a (pure) list of ints. Thus, you cannot start returning the result [Int] while there are still IO actions to perform to compute the rest of the result.

-Jeff


---

This e-mail may contain confidential and/or privileged information. If you
are not the intended recipient (or have received this e-mail in error)
please notify the sender immediately and destroy this e-mail. Any
unauthorized copying, disclosure or distribution of the material in this
e-mail is strictly forbidden.