is there a more clever way to accomplish this? may...

# announcements

[Hullaballoonatic]

is there a more clever way to accomplish this? maybe a way to generalize the behavior (delegation or annotation?), or does such a generalization already exist?
https://pl.kotl.in/Z2joV2hL3

class MyClass(foo: Int, bar: Int) {
    private var fooLock = false
    var foo = foo
    	set(v) {
            fooLock = true
            
            if (!barLock) bar += (v - field)
            field = v
            
            fooLock = false
        }
    
    private var barLock = false
    var bar = bar
    	set(v) {
            barLock = true
            
            if (!fooLock) foo += (v - field)
            field = v
            
            barLock = false
        }
}

[streetsofboston]

I think you could write your own property delegate class for this.

[Hullaballoonatic]

yeah, that was my immediate thought. wanted to make sure one didn't already exist

[mathew murphy]

Should you not use an actual Lock and the withLock extension?

[Hullaballoonatic]

i idid not know that existed

[mathew murphy]

That way you're safe if you want to start using the code in a multithreaded context.

[mathew murphy]

https://winterbe.com/posts/2015/04/30/java8-concurrency-tutorial-synchronized-locks-examples/

[karelpeeters]

I think you should refactor the way you store information, for example:

class MyClass(var foo: Int, bar: Int) {
    val delta = bar - foo
    
    var bar: Int
    	get() = foo + delta
    	set(v) { foo = v - delta }
}

[karelpeeters]

That's a drop-in replacement for your class.

[karelpeeters]

(it took me a while to figure that out because the above code is completely unreadable, it's almost intentionally obfusticated)

[Hullaballoonatic]

the actual shared operation was a placeholder

[Hullaballoonatic]

i could have made that more obvious by passing it as a parameter or something

[karelpeeters]

Are you sure it's impossible to refactor the way you store information in your case? This partial redudancy/dependency is really bad.

[Hullaballoonatic]

In a way, however, I think it's more intuitive the way I wrote it 😮

[karelpeeters]

Well then your opinion is wrong 🙃 . Another alternative would be to check for equality before setting:

class MyClass(foo: Int, bar: Int) {
    var foo = foo
        set(v) {
            if (field != v) {
            	field = v
                bar += (v - field)
            }
        }
    
    var bar = bar
        set(v) {
            if (field != v) {
                field = v
                foo += (v - field)
            }
        }
}

Still ugly and unreadable but it's not as bad.

[Hullaballoonatic]

oh, right, yeah that'd work too in this case

[karelpeeters]

And it's probably easier to generalize in a property delegate.

[Hullaballoonatic]

yeah