[
https://issues.apache.org/jira/browse/GROOVY-11525?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17902337#comment-17902337
]
Jochen Theodorou commented on GROOVY-11525:
-------------------------------------------
[~daniel_sun] with init as well?
{code:Java}
int hash(Object key) {
// h is only visible in the expression
return (key == null) ? 0 : (int h = key.hashCode(); h ^ (h >>> 16))
}
int hash(Object key) {
// h is only visible in the expression
return (key == null) ? 0 : (int h = key.hashCode() -> h ^ (h >>> 16))
}
{code}
I am partial about the syntax. First of all the second variant is the one I
like more visually, but it is very near a lambda expression. That worries me a
bit. The first one.. well
{code:Java}
for (int i=0; i<10; i++) {
}
{code}
Is also very near, but comparable to the lambda expression your variant is an
eager evaluation while this one is.. well is it more like lazy. And it looks
really similar as well. Which reminds me. Is it valid here?
{code:Java}
foo (int h=1; h) {return h}
{code}
It should not, right...
> Support expression scope variable
> ---------------------------------
>
> Key: GROOVY-11525
> URL: https://issues.apache.org/jira/browse/GROOVY-11525
> Project: Groovy
> Issue Type: New Feature
> Reporter: Daniel Sun
> Priority: Major
>
> Let's take a look at the following code first:
> {code}
> int hash(Object key) {
> int h;
> return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
> }
> {code}
> variable {{h}} is actually an expression scope variable, but current syntax
> doesn't support.
> I propose an expression scope variable syntax, e.g.
> Proposed syntax 1:
> {code}
> // Just support declaring variables of same type
> (int h, x, y; ...)
> {code}
> {code}
> int hash(Object key) {
> // h is only visible in the expression
> return (int h; (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16))
> }
> {code}
> We can reduce the scope of {{h}} further:
> {code}
> int hash(Object key) {
> // h is only visible in the expression
> return (key == null) ? 0 : (int h; (h = key.hashCode()) ^ (h >>> 16))
> }
> {code}
> Proposed syntax 2(I prefer the syntax):
> {code}
> // Support declaring variables of different types
> (int h, X x, Y y -> ...)
> {code}
> {code}
> int hash(Object key) {
> // h is only visible in the expression
> return (int h -> (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16))
> }
> {code}
> {code}
> int hash(Object key) {
> // h is only visible in the expression
> return (key == null) ? 0 : (int h -> (h = key.hashCode()) ^ (h >>> 16))
> }
> {code}
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
