ScopedValue: Capturing current bindings

[Attila Kelemen]

Let's assume we have a static method like this in `ScopedValue`:

```
public static void withCapturedContext(
    Consumer<? super CapturedScopedValueContext> task
) { ... }
```

where `CapturedScopedValueContext` is defined this way:

```
public interface CapturedScopedValueContext {
  <T> T inContext(Callable<? extends T> task);
}
```

The method `withCapturedContext` captures the current scoped value
bindings, then immediately calls its argument (task) with an instance of
`CapturedScopedValueContex` which will run tasks with the captured scope
value bindings (when calling its `inContext` method). However,
`CapturedScopedValueContext.inContext` validates if the captured scope
value bindings is the same as the current one, or the parent of the current
scoped value bindings, and if it is not, then fails with an ISE.

That is, this could be an unoptimized implementation of
`withCapturedContext` (with the only caveat that currently `runWith`
doesn't have a static variant):

```
public static void withCapturedContext(
    Consumer<? super CapturedScopedValueContext> task
) {
  var capturedBindings = scopedValueBindings();
  task.accept(new CapturedScopedValueContext() {
    @Override
    public <T> T inContext(
        Callable<? extends T> inContextTask
    ) {
      scopedValueBindings().verifyValidContext(capturedBindings);
      return runWith(capturedBindings, inContextTask);
    }
  });
}

static final class Snapshot {
    // ...

    void verifyValidContext(Snapshot checked) {
        for (var current = this; current != null; current = current.prev) {
            if (current == checked) {
                return;
            }
        }
        throw new IllegalStateException("Invalid context.");
    }
}
```

I hope this clarifies what functionality I'm missing.


Andrew Haley <aph-open at littlepinkcloud.com> ezt írta (időpont: 2023. jún.
1., Cs, 15:50):

> On 6/1/23 12:58, Attila Kelemen wrote:
> >> However, any structure that allows a scoped value to live after its
> binding scope has terminated is out of the question because it breaks a
> fundamental invariant.
> > I do not want this at all, and never suggested to have this
> > possibility. In fact, I agree that such access should not be allowed.
>
> I'm sorry, trying to understand what you want is exhausting.
>
> Please provide a concise and precise definition of what your API to
> capture current scoped values would do. I do not need any examples
> of how it might be used, just an operational definition of the
> CapturedScopedValueContext API.
>
> --
> Andrew Haley  (he/him)
> Java Platform Lead Engineer
> Red Hat UK Ltd. <https://www.redhat.com>
> https://keybase.io/andrewhaley
> EAC8 43EB D3EF DB98 CC77 2FAD A5CD 6035 332F A671
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/loom-dev/attachments/20230601/0c8c9f03/attachment.htm>