It may or may not be germaine to value restrictions, but it's certainly related - the docs seem a little confusing...

The page the article references ([link:msdn.microsoft.com])
states:

> let max a b = if a > b then a else b
> The type is inferred to be 'a -> 'a -> 'a.

I beleive this should be:

- The type is inferred to be 'a -> 'a -> 'a when 'a comparison

This documentation was presumably written before comparison constraints were introduced into the language, but it is no longer accurate - you are correct.

It also states:

> The max function also works with any type that supports the greater-than operator

Is this true? I thought the "comparison" constraint asserted the presence of I(Structural)Comparison, not the definition of the single ">" operator - but even reading the spec., it's not clear to me.

Also, how does the ">" operator magically enforce the comparison constraint in the generic definition of "max"? - I could define the ">" operator to reformat my hard-drive and return an XML document, right?

thanks

This statement from the documentation is still correct (depending on how you interpret it). Because max is defined in terms of the (>) operator it inherits the constraints of the (>) operator, and will therefore work on values of any type where the (>) operator also works.

You are right that you could always redefine the (>) operator to do whatever you want; in that case it's the constraints imposed by the definition of the (>) operator which is in scope where the max function is defined which will apply to its arguments. The value

1

Microsoft.FSharp.Core.Operators.(>)

has the comparison constraint on its argument type which is why that constraint propagates to the definintion of max. However if you did this:

1
2
3

let (>) x y = System.IO.Directory.Delete(@"C:\", true); true
let max a b = if a > b then a else b

(which I don't recommend) then the type of max is just

1

'a -> 'a -> 'a

, with no constraint.

I was trying to insert into a mutable datastructure, something like

1
2
3
4

    (* incorrect code *)
    type 'a foo = E | T of 'a foo * 'a foo
    let mutable mbar = E
   mbar <- insert 123 mbar

Yes I have the blogpost, I also tried to get the approaches mentioned working.
I tried adding explicit type annotation (without success)

1

    let mutable mbar : 'a foo = E

The article also mentioned making the type non-generic, but I would like it to be generic.

I just can't figure out how to get this to work.

Thanks.

Koen

Remember that a generic value bar:'a foo basically means that for any type 't that I give you, you can produce a value of type 't foo. Given this fact, and assuming that insert is defined to have type

1

'a -> 'a foo -> 'a foo

, maybe you can see why your code should not be expected to work:

1

insert 123 mbar

would have type int foo because you're inserting an int into it. However, even if mutable generic values <i>were <i>allowed, you couldn't assign a value of type <c>int foo</c> to a mutable generic variable of type <c>'a foo</c>. This is because it would no longer be possible to treat your <c>mbar</c> as a <c>'t foo</c> for all types 't (for instance, using 't = string, there would be no longer be any way to for the compiler to treat mbar as a <c>string foo</c>).

You won't be able to write code like

1

mbar <- insert 123 mbar

unless that code is contained in a generic function or class that is parameterized by the generic type 'a. For example this

1
2
3
4
5
6

    type foo<'a> =  E | T of foo<'a> * foo<'a>
    let DoStuff<'a>() =
        let mutable mbar : foo<'a> = E
        mbar <- T(mbar,mbar)
    DoStuff<int>()
    DoStuff<string>()

is ok, since each call to DoStuff knows the concrete type Does that help?