Optionality: Parentheses, Semicolons, return & public

def add(a, b) { a + b }
def label(String s) { "<${s}>" }
def twice(Closure c) { c(); c() }

println 'optional parentheses'          // one argument
println add(1, 2)                       // parentheses kept for a nested call
def total = add 3, 4                    // two arguments, no parentheses
println total
twice { print 'tick;' }                 // closure as the only argument
println()
println label('a').toUpperCase()        // chained calls need parentheses
println "${label 'b'}"                  // a command expression inside a placeholder

def water(String plant) { [every: { Integer h -> "water ${plant} every ${h}h" }] }
def plan = water 'tomatoes' every 2     // command chain: water('tomatoes').every(2)
println plan

optional parentheses
3
7
tick;tick;
<A>
<b>
water tomatoes every 2h

def attempts = [
    'nested command expression':  'println add 1, 2',
    'no-argument call':           'def f() { 1 }; def g = f',
    'literal receiver':           'println [1, 2].collect { it * 2 }',
    'method name as argument':    'def l = [3, 1]; l.each println',
    'condition in assert':        'assert add 1, 2 == 3',
    'property is not a call':     "def s = 'a'; s.toUpperCase",
    'parentheses used':           'println(add 1, 2)',
]
attempts.each { name, code ->
    try {
        new GroovyShell(new Binding()).evaluate("def add(a, b) { a + b }\n" + code)
        println "${name}: ok"
    } catch (Throwable e) {
        println "${name}: ${e.class.simpleName}: ${e.message.readLines()[0]}"
    }
}

nested command expression: MissingPropertyException: No such property: println for class: Script1
no-argument call: MissingPropertyException: No such property: f for class: Script1
literal receiver: MissingPropertyException: No such property: println for class: Script1
method name as argument: MissingPropertyException: No such property: println for class: Script1
condition in assert: MultipleCompilationErrorsException: startup failed:
property is not a call: MissingPropertyException: No such property: toUpperCase for class: java.lang.String
3
parentheses used: ok

def a = 1; def b = 2          // two statements on one line need the semicolon
println a + b

def sum = a +
    b                          // operator at the end of the line: statement continues
println sum

def broken = a
    + b                        // operator at the start of the next line: a new statement
println broken

def wrapped = (a
    + b)                       // inside parentheses newlines are ignored
println wrapped

def chain = [3, 1, 2]
    .sort()                    // a leading dot continues the expression
    .reverse()
println chain

3
3
1
3
[3, 2, 1]

def implicit() { 42 }
int explicit() { return 42 }
println implicit() + explicit()

def lastIf(boolean b) { if (b) 'yes' else 'no' }
println lastIf(true) + lastIf(false)

def ifNoElse(boolean b) { if (b) 'yes' }
println ifNoElse(false)                     // no else branch: null

def lastTry() { try { 'ok' } finally { 'ignored' } }
println lastTry()

def lastSwitch(x) { switch (x) { case 1: 'one'; break; default: 'other' } }
println lastSwitch(1) + lastSwitch(2)

def assignLast() { def x = 5 }
println assignLast()                        // an assignment is an expression

def loopLast() { for (i in 1..3) { i } }
println loopLast()                          // a loop has no value

def voidLike() { println 'side effect' }
println voidLike()                          // println returns null

void v() { 'x' }
println v()

def closureLast = { a, b -> a * b }
println closureLast(3, 4)

def firstEven(list) {
    for (n in list) {
        if (n % 2 == 0) return n            // early return
    }
    null
}
println firstEven([1, 3, 4, 6])

84
yesno
null
ok
oneother
5
null
side effect
null
null
12
4

import java.lang.reflect.Modifier

class Zone {
    String name                // property: private field plus public getter and setter
    public int exposed = 2     // public field: no accessors generated
    private int secret = 1
    String hello() { 'hi' }    // public by default
    private String hidden() { 'private but callable' }
}

def z = new Zone(name: 'bench')
println z.hello()
println z.hidden()             // Groovy does not enforce private
println z.secret

println Modifier.isPublic(Zone.getDeclaredMethod('hello').modifiers)
println Modifier.isPrivate(Zone.getDeclaredField('name').modifiers)
println Modifier.isPublic(Zone.getDeclaredField('exposed').modifiers)
println Zone.declaredMethods*.name.findAll { it.endsWith('Name') }.sort()

hi
private but callable
1
true
true
true
[getName, setName]

// relaxed style
class Bench {
    String name
    List<Integer> temps = []

    def record(int t) { temps << t; this }
    def average() { temps ? temps.sum() / temps.size() : 0 }
}

def bench = new Bench(name: 'north')
bench.record 20
bench.record 24
println bench.average()

// explicit style
public class Bench2 {
    private String name;
    private List<Integer> temps = new ArrayList<Integer>();

    public Bench2 record(int t) { temps.add(t); return this; }
    public Object average() { return temps.size() > 0 ? (Object) (temps.sum() / temps.size()) : 0; }
}

Bench2 other = new Bench2();
other.record(20);
other.record(24);
System.out.println(other.average());

22
22