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

@gradbot - What about `Me`? We don't want the large demographic of programmers coming from VB to feel left out. — Daniel, Mar 18 '11 at 17:28
I wish I could write `member _.PrintMessage() =`, to indicate that I'm not using `this` — Tim Robinson, Mar 18 '11 at 18:30
@Tim Robinson: its not quite the same, but I usually use __ (i.e. double underscore) to indicate that I'm not using the self-reference — pblasucci, Mar 18 '11 at 20:57

score 18 · Accepted Answer · answered Mar 18 '11 at 18:20

18

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?

answered Mar 18 '11 at 18:20

kvb

54,864
2
91
133

5

Think about the bizarre context-sensitive behavior of `this` in JavaScript and the simplicity of this (no pun intended) seems brilliant. – Daniel Mar 18 '11 at 18:33
That's a pretty good advantage. Just thought I'd mention that in Java, you would access the outer instance using `MyClass.this`, and in Javascript you do a lot of `var that = this;`. I think I prefer Java's approach, again for consistency. – Stephen Swensen Mar 18 '11 at 19:26
Oh, and interesting philosophical argument, however, I'd argue that if every function had exactly one argument, I'd be content with being forced to use `arg`. :) – Stephen Swensen Mar 18 '11 at 19:35
Nice answer, thanks. _As an F# newbie I had to go and learn about object expressions before I could understand why it was a good answer :)_ – bentayloruk Mar 18 '11 at 20:35
5

@Stephen - I can see your code now: `let x arg = let y arg = let z arg = arg + arg; z arg; y arg` :) – Daniel Mar 18 '11 at 20:37
1

@Daniel - I prefer `let x = (fun arg -> (let y = (fun arg -> (let z = (fun (arg:int) -> arg + arg; arg; 1) in z)) in y))` ;) – Stephen Swensen Mar 18 '11 at 23:21

score 1 · Answer 2 · answered Mar 18 '11 at 18:22

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#.

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

2 Answers2

Linked