Operator Overloading

class Volume {
    final int litres
    Volume(int litres) { this.litres = litres }
    Volume plus(Volume other) { new Volume(litres + other.litres) }
    Volume plus(int extra)    { new Volume(litres + extra) }
    String toString() { "${litres}L" }
}
def a = new Volume(10)
def b = new Volume(4)
assert (a + b).litres == 14
assert (a + 5).litres == 15
println "${a + b} and ${a + 5}"
try { println(5 + a) } catch (e) { println "5 + a -> ${e.class.simpleName}" }

14L and 15L
5 + a -> MissingMethodException

class Volume {
    final int litres
    Volume(int litres) { this.litres = litres }
    Volume plus(int extra) { new Volume(litres + extra) }
    String toString() { "${litres}L" }
}
class VolumeCategory { static Volume plus(Integer n, Volume v) { v + n } }
def v = new Volume(10)
use(VolumeCategory) { println(5 + v) }

15L

class Volume implements Comparable<Volume> {
    final int litres
    Volume(int litres) { this.litres = litres }
    Volume plus(Volume o)   { new Volume(litres + o.litres) }
    Volume plus(int n)      { new Volume(litres + n) }
    Volume minus(Volume o)  { new Volume(litres - o.litres) }
    Volume multiply(int n)  { new Volume(litres * n) }
    Volume div(int n)       { new Volume(litres.intdiv(n)) }
    Volume remainder(int n) { new Volume(litres % n) }
    Volume power(int n)     { new Volume((litres ** n) as int) }
    Volume negative()       { new Volume(-litres) }
    Volume positive()       { this }
    Volume next()           { new Volume(litres + 1) }
    Volume previous()       { new Volume(litres - 1) }
    Volume leftShift(int n) { new Volume(litres << n) }
    Volume rightShift(int n){ new Volume(litres >> n) }
    Volume or(Volume o)     { new Volume(litres | o.litres) }
    Volume and(Volume o)    { new Volume(litres & o.litres) }
    Volume xor(Volume o)    { new Volume(litres ^ o.litres) }
    Volume bitwiseNegate()  { new Volume(~litres & 0xFF) }
    int compareTo(Volume o) { litres <=> o.litres }
    boolean equals(Object o) { o instanceof Volume && litres == o.litres }
    int hashCode() { litres }
    String toString() { "${litres}L" }
}
def a = new Volume(10), b = new Volume(4)
assert a + b == new Volume(14)
assert a + 5 == new Volume(15)
assert a - b == new Volume(6)
assert a * 3 == new Volume(30)
assert a / 3 == new Volume(3)
assert a % 3 == new Volume(1)
assert a ** 2 == new Volume(100)
assert -a == new Volume(-10) && +a === a
assert a++ == new Volume(10)        // postfix: the old value, then a = a.next()
assert a == new Volume(11)
assert --a == new Volume(10)
assert a << 1 == new Volume(20) && a >> 1 == new Volume(5)
assert (a | b) == new Volume(14) && (a & b) == new Volume(0) && (a ^ b) == new Volume(14)
assert ~a == new Volume(245)
// comparison operators come from compareTo
assert a > b && b < a && a >= a && a <= a && a != b
assert (a <=> b) == 1
assert [a, b].max() == a
println "${a + b}, ${a - b}, ${-a}, ${~a}"

14L, 6L, -10L, 245L

class Greenhouse {
    private final Map<String, BigDecimal> temps = [:]
    BigDecimal getAt(String zone) { temps[zone] }
    void putAt(String zone, BigDecimal value) { temps[zone] = value }
    boolean isCase(Object x) { x in temps.values() }    // used by `in` and switch
    Object asType(Class c) { c == List ? temps.keySet().sort() : super.asType(c) }
    String call(String zone) { "zone $zone: ${temps[zone]}" }
}
def g = new Greenhouse()
g['north'] = 21.5
g['south'] = 24.0
assert g['north'] == 21.5
assert 24.0 in g
assert !(30.0 in g)
assert (g as List) == ['north', 'south']
assert g('south') == 'zone south: 24.0'
switch (21.5) { case g: println 'a zone is at 21.5'; break; default: println 'no match' }
println g('north')

class Grid {
    def data = [:]
    def getAt(int row, int col) { data[[row, col]] }
    void putAt(List idx, v) { data[idx] = v }
    def getAt(List idx) { data[idx] }
}
def grid = new Grid()
grid[[1, 2]] = 'basil'
println grid[1, 2]
println grid[[1, 2]]

a zone is at 21.5
zone north: 21.5
basil
basil

class V implements Comparable<V> { int n; int compareTo(V o) { n <=> o.n } }
println(new V(n: 1) == new V(n: 1))      // no equals(): uses compareTo
class W { int n; boolean equals(o) { true } }
println(new W(n: 1) == new W(n: 2))      // only equals(): used as is
class OnlyMod { def mod(x) { 'mod' } }
class OnlyRem { def remainder(x) { 'remainder' } }
try { println(new OnlyMod() % 1) } catch (e) { println "OnlyMod: ${e.class.simpleName}" }
println(new OnlyRem() % 1)

true
true
OnlyMod: MissingMethodException
remainder

class WaterLog {
    List<Integer> entries = []
    int total = 0
    void plusAssign(int litres) { entries << litres; total += litres }   // mutates in place
    WaterLog plus(int litres) { new WaterLog(entries: entries + litres, total: total + litres) }
}
def log = new WaterLog()
def same = log
log += 5
log += 7
assert log.is(same)                 // no reassignment: still the same object
assert log.total == 12 && log.entries == [5, 7]
def r = (log += 1)
assert r.is(log)                    // value of the expression is the mutated receiver
println "total = ${log.total}"

// without plusAssign the old desugaring x = x.plus(y) still applies
class Plain { int n; Plain plus(int k) { new Plain(n: n + k) } }
def p = new Plain(n: 1); def p0 = p
p += 2
assert p.n == 3 && !p.is(p0)
println "plain: new object = ${!p.is(p0)}"

total = 13
plain: new object = true

import groovy.transform.OperatorRename

// pretend this class comes from a library that does not follow Groovy's names
class Fraction {
    final int num, den
    Fraction(int n, int d) { num = n; den = d }
    Fraction add(Fraction o) { new Fraction(num * o.den + o.num * den, den * o.den) }
    Fraction sub(Fraction o) { new Fraction(num * o.den - o.num * den, den * o.den) }
    boolean equals(Object o) { o instanceof Fraction && num * o.den == o.num * den }
    int hashCode() { 1 }
    String toString() { "$num/$den" }
}

@OperatorRename(plus = 'add', minus = 'sub')
def mix() {
    def half = new Fraction(1, 2)
    def third = new Fraction(1, 3)
    assert half + third == new Fraction(5, 6)
    assert half - third == new Fraction(1, 6)
    assert half.add(third) == half + third      // the old name still works
    "${half + third}"
}
println mix()

try {
    evaluate '''
        def h = new Fraction(1, 2)
        h + h
    '''
} catch (e) { println "outside the annotation: ${e.class.simpleName}" }

5/6
outside the annotation: MissingMethodException

class Sensor { boolean ok; boolean asBoolean() { ok } }
assert !new Sensor(ok: false)
assert new Sensor(ok: true)
assert true.implies(false) == false
assert false.implies(true)
class Cond { def implies(x) { 'custom' } }
def c = new Cond()
println(c.implies(1))
println(c ==> true)

custom
true