Words from string to list

Question

I'm trying to write a Haskell function which would read a string and return a list with the words from the string saved in it.

Here's how I did it:

toWordList :: String -> [String]
toWordList = do
[ toLower x | x <- str ]
    let var = removePunctuation(x)
        return (words var)

But I get this error:

Test1.hs:13:17: error: parse error on input 'let'
   |
13 |                 let var = removePunctuation(x)
   |                 ^^^

I'm new to Haskell so I don't have the grasp over its syntax so thanks in advance for the help.

score 1 · Accepted Answer · answered Dec 23 '17 at 14:40

There's quite a few mistakes here, you should spend more time reading over some tutorials (learn you a Haskell, Real World Haskell). You're pretty close though, so I'll try to do a break-down here.

do is special - it doesn't switch Haskell into "imperative mode", it lets you write clearer code when using Monads - if you don't yet know what Monads are, stay away from do! Keywords like return also don't behave the same as in imperative languages. Try to approach Haskell with a completely fresh mind.

Also in Haskell, indentation is important - see this link for a good explanation. Essentially, you want all the lines in the same "block" to have the same indentation.

Okay, let's strip out the do and return keywords, and align the indentation. We'll also name the parameter to the function str - in your original code, you missed this bit out.

toWordList :: String -> [String]
toWordList str =
    [toLower x | x <- str]
    let var = removePunctuation(x)
    words var

The syntax for let is let __ = __ in __. There's different notation when using do, but forget about that for now. We also don't name the result of the list comprehension, so let's do that:

toWordList str =
    let lowered = [toLower x | x <- str] in
    let var = removePunctuation lowered in
    words var

And this works! We just needed to get some syntax right and avoid the monadic syntactic sugar of do/return.

It's possible (and easy) to make it nicer though. Those let blocks are kinda ugly, we can strip those away. We can also replace the list comprehension with map toLower, which is a bit more elegant and is equivalent to your comprehension:

toWordList str = words (removePunctuation (map toLower str))

Nice, that's down to a single line now! But all those brackets are also a bit of an eyesore, how about we use the $ function?

toWordList str = words $ removePunctuation $ map toLower str

Looking good. There's another improvement we can make, which is to convert this into point-free style, where we don't explicitly name our parameter - instead we express this function as the composition of other functions.

toWordList = words . removePunctuation . (map toLower)

And we're done! Hopefully the first two code snippets make it clearer how the Haskell syntax works, and the last few might show you some nice examples of how you can make fairly verbose code much much cleaner.

Words from string to list

1 Answers1