12 replies to this topic

[HotKeyIt]

Currently this is not possible because base is set before initialization of _base.
It would be great if the keys would be set before base is assigned.

What do you think?

obj:= new _NotifyChange
Class _NotifyChange {
	_base := {}
	__Get(key){
		return this._base[key]
	}
	__Set(key,val){
		this._base[key] := val*2
		Return
	}
}

[Lexikos]

It's debatable whether the script would want the meta-functions to be skipped. If it really does, it can bypass __Set explicitly:

obj:= new _NotifyChange
Class _NotifyChange {
   [color=red]__New() {
      ObjInsert(this, "_base", {})
   }[/color]
   __Get(key){
      return this._base[key]
   }
   __Set(key,val){
      this._base[key] := val*2
      Return
   }
}

Btw,

Set: If the operation was successful, __Set should return the new value of the field, which may differ from the original r-value. This allows assignments to be chained, as in a.x := b.y := z. An empty string should be returned if the assignment failed, allowing the script to detect the error.

It also makes the code shorter.

__Set(key,val){
      [color=red]return [/color]this._base[key] := val*2
   }

[HotKeyIt]

:oops: forgot about ObjInsert, that is good enough
Thanks also for note about return, will consider it next time

[just me]

It's debatable whether the script would want the meta-functions to be skipped.

It's not debatable, it shouldn't!

[HotKeyIt]

It's not debatable, it shouldn't!

Possibly we could use local for that, would be great, I think?

Class _NotifyChange {

  [color=red]local _base:={}[/color]

   __Get(key){

      return this._base[key]

   }

   __Set(key,val){

      Return this._base[key] := val*2

   }

}

[Lexikos]

No. "Local" is used for variable scope. This has nothing to do with scope. The need to bypass the meta-functions should be rare and the current workaround is simple. We don't need a new language element for it.

[just me]

@Lexikos:

I'd be glad for a "real world" example, where __Set and __Get methods are provided for class or instance variables?

[fragman]

I have one. I needed to call some functions automatically before the constructor of a class that derives from a base class was called. I used an instance variable in the base class and changed it's set method so that it would not actually set the key. This makes it possible to create base classes which can make sure that their constructor is always called.

[just me]

@fragman:

Would you please post it?

[fragman]

See here: <!-- m -->https://github.com/C... ... b/CGUI.ahk<!-- m --> (line 49)

It's used to make sure that the constructor of this class is always called when a class that extends this class is created. The __Set function ignores this specific key so nothing will be stored.

[just me]

Sorry for causing confusion, but

It's not debatable, it shouldn't!

should be

..., it shouldn't invoke them!

At time of initialization everything is under control and can be done without the need to invoke the __Set() / __Get() metafunctions. So it makes more sense for me to call the meta-functions only after the initialization part is done.

@fragman:
Probably I'm missing something, but I don't understand why you do what you do with the _Constructor variable.

[fragman]

The variable itself is never assigned. I use it as a means to call the constructor of the CGUI class before the constructor of other classes that extend CGUI is called. I use __Set in CGUI to make sure that no key gets assigned to _Constructor.

[Lexikos]

just me: I disagree, therefore it is debatable. To not invoke them would be inconsistent with every other assignment. It would also require complicating the design.