Compare real list in sml

Question

For the next code I'm getting an error:

fun epoly(L:real list, x:real)=
= if L = [] then 0.0 else (epoly(tl(L:real list), x:real));;

Error:

stdIn:42.1-42.57 Error: operator and operand don't agree [equality type required]
  operator domain: ''Z * ''Z
  operand:         real list * 'Y list
  in expression:
    L = nil

Answer 1

Since you're not actually asking a question, it is a little unclear what your intent is. Presumably this is attempted code that doesn't work and the accompanying error message, and the implicit question is "Why doesn't this code work? What am I doing wrong, and what can I do to improve it?" But really that's guesswork, and those are lazy questions, too.

Here's how your post could look like if my assumptions above are correct and you want positive feedback in the future:

I am trying to write a function that evaluates a polynomial with real coefficients L for the variable x.

It looks like:

fun epoly (L : real list, x : real) =
    if L = [] then 0.0 else epoly(tl L, x)

Unfortunately I am getting a type error that I don't understand:

stdIn:1.35-1.91 Error: operator and operand don't agree [equality type required]
  operator domain: ''Z * ''Z
  operand:         real list * 'Y list
  in expression:
    L = nil

What does this error mean, and if this is not the right way to evaluate a polynomial, then what would another way to accomplish the same thing look like?

The take-aways:

• Write what your problem is, don't let others assume what your problem is. Making a question easily understood makes people want to answer your question, and describing your problem in words tells what you think is the problem, so that people don't try and answer the wrong question. In this case, your question could have been "Under what version of the Standard ML specification were reals removed as an eqtype?" and a sufficient answer would have been '97. But would you have been happy about that answer?

  Once you know how to ask the right question, you can also better google around (e.g. search for: evaluate polynomial "standard ml"|sml) and find that there exists code from which you can let yourself inspire: here, here, here.

• Format your code nicely and make sure it works. Use StackOverflow's Markdown to format your code nicely. The code that you posted contains artifacts from the interactive REPL (an extra =), so anyone who copy-pastes it into a REPL will get an error, will have to figure out where it occurred, fix it, and then start to think about what could be the problem, since you didn't say. A good rule is to test that the code you posted works by copy-pasting it once you've asked the question. One can easily forget to include a non-standard function.

An answer, assuming my rendition of your "question" somewhat lines up with your intent:

---

When you do if L = [] ... then you're using equality for lists of reals, which in turn relies on equality for reals, but reals can't be compared for equality. See the Q&A "Why can't I compare reals in Standard ML?" You can test if a list of reals is empty without comparing reals by doing e.g.:

fun epoly (L, x) =
    if null L then 0.0 else epoly (tl L, x)

This is because the standard library function null uses pattern matching on lists but does not address the list's elements, whereas = assumes that elements may have to be compared. Even though that never happens in practice in the example L = [], this is still an error in the type system.

If you were comparing reals for equality, consider using an epsilon test. Besides that, consider using pattern matching instead of hd and tl because those functions can fail and crash because they're partial:

fun epoly ([],    x) = 0.0
  | epoly (c::cs, x) = epoly (cs, x)

All this function does is throw away its second argument x, traverse its first argument, c::cs, and do nothing with each coefficient c. Presumably, in order to evaluate a polynomial, you must do something to coefficient c and x before doing the same thing recursively on the remaining coefficients cs and x, and then somehow compose those.