This is my second attempt to code something in F# so my syntax will not be great. I'm using the CTP release on VS 2008 Shell (BTW: all free stuff, so thanks to Microsoft for that - "al Cesar lo que es del Cesar").

Here is the problem: I create a very simple type as follows:

type Polynomial =
{
_coefficient: double;
_degree: int;
_tail: Option
}

The idea is represent a polynomial in a compact way following a Horner-scheme approach:

p(x) = a<SUB>0 </SUB>+ x<SUP>r</SUP><SUB>0 </SUB>(a<SUB>1</SUB> + x<SUP>r</SUP><SUB>1</SUB> (...(a<SUB>n </SUB>+ x<SUP>r</SUP><SUB>n</SUB>)...))

Then:

_coefficient = a<SUB>0</SUB>

_degree = r<SUB>0</SUB>

_tail = a<SUB>1</SUB> + x<SUP>r</SUP><SUB>1</SUB> (...(a<SUB>n </SUB>+ x<SUP>r</SUP><SUB>n</SUB>)...)

and so on. In this representation a choice needs to be made between certainly storing the degree or potentially storing useless zeros; in this particular example I chose the former.

This interesting article explains that lists in F# are either empty or they are tuples of the form (element, list of (the rest of the) elements):

[link:lorgonblog.spaces.live.com]

In essence, the type above tries to apply the same principle to the representation of polynomials. The underlying hope is, of course, that one such representation will make recursiveness the 'natural' way to manipulate these objects.

Since polynomials have a finite degree, at some point _tail becomes nothing; I decided to try and capture this by defining

_tail: Option

in the definition of the type Polynomial (I'm not 100% sure yet if this is what Option<'a> tries to help with, but it certainly looks that way).

Next, I add a member function to evaluate a given polynomial at some specific abscissa:

member p.Evaluate (point: double) =
p._coefficient + (point ** double(p._degree)) *
match p._tail with
| None -> 1.0
| Some q -> q.Evaluate(point)

All this compiles, works beautifully and inherits all the advantages of Horner-scheme evaluation.

My next step is to define a member function to multiply a polynomial by a scalar:

member p.Times (number: double) =
{
_coefficient = p._coefficient * number;
_degree = p._degree;
_tail = match p._tail with
| None -> None
| Some q -> q.Times(number)
}

And here is where the problem appears: The last line does not compile. I get this error:

error FS0193: Type constraint mismatch. The type
Polynomial
is not compatible with type
Option.
The type 'Polynomial' is not compatible with the type 'Option'.

I don't understand why

| Some q -> q.Times(number)

in p.Times results in a type incompatibility error whereas

| Some q -> q.Evaluate(point)

in p.Evaluate works fine (i.e. it does not seem to cause any incompatibilities).

The only difference I can see is that p.Times "does stuff" whereas p.Evaluate "returns stuff"; but with that difference alone I can't figure out what's causing the problem.

I spent a few hours setting as many traps as I could think of (static methods, definition of a class type instead, etc) but I always got the same error and could not find a way to implement the function correctly.

Thank you very much in advance for your help,

dfg