Records & Sealed Types

record Message(String from, String to, String body) {}

def msg = new Message('greenhouse', 'owner', 'Soil is dry')
assert msg.toString() == 'Message[from=greenhouse, to=owner, body=Soil is dry]'

import java.time.Instant

record Reading(String sensorId, Instant at, double temperature, double humidity, double soil) {
    // compact constructor: no parameter list, runs before the fields are assigned
    Reading {
        if (humidity < 0 || humidity > 100) {
            throw new IllegalArgumentException("humidity out of range: $humidity")
        }
        sensorId = sensorId.trim().toUpperCase()     // reassigning a parameter changes the stored value
    }

    boolean isDry() { soil < 20 }                      // extra instance method
    static Reading of(String id, double t) {           // static factory
        new Reading(id, Instant.parse('2026-10-14T06:00:00Z'), t, 50, 30)
    }
}

def noon = Instant.parse('2026-10-14T06:00:00Z')
def r = new Reading(' a1 ', noon, 21.5, 60, 15)
println r
println r.sensorId() + ' ' + r.sensorId                // accessor method and property syntax
println r.dry
println Reading.of('b2', 18)
println r == new Reading('A1', noon, 21.5, 60, 15)
println Reading.isRecord()
println Reading.superclass.name
println Reading.recordComponents*.name
try { new Reading('x', noon, 1, 120, 1) } catch (IllegalArgumentException e) { println e.message }
try { r.temperature = 3 } catch (ReadOnlyPropertyException e) { println e.message }
println new Reading(sensorId: 'n1', at: noon, temperature: 1, humidity: 2, soil: 3)

Reading[sensorId=A1, at=2026-10-14T06:00:00Z, temperature=21.5, humidity=60.0, soil=15.0]
A1 A1
true
Reading[sensorId=B2, at=2026-10-14T06:00:00Z, temperature=18.0, humidity=50.0, soil=30.0]
true
true
java.lang.Record
[sensorId, at, temperature, humidity, soil]
humidity out of range: 120.0
Cannot set read-only property: temperature for class: Reading
Reading[sensorId=N1, at=2026-10-14T06:00:00Z, temperature=1.0, humidity=2.0, soil=3.0]

record Sample(String zone, double value, String unit) {}
def s = new Sample('north', 21.5, 'C')

println s.toList()
println s.toMap()
println s.size()
println s[1] + ' ' + s.getAt(2)
def (zone, value, unit) = s
println "$zone $value $unit"

[north, 21.5, C]
[zone:north, value:21.5, unit:C]
3
21.5 C
north 21.5 C

sealed interface Zone permits Bench, HangingBasket, Bed {}
record Bench(String id, int slots) implements Zone {}
record HangingBasket(String id, double heightCm) implements Zone {}
non-sealed class Bed implements Zone { String id = 'bed-1' }
class RaisedBed extends Bed {}                     // allowed: Bed is non-sealed

println Zone.sealed
println Zone.permittedSubclasses*.simpleName
println Bench.sealed

String describe(Zone z) {
    switch (z) {
        case Bench         -> "bench with ${z.slots()} slots"
        case HangingBasket -> "basket at ${z.heightCm()} cm"
        case Bed           -> "bed ${z.id}"
    }
}
println describe(new Bench('b1', 6))
println describe(new HangingBasket('h1', 180))
println describe(new RaisedBed())

true
[Bench, HangingBasket, Bed]
false
bench with 6 slots
basket at 180.0 cm
bed bed-1

import groovy.transform.Sealed
import groovy.transform.NonSealed

@Sealed(permittedSubclasses = [Cat, Dog])
interface Pet {}
final class Cat implements Pet {}
final class Dog implements Pet {}
println Pet.sealed
println Pet.permittedSubclasses*.simpleName

sealed class Shape permits Circle, Polygon {}
final class Circle extends Shape {}
sealed class Polygon extends Shape permits Square {}
final class Square extends Polygon {}
println Shape.permittedSubclasses*.simpleName
println Polygon.permittedSubclasses*.simpleName

sealed trait Msg permits Ping, Pong {}
final class Ping implements Msg {}
final class Pong implements Msg {}
println Msg.sealed

sealed interface Expr {}                           // no permits: same-file subclasses are inferred
record Const(int i) implements Expr {}
record Plus(Expr l, Expr r) implements Expr {}
record Neg(Expr e) implements Expr {}
println Expr.permittedSubclasses*.simpleName

true
[Cat, Dog]
[Circle, Polygon]
[Square]
true
[Const, Plus, Neg]

sealed interface Expr {}
record Const(int i) implements Expr {}
record Plus(Expr l, Expr r) implements Expr {}
record Neg(Expr e) implements Expr {}

int eval(Expr e) {
    switch (e) {
        case Const -> e.i()
        case Plus  -> eval(e.l()) + eval(e.r())
        case Neg   -> -eval(e.e())
    }
}
println eval(new Plus(new Const(3), new Neg(new Const(1))))
println new Plus(new Const(3), new Neg(new Const(1)))

2
Plus[l=Const[i=3], r=Neg[e=Const[i=1]]]