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
        }
}

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

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

Should you not use an actual Lock and the

withLock

extension?

i idid not know that existed

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

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 }
}

the actual shared operation was a placeholder

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

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

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.

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

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

yeah