**Write a Haskell function to convert a string to a number**. The string should be in the form of $2,345,678.99 and can possibly have leading zeros.

As I mentioned in the last post, there was a better way to solve this than tail recursion.

strToNum :: String -> Float

strToNum(str) = let num = [x|x <- str, (x >= '0' && x <= '9') || x == '.']

in read num :: Float

This function uses list comprehension to filter the string for valid characters and the uses read to convert the filtered string into a floating point number. As you can see it's very concise, and when you are used to the form very readable. This says num is all the valid (0-9 and .) characters from the string str.

**Write a function that takes an argument x and returns a lazy sequence**that has every third number, starting with x. Then, write a function that includes every fifth number, beginning with y. Combine these functions through composition to return every eighth number, beginning with x + y.

stepList x n = take 5 [x,x+n..]

threeList x = stepList x 3

fiveList x = stepList x 5

eightList x y = zipWith (+) (threeList x) (fiveList y)

So, the lazy sequence is [x,x+n..] to stop things running off into infinity I've used

**take**to perform the lazy eveluation. Again, Haskell can be very concise -look at zipWith in eightList.

**Use a partially applied function to define a function that will return**half of a number and another that will append \n to the end of any string.

half = (*) 0.5

This is quite cunning (of Haskell). Inside Hskell all functions are, I believe, curried -that is they take only one argument. As a bit of syntactic sugar Haskell support infix operators, but you can force them to their curried form but surrounding the operator in brackets. Since the functions are curried they are quite happy to have a dangling second argument, in fact we have here a function that is 'multiply by 0.5'.

backAppend x y = y ++ x

append = backAppend "\n"

The same applies to the

**append**function here, only we have had to define

**backAppend**to get the arguments the way round we want.

I'm going to leave the second set for now, and maybe come back to them at the end.

## No comments:

## Post a Comment