What are the benefits of such flexible "self-identifiers" in F#?

Question

While I understand self-identifiers in F#, I am puzzled as to the benefits of such flexibility. Why does F# not just support this.Blah as C# does and be done with it? I'm guessing some people use it to improve readability, but even that seems a stretch. So, what are the uses/benefits of this language feature?

For the un-initiated, below is an example that defines a type-wide self identifier "self" and a method scoped identifier "this". The example is taken from the MSDN article linked above.

type MyClass2(dataIn) as self =
   let data = dataIn
   do
       self.PrintMessage()
   member this.PrintMessage() =
       printf "Creating MyClass2 with Data %d" data

Answer 1

One small advantage is that you can use them to differentiate an object expression's this from that of the type which has created it:

type IExample = abstract GetAnObject : unit -> obj

type MyClass() = 
  member outer.Example1 = { new IExample with member inner.GetAnObject() = upcast inner }
  member outer.Example2 = { new IExample with member inner.GetAnObject() = upcast outer }

A potential philosophical reason is that it makes it seem like the this reference is not too different from any other argument. If you should be able to name the other arguments (instead of being forced to use arg1, arg2, etc.), then why shouldn't you be able to name the first argument as you please, too?

Answer 2

The only thing I can come up with (and it's not big) is that since the self-identifier must explicitly be referred to when calling an instance method, being able to name it lets you use something shorter than the word this. There is a lot of (valid or not) desire in languages on FP languages on which F# is based for conciseness (sometimes to the point of overdoing it) that may have prompted this. After all, you'll note this desire showing through in other places in F# where it wouldn't in e.g. C#--note function names like iteri that would probably be called IterateWithIndex in C#.