Raise/throw exception in SML - function

Question

Write two versions of the function power, the first version takes two integer arguments m and n
and returns the value m^n
Note that both m and n can be any integers (positive or non-positive).
The second version of the function is called (cpower m n) and it is the curried version.
Remark: if both m and n are Zero then an exception should be raised.
fun power(m,n) = if n=0 then 1 else m * power(m,n-1);
fun cpower (m,n) : int =
if n = 0 then 1 else
if n >= 0 then power(m,n) else
if n < 0 then 1/power(m,n) else m * cpower (m,n-1);
How do I add so that this function throws an exception?

Answer 1

Your cpower function does not have the right type signature. It isn't curried. A curried function with two arguments looks like:
fun cpower m n = ...
It has the type int → int → int as opposed to power's type (int × int) → int. Curried functions with two arguments are equivalent to functions with one argument that return a function with another argument. E.g.
fun cpower m = (fn n => ...)
that can also be written
val rec cpower = (fn m => fn n => ...)
Your current cpower function appears to have a special case for n<0, but here you write 1/power(m,n). But the / operator is not defined for integers which the rest of your program assumes through integer literals (0, 1) and if the result is a fraction below 1, it isn't in the domain of integers.
Consider using pattern matching instead of if-then-else in both cases. For the first power function it would look like:
fun naive_power (m, 0) = 1
| naive_power (m, n) = m * naive_power (m, n-1)
Your functions don't throw when both m and n are zero. (Neither does my version that uses pattern matching.) You might want to write an additional if-then-else and throw if both m and n are zero, e.g. like,
fun power (m, 0) = 1
| power (m, n) = if n < 0 then raise Domain else m * power (m, n-1)
One bad thing about this function is that it will check if n < 0 at every single recursive call to itself when, really, you know that if it was positive the first time and the base case will catch it at 0, it won't be negative at any later stage. An elegant solution here is to wrap the recursive part of your function in a non-recursive function that performs these checks once, e.g. like,
fun power (0, 0) = raise Domain
| power (m, n) = if n < 0 then raise Domain else naive_power (m, n)
where naive_power was the function above that assumed its input valid.
One other bad thing about this function is that it isn't tail-recursive when it could easily be. That is, a call to power (m, 5) will evaluate as such:
power (2, 5) ~> 2 * (power (m, 4))
~> 2 * (2 * (power (m, 3)))
~> 2 * (2 * (2 * (power (m, 2))))
~> 2 * (2 * (2 * (2 * (power (m, 1)))))
~> 2 * (2 * (2 * (2 * (2 * power (m, 0)))))
~> 2 * (2 * (2 * (2 * (2 * 1))))
~> 2 * (2 * (2 * (2 * 2)))
~> 2 * (2 * (2 * 4))
~> 2 * (2 * 8)
~> 2 * 16
~> 32
meaning a lot of function calls waiting for the next function call to resolve before itself can resolve. A tail-recursive version might use an additional argument to store the temporary result in and return it at the end:
fun power (0, 0) = raise Domain
| power (M, N) =
let fun power_helper (m, 0, result) = result
| power_helper (m, n, tmp) = power_helper (m, n-1, tmp * m)
in if N < 0 then raise Domain else power_helper (M, N, 1) end
It can be useful to embed helper functions into other functions either because you need to perform certain checks once and have the main, recursive part of your algorithm resolved in another function, or because you wish to add more arguments to your recursive function without breaking the type signature. (power_helper takes three arguments, so a tail-recursive version would not, without being wrapped, be a valid solution to the problem of writing a function with two arguments that calculates mⁿ.
Evaluating power (2, 5) assuming its tail-recusive implementation could look as such:
power (2, 5) ~> power_helper (2, 5, 1)
~> power_helper (2, 4, 2)
~> power_helper (2, 3, 4)
~> power_helper (2, 2, 8)
~> power_helper (2, 1, 16)
~> power_helper (2, 0, 32)
~> 32