I am trying to learn TclOO. I have created two classes P and Q which
appear to have identical behavior. Class P uses "my variable" and Q uses
"variable". Can someone explain the difference between them. (I am
familiar with Python and Go if that's any help with explaining.)

oo::class create P {
constructor {{x 0} {y 0}} {
my variable x_
my variable y_
set x_ $x
set y_ $y
}

method x {} {
my variable x_
return $x_
}

method set_x {x} {
if {![string is integer -strict $x]} {
throw NOT_AN_INT "x must be an int not \"$x\""
}
my variable x_
set x_ $x
}

method y {} {
my variable y_
return $y_
}
}

oo::class create Q {
constructor {{x 0} {y 0}} {
variable x_
variable y_
set x_ $x
set y_ $y
}

method x {} {
variable x_
return $x_
}

method set_x {x} {
if {![string is integer -strict $x]} {
throw NOT_AN_INT "x must be an int not \"$x\""
}
variable x_
set x_ $x
}

method y {} {
variable y_
return $y_
}
}

puts "P"
set p1 [P new]
puts "p1 x=[$p1 x] y=[$p1 y]"
$p1 set_x 5
puts "p1 x=[$p1 x] y=[$p1 y]"
try {$p1 set_x "invalid"} trap {} err { puts $err }
set p2 [P new 0 -8]
puts "p2 x=[$p2 x] y=[$p2 y]"
$p2 set_x 17
puts "p2 x=[$p2 x] y=[$p2 y]"
puts "p1 x=[$p1 x] y=[$p1 y]"

puts "Q"
set q1 [Q new]
puts "q1 x=[$q1 x] y=[$q1 y]"
$q1 set_x 5
puts "q1 x=[$q1 x] y=[$q1 y]"
try {$q1 set_x "invalid"} trap {} err { puts $err }
set q2 [Q new 0 -8]
puts "q2 x=[$q2 x] y=[$q2 y]"
$q2 set_x 17
puts "q2 x=[$q2 x] y=[$q2 y]"
puts "q1 x=[$q1 x] y=[$q1 y]"

On 04/07/2024 09:17, Mark Summerfield wrote:
> I am trying to learn TclOO. I have created two classes P and Q which
> appear to have identical behavior. Class P uses "my variable" and Q uses
> "variable". Can someone explain the difference between them. (I am
> familiar with Python and Go if that's any help with explaining.)
>
> oo::class create P {
> constructor {{x 0} {y 0}} {
> my variable x_
> my variable y_
> set x_ $x
> set y_ $y
> }
>
> method x {} {
> my variable x_
> return $x_
> }
>
> method set_x {x} {
> if {![string is integer -strict $x]} {
> throw NOT_AN_INT "x must be an int not \"$x\""
> }
> my variable x_
> set x_ $x
> }
>
> method y {} {
> my variable y_
> return $y_
> }
> }
>
> oo::class create Q {
> constructor {{x 0} {y 0}} {
> variable x_
> variable y_
> set x_ $x
> set y_ $y
> }
>
> method x {} {
> variable x_
> return $x_
> }
>
> method set_x {x} {
> if {![string is integer -strict $x]} {
> throw NOT_AN_INT "x must be an int not \"$x\""
> }
> variable x_
> set x_ $x
> }
>
> method y {} {
> variable y_
> return $y_
> }
> }
>
> puts "P"
> set p1 [P new]
> puts "p1 x=[$p1 x] y=[$p1 y]"
> $p1 set_x 5
> puts "p1 x=[$p1 x] y=[$p1 y]"
> try {$p1 set_x "invalid"} trap {} err { puts $err }
> set p2 [P new 0 -8]
> puts "p2 x=[$p2 x] y=[$p2 y]"
> $p2 set_x 17
> puts "p2 x=[$p2 x] y=[$p2 y]"
> puts "p1 x=[$p1 x] y=[$p1 y]"
>
> puts "Q"
> set q1 [Q new]
> puts "q1 x=[$q1 x] y=[$q1 y]"
> $q1 set_x 5
> puts "q1 x=[$q1 x] y=[$q1 y]"
> try {$q1 set_x "invalid"} trap {} err { puts $err }
> set q2 [Q new 0 -8]
> puts "q2 x=[$q2 x] y=[$q2 y]"
> $q2 set_x 17
> puts "q2 x=[$q2 x] y=[$q2 y]"
> puts "q1 x=[$q1 x] y=[$q1 y]"

Sorry, can't give an exact answer, but my preference is to put member
variables in the oo::class definition, so that in methods they are
available automatically:

oo::class create MyClass {
# private member variables should be CamelCase
variable Var1 Var2 Var3

constructor {} {
# initialize according to their types:
set Var1 [list]
set Var2 [dict create]
array set Var3 {}
}
}

On 04/07/2024 09:17, Mark Summerfield wrote:
> I am trying to learn TclOO. I have created two classes P and Q which
> appear to have identical behavior. Class P uses "my variable" and Q uses
> "variable". Can someone explain the difference between them. (I am
> familiar with Python and Go if that's any help with explaining.)
>
When only passing one argument to each of the commands, there is no
functional difference. I normally use "my variable" if I just want to
access one or more instance variables in a method. I use "variable" when
I want to initialize the variables.

So, in the constructor of your example I would use "variable", while I'd
use "my variable" in the methods:

oo::class create P {
constructor {{x 0} {y 0}} {
variable x_ $x y_ $y
}

method x {} {
my variable x_
return $x_
}
}

Schelte.

Am 04.07.24 um 09:17 schrieb Mark Summerfield:
> I am trying to learn TclOO. I have created two classes P and Q which
> appear to have identical behavior. Class P uses "my variable" and Q uses
> "variable". Can someone explain the difference between them. (I am
> familiar with Python and Go if that's any help with explaining.)
>
> oo::class create P {
> constructor {{x 0} {y 0}} {
> my variable x_
> my variable y_
> set x_ $x
> set y_ $y
> }
>
> method x {} {
> my variable x_
> return $x_
> }
>
> method set_x {x} {
> if {![string is integer -strict $x]} {
> throw NOT_AN_INT "x must be an int not \"$x\""
> }
> my variable x_
> set x_ $x
> }
>
> method y {} {
> my variable y_
> return $y_
> }
> }
>
> oo::class create Q {
> constructor {{x 0} {y 0}} {
> variable x_
> variable y_
> set x_ $x
> set y_ $y
> }
>
> method x {} {
> variable x_
> return $x_
> }
>
> method set_x {x} {
> if {![string is integer -strict $x]} {
> throw NOT_AN_INT "x must be an int not \"$x\""
> }
> variable x_
> set x_ $x
> }
>
> method y {} {
> variable y_
> return $y_
> }
> }
>
> puts "P"
> set p1 [P new]
> puts "p1 x=[$p1 x] y=[$p1 y]"
> $p1 set_x 5
> puts "p1 x=[$p1 x] y=[$p1 y]"
> try {$p1 set_x "invalid"} trap {} err { puts $err }
> set p2 [P new 0 -8]
> puts "p2 x=[$p2 x] y=[$p2 y]"
> $p2 set_x 17
> puts "p2 x=[$p2 x] y=[$p2 y]"
> puts "p1 x=[$p1 x] y=[$p1 y]"
>
> puts "Q"
> set q1 [Q new]
> puts "q1 x=[$q1 x] y=[$q1 y]"
> $q1 set_x 5
> puts "q1 x=[$q1 x] y=[$q1 y]"
> try {$q1 set_x "invalid"} trap {} err { puts $err }
> set q2 [Q new 0 -8]
> puts "q2 x=[$q2 x] y=[$q2 y]"
> $q2 set_x 17
> puts "q2 x=[$q2 x] y=[$q2 y]"
> puts "q1 x=[$q1 x] y=[$q1 y]"

Hello
if the website is not known:

https://wiki.tcl-lang.org/page/Variables+in+TclOO

Gregor

On Fri, 5 Jul 2024 22:26:16 +0200, Schelte wrote:

[snip]
> So, in the constructor of your example I would use "variable", while I'd
> use "my variable" in the methods:
>
> oo::class create P {
> constructor {{x 0} {y 0}} {
> variable x_ $x y_ $y
> }
>
> method x {} {
> my variable x_
> return $x_
> }
> }

What I still don't understand is that in method x, _both_ "my variable"
_and_ plain "variable" seem to work.

In fact the only time I've needed "my" so far is in a method call. (But
I'll read the web page that was recommended and am still working my way
through reading Tip 257.)

On 7/6/2024 1:54 AM, Mark Summerfield wrote:
> On Fri, 5 Jul 2024 22:26:16 +0200, Schelte wrote:
>
> [snip]
>> So, in the constructor of your example I would use "variable", while I'd
>> use "my variable" in the methods:
>>
>> oo::class create P {
>> constructor {{x 0} {y 0}} {
>> variable x_ $x y_ $y
>> }
>>
>> method x {} {
>> my variable x_
>> return $x_
>> }
>> }
>
> What I still don't understand is that in method x, _both_ "my variable"
> _and_ plain "variable" seem to work.
>
> In fact the only time I've needed "my" so far is in a method call. (But
> I'll read the web page that was recommended and am still working my way
> through reading Tip 257.)
>
>
>

I don't understand this either. It appears that the my command, which comes from oo::object treats its first argument as a method, and variable like new and create are some inherited methods. The my command seems to in effect replace "my" with the obj you are currently running. The description in oo::object then treats that obj as the "obj" in its documentation.

The effect seems to be that the same sort of thing occurs, a linking of the variables from a namespace into the current context. And I've read that in several places. Syntactically, however, one takes a list of variables, while the other I don't know. The key paragraph on the wiki is:

"They differ importantly in how multiple arguments are treated, so be careful."

Unfortunately, the list of hyperlinks ends there, so I don't know how they differ. At first I guessed it meant that using variable alone, one could also set values, as in the normal variable command inside a namespace. But when I tried that, it made the 2nd argument a variable also.

I'm afraid this overloading of the variable command has me stumped.

Am 04.07.24 um 09:17 schrieb Mark Summerfield:
> I am trying to learn TclOO. I have created two classes P and Q which
> appear to have identical behavior. Class P uses "my variable" and Q uses
> "variable". Can someone explain the difference between them. (I am
> familiar with Python and Go if that's any help with explaining.)
>

Hello Mark,
I have replaced your demo, hope that's OK.
Different when there are multiple variables as arguments. Originally I
expected the opposite behavior. I had misunderstood that until now.

#DemoClass1 and DemoClass2
# difference constructor with variable individually or together
# difference output for instanceVar2, no initialization with 15 (DemoClass1)
#DemoClass3 and DemoClass4
# no difference with my variable individually or together
# in example:
# objx1 with my variable, x for DemoClass
# objx2 with variable, x for DemoClass

oo::class create DemoClass1 {
constructor {val1 val2} {
variable instanceVar1 instanceVar2
set instanceVar1 $val1
set instanceVar2 $val2
}
method incrementInstanceVarsWithMy {} {
my variable instanceVar1 instanceVar2
incr instanceVar1
incr instanceVar2
}
method incrementInstanceVarsWithVariable {} {
variable instanceVar1
variable instanceVar2
incr instanceVar1
incr instanceVar2
}
method getInstanceVarsWithMy {} {
my variable instanceVar1 instanceVar2
return "instanceVar1: $instanceVar1, \
instanceVar2: $instanceVar2"
}
method getInstanceVarsWithVariable {} {
variable instanceVar1
variable instanceVar2
return "instanceVar1: $instanceVar1, \
instanceVar2: $instanceVar2"
}
} oo::class create DemoClass2 {
constructor {val1 val2} {
variable instanceVar1
variable instanceVar2
set instanceVar1 $val1
set instanceVar2 $val2
}
method incrementInstanceVarsWithMy {} {
my variable instanceVar1 instanceVar2
incr instanceVar1
incr instanceVar2
}
method incrementInstanceVarsWithVariable {} {
variable instanceVar1
variable instanceVar2
incr instanceVar1
incr instanceVar2
}
method getInstanceVarsWithMy {} {
my variable instanceVar1 instanceVar2
return "instanceVar1: $instanceVar1, \
instanceVar2: $instanceVar2"
}
method getInstanceVarsWithVariable {} {
variable instanceVar1
variable instanceVar2
return "instanceVar1: $instanceVar1, \
instanceVar2: $instanceVar2"
}
} oo::class create DemoClass3 {
constructor {val1 val2} {
my variable instanceVar1 instanceVar2
set instanceVar1 $val1
set instanceVar2 $val2
}
method incrementInstanceVarsWithMy {} {
my variable instanceVar1 instanceVar2
incr instanceVar1
incr instanceVar2
}
method incrementInstanceVarsWithVariable {} {
variable instanceVar1
variable instanceVar2
incr instanceVar1
incr instanceVar2
}
method getInstanceVarsWithMy {} {
my variable instanceVar1 instanceVar2
return "instanceVar1: $instanceVar1, \
instanceVar2: $instanceVar2"
}
method getInstanceVarsWithVariable {} {
variable instanceVar1
variable instanceVar2
return "instanceVar1: $instanceVar1, \
instanceVar2: $instanceVar2"
}
}

oo::class create DemoClass4 {
constructor {val1 val2} {
my variable instanceVar1
my variable instanceVar2
set instanceVar1 $val1
set instanceVar2 $val2
}
method incrementInstanceVarsWithMy {} {
my variable instanceVar1
my variable instanceVar2
incr instanceVar1
incr instanceVar2
}
method incrementInstanceVarsWithVariable {} {
variable instanceVar1
variable instanceVar2
incr instanceVar1
incr instanceVar2
}
method getInstanceVarsWithMy {} {
my variable instanceVar1
my variable instanceVar2
return "instanceVar1: $instanceVar1, \
instanceVar2: $instanceVar2"
}
method getInstanceVarsWithVariable {} {
variable instanceVar1
variable instanceVar2
return "instanceVar1: $instanceVar1, \
instanceVar2: $instanceVar2"
}
}

puts "DemoClass1"
puts " obj11"
set obj11 [DemoClass1 new 5 1]
$obj11 incrementInstanceVarsWithMy
puts "obj11: [$obj11 getInstanceVarsWithMy]"
puts " obj12"
set obj12 [DemoClass1 new 15 10]
$obj12 incrementInstanceVarsWithVariable
puts "obj12: [$obj12 getInstanceVarsWithVariable]"

puts \n
puts "DemoClass2"
puts " obj21"
set obj21 [DemoClass2 new 5 1]
$obj21 incrementInstanceVarsWithMy
puts "obj21: [$obj21 getInstanceVarsWithMy]"
puts " obj22"
set obj22 [DemoClass2 new 15 10]
$obj22 incrementInstanceVarsWithVariable
puts "obj22: [$obj22 getInstanceVarsWithVariable]"

puts \n
puts "DemoClass3"
puts " obj31"
set obj31 [DemoClass3 new 5 1]
$obj31 incrementInstanceVarsWithMy
puts "obj31: [$obj31 getInstanceVarsWithMy]"
puts " obj32"
set obj32 [DemoClass3 new 15 10]
$obj32 incrementInstanceVarsWithVariable
puts "obj32: [$obj32 getInstanceVarsWithVariable]"

puts \n
puts "DemoClass4"
puts " obj41"
set obj41 [DemoClass4 new 5 1]
$obj41 incrementInstanceVarsWithMy
puts "obj41: [$obj41 getInstanceVarsWithMy]"
puts " obj42"
set obj42 [DemoClass4 new 15 10]
$obj42 incrementInstanceVarsWithVariable
puts "obj42: [$obj42 getInstanceVarsWithVariable]"

if {0} {
Output:
DemoClass1
obj11
obj11: instanceVar1: 6, instanceVar2: 1
obj12
obj12: instanceVar1: 16, instanceVar2: 1

DemoClass2
obj21
obj21: instanceVar1: 6, instanceVar2: 2
obj22
obj22: instanceVar1: 16, instanceVar2: 11

DemoClass3
obj31
obj31: instanceVar1: 6, instanceVar2: 2
obj32
obj32: instanceVar1: 16, instanceVar2: 11

DemoClass4
obj41
obj41: instanceVar1: 6, instanceVar2: 2
obj42
obj42: instanceVar1: 16, instanceVar2: 11

}

On 7/7/2024 6:21 AM, greg wrote:
> Am 04.07.24 um 09:17 schrieb Mark Summerfield:
>> I am trying to learn TclOO. I have created two classes P and Q which
>> appear to have identical behavior. Class P uses "my variable" and Q uses
>> "variable". Can someone explain the difference between them. (I am
>> familiar with Python and Go if that's any help with explaining.)
>>
>
> Hello Mark,
> I have replaced your demo, hope that's OK.
> Different when there are multiple variables as arguments. Originally I expected the opposite behavior. I had misunderstood that until now.
>
>
>
>
> #DemoClass1 and DemoClass2
> # difference constructor with  variable individually or together
> # difference output for instanceVar2, no initialization with 15 (DemoClass1)
> #DemoClass3 and DemoClass4
> # no difference with my variable individually or together
> # in example:
> # objx1 with my variable, x for DemoClass
> # objx2 with variable, x for DemoClass
>
> oo::class create DemoClass1 {
>     constructor {val1 val2} {
>         variable instanceVar1 instanceVar2
>         set instanceVar1 $val1
>         set instanceVar2 $val2
>     }

<snip>

Greg:

Just to (hopefully) clarify with my own findings (Forgive me if this is what you were trying to say in your posting) :

I've stepped this through, and what is happening is that the command in the constructor:

variable instanceVar1 instanceVar2

does indeed do what I thought it was supposed to do (but I must have messed up earlier) and both creates instanceVar1 and initializes it to the string "instanceVar2".

I had wondered why it wouldn't get an error on the increment of a non-integer, until I also saw that it is immediately overwritten by the value of $val1, which is an integer.

instanceVar2 in this constructor is thus merely a local variable that is set to $val2 and then disappears when the constructor returns.

et