在Haskell中使用守卫编写乘积函数

Question

I need to write the function product in two ways:

1. Using Guards
2. Using if-then-else

So that the function return the product of m through n.

example:

product 3 5

returns 3*4*5 = 60

Thanks

Answer 1

This sounds like a homework problem so instead of just dropping code on you, let's work through the problem:

Type Signature

Haskell is a functional language with strong typing so it is probably best to start by writing the type signature of our function. Your example shows two integer arguments and an integer return value. We code this as:

product :: Int->Int->Int

This reads as " product is a function that takes two Int s and returns an Int ." (there are other more correct ways to read this but that is for another day)

Recursion

we are going to use a common pattern in Haskell. Because we need to keep track of intermediate values in this case the partial product we will write a second function product' that will take an extra parameter, the running product.

product' :: Int->Int->Int->Int
product' accumulator current final = product' (accumulator*current) (current+1) final

At every iteration this will take the most recent accumulated value multiply by current and pass that as the new accumulator, it will take current and add 1 to it passing it as the new current, and will pass final unchanged. To get it started we write our original function:

product i f = product' 1 i f

or in points-free notation

product = product' 1

The problem is the product' code will loop forever. We need a way to stop when we current is greater then final.

Guards

Rather then rewrite the book on guard patterns I'll send you to the book . In short they let you a boolean before you do something. We'll use them to stop our recursion.

product' :: Int->Int->Int->Int
product' accumulator current final 
    | current <= final = product' (accumulator*current) (current+1) final
    | otherwise = accumulator

So long as current is less than or equal to final we continue to recurse once it's not the final answer is in accumulator.

If-Then-Else

Guards can be replaced with if constructs (perhaps deeply nested) in a mechanical fashion.

product' :: Int->Int->Int->Int
product' accumulator current final = 
  if current <= final 
    then product' (accumulator*current) (current+1) final
    else accumulator

Final Thoughts

Don't write code like this. There are a number of wonderfully generic higher level function that do just these types of things. Here is just one better way to write product:

product i f = foldl (*) 1 [i..f]