[External] : ComputedConstant: rename to Lazy?

[-]

Thank you for this clarification.

The main reason that I considered the "Lazy" name is that "Constant" as a
term isn't well-defined in our API specification: simply put, it's like a
final with lazy semantics like described in John Rose's JEP draft [1]
(which also seems to consider Leyden's development and overlaps partially
with CC proposal), where it can be optimized (constant fold) like final
(static or non-static with -XX:+TrustFinalNonStaticFields) fields. Can we
emphasize such a "final" nature without confusing it with actual constants?

In addition, in what case can the computation of a CC start before VM
startup? I cannot think of any example and would like to know one.

Chen

[1] https://openjdk.org/jeps/8209964

On Fri, Sep 1, 2023 at 2:27 PM Per-Ake Minborg <per-ake.minborg at oracle.com>
wrote:

> Hi Chen,
>
> In the beginning, we used Lazy but it became apparent that CCs are more
> than that. In fact, computation might occur even BEFORE the JVM starts and
> then the name Lazy becomes confusing. It is all but lazy in this case.
>
> So, we arrived at the more general name ComputedConstant. It does not
> carry any indication as to when the constant is computed.
>
> Best, Per
> ------------------------------
> *From:* liangchenblue at gmail.com <liangchenblue at gmail.com>
> *Sent:* Friday, September 1, 2023 6:59 AM
> *To:* leyden-dev at openjdk.org <leyden-dev at openjdk.org>; Per-Ake Minborg <
> per-ake.minborg at oracle.com>
> *Subject:* [External] : ComputedConstant: rename to Lazy?
>
> Hello,
> I noticed that ComputedConstant, in addition to ensuring constant-folding
> of lazy values, is a general-purpose lazy wrapper, and can be used even
> outside of constant-folding scenarios to offer thread safety and error
> handling in lazy computations.
>
> Thus, I recommend renaming it into Lazy, or some other name more simple
> and concise than ComputedConstant, to the ease of users.
>
> A similar scenario exists in JDK already: List.of() factory wraps an array
> with stable annotation, thereby offering constant-folded arrays/lists
> that's faster to iterate (random access via List.get() in an index loop,
> not using iterators) by index compared to a plain array when both are
> stored in static final fields. However, we are not calling such a factory
> list a "Constant List," but simply an immutable list.
>
> This proposal only changes the name of CC; it will not affect the
> specification (thread safety, error handling, constant-foldability) in any
> way, and it does not propose to change the method names.
>
> Best,
> Chen Liang
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/leyden-dev/attachments/20230901/85240ff2/attachment.htm>