Neat trick - 'with' and unnamed objects + 'with' proposals

[Dan]

Bill Baxter Wrote:

> I just discovered this little trick that I think is way cool.
> You can use 'with' in combination with an anonymous object to set 
> attributes on that object without having to bother giving it a name or a 
> variable.
> 
> 
> with(new someGUIWidget(myParent)) {
>     shown = true;
>     focusable = false;
> }

In JavaScript they've had this "feature" for a very long time.  I never, ever use it.  Why?

x = 3;
myFunc = function(){
x = 2;
this.x = 1;
bla bla bla ginger
with(x){
bla bla bla bla ginger
bla bla bla
bla bla
x += 3;
bla bla
}
x -= 2;
}

That in itself isn't so bad.  But in real code, it looks godawful and makes a guy concentrate on scoping it for a second; distracting him from the algorithm.

> That's really nifty for GUI code.
> 
> This could be even more useful if there were some kind of 'this' for 
> 'with' blocks.  Then you could also call non-member functions.

Lions and tigers and bears, oh my.  Can't you just:

alias supercalafragilisticexpialadocious.bob.mom.mom.niece.daughter d;

d.shown = true;
d.focusable = false;
etc.?

> with(new someGUIWidget(myParent)) {
>     shown = true;
>     focusable = false;
>     some_global_function(this);
> }
> 
> Or perhaps analogous to how constructors are called 'this()' and have a 
> 'this' pointer, we'd have a 'with' pointer so that the meaning of 'this' 
> in a class wouldn't be shadowed:
> 
> with(new someGUIWidget(myParent)) {
>     some_global_function(with);
> }

Eww... ambiguity and context sensitivity.

> And even cooler would be if you could have a 'with-expression' that just 
> evaluates to the thing in the parens:
> 
> auto obj = with(new someGUIWidget(myParent))
> {
>     shown = true;
>     focusable = false;
>     some_global_function(this);
> };

auto obj = new someGuiWidget(myParent){
  shown = true;
  focusable = false;
};
some_global_function(obj); <- can't execute in a class declaration.  Try in the constructor?

> 
> Sometimes I've seen people try to make APIs in C++ where all the 
> attribute setters return the object so that property setting can be 
> chained, like:
> 
>       myObject.set_focusable(true).set_shown(true);

I did that back in the day too, but not for setting properties, it was for performing more complex algorithms with the DOM, such as making an object move in circles, or fall using a gravity formula.

> Presumably the objective is to avoid repeating the name of the object a 
> lot.  But that never works out too well, because making every mutator 
> return a pointer to 'this' is just not so practical in the end, and 
> forcing every property setting operation to use function call syntax is 
> also not so great.

Property setting operations?  Totally agree.  Returning a this* isn't so bad unless you have something else to return.  I only did it with subroutines.

The real reason it's bad is because you're masturbating the stack doing calls like that just to avoid doing something in source code.  Such a thing is forgiveable in web scripts where filesize matters, it's not in programming.