如何正确使用Maybe base？

Question

I write a code to convert a string to be a list of Intger:

convert::String -> Maybe [Int]
convert (c:cs) 
    isDigit c            = Just(c: (convert cs):[])
    otherwise            = Nothing

and it shows an error...

test.hs:15:26: error:
parse error on input ‘=’
Perhaps you need a 'let' in a 'do' block?
e.g. 'let x = 5' instead of 'x = 5'

Why is that so...

Answer 1

While there are other compile errors in your code, the reason you're getting the error message about the parse error is because you are not including the pipe character used in guards.

convert (c:cs) 
    | isDigit c            = Just(c: (convert cs):[])
    | otherwise            = Nothing

Answer 2

There were several errors in your code. You need to try to convert each character, which gives a Maybe Int . Then you loop on the string using mapM inside the Maybe monad :

import Data.Char

convertChar :: Char -> Maybe Int
convertChar c = if isDigit c then Just $ ord c else Nothing

convert :: String -> Maybe [Int]
convert = mapM convertChar

Answer 3

Another way of looking at V. Semeria's answer is to use sequence (from the Traversable type class) with map :

import Data.Char -- for ord

convertChar :: Char -> Maybe Int
convertChar c = if isDigit c then Just $ ord c - 48 else Nothing

convert :: String -> Maybe [Int]
-- Start with String -> [Maybe Int], then convert
-- the [Maybe Int] to Maybe [Int]
convert = sequence . map convertChar

This is a common pattern, so Traversable also provides traverse , which in this case is equivalent to sequence . map sequence . map .

convert :: Traversable t => t Char -> Maybe (t Int)
convert = traverse converChar

Some examples (most of the instances of Traversable available by default aren't very interesting, but various tree types can have instances).

> convert "123"
Just [1,2,3]
> convert (Just '1')
Just (Just 1)
> convert (True, '2')
Just (True, 2)
> convert (Right '1')
Just (Right 1)