Thanks for the reply. So if I use an AutoCloseable, I would have something like:
class Foo { private state def bar() { def temp = state state = newState try ({ -> state = temp } as AutoCloseable) { // or rewrite this line using withCloseable baz() } } } In my case, Foo is something that visits the elements of a tree or list. I don't want to create a new instance to visit each element. bar represents a method that advances to the next element and baz (maybe from super type) processes the next element set in "state". state is a field or property so I am expecting the assignments to live inside the bar method's scope. My goal is to eliminate repetitious typing of assigning the current value to a temporary variable, assigning the next value to the field and at the end restoring the previous value. From: Leo Gertsenshteyn <leo...@gmail.com> Sent: Saturday, November 21, 2020 5:34 PM To: dev@groovy.apache.org Subject: Re: Alternatives to try/finally code structure Hi Eric, Am I correctly interpreting that baz() in the above examples calls into 3rd party code and that code has direct reference to the state and controls the state variables' lifecycle? If that's not the case, there may much much simpler solutions involving intermediate objects, recursion, etc., but I will assume those are not available to you. In that case, these look like scenarios for which Java's "try-with-resources" was meant to reduce verbosity. It allows a try block to take objects that implement the AutoCloseable interface and it will call their "close()" methods at the end of the block -- no "finally" needed. In Groovy, we can leverage that with ".withCloseable { ... }" closure blocks. Here's an example script: class Foo implements AutoCloseable { Foo { // set up state as needed println("Opened a Foo!") } @Override void close() throws Exception { // tear down state as needed println("Closed a Foo!") } } def main() { new Foo().withCloseable { // baz() println("Hello!") } } main() Cheers, Leo On Sat, Nov 21, 2020 at 11:29 AM Milles, Eric (TR Technology) <eric.mil...@thomsonreuters.com<mailto:eric.mil...@thomsonreuters.com>> wrote: Groovy Devs, I have been pondering how to automate the writing of try/finally blocks used to unconditionally restore object state. Does anyone know of a Groovier way to do something like this before I pursue a macro method, an AST transformation, or something more involved? It currently requires a lot of typing to do this. Scenario 1: stack-ify a scalar field/property -- often used when traversing a list or tree and "state" is the current element class Foo { private state def bar() { def temp = state // may be any number of fields saved to temp vars state = newState try { baz() } finally { state = temp } } def baz() { // make use of state; does not require previous values } } Scenario 2: mutation rollback -- similar but "state" is not written to beforehand class Foo { private state def bar() { def temp = state // may be any number of fields saved to temp vars try { baz() } finally { state = temp } } def baz() { // modifies state } } Note: "state" is not always convertible into a java.util.Stack. Sometimes this is 3rd-party code that is being extended. I was thinking of something like this so as not to overload the try keyword: class Foo { def bar() { push (field1 = value, field2) { // AST would be re-written to try/finally like Scenario 1/2 baz() } } ... } This e-mail is for the sole use of the intended recipient and contains information that may be privileged and/or confidential. If you are not an intended recipient, please notify the sender by return e-mail and delete this e-mail and any attachments. Certain required legal entity disclosures can be accessed on our website: https://www.thomsonreuters.com/en/resources/disclosures.html