Domain Specific Languages

show = { println it }
square_root = { Math.sqrt(it) }
def please(action) {
  [the: { what ->
    [of: { n -> action(what(n)) }]
  }]
}
please show the square_root of 100       // please(show).the(square_root).of(100)

def split(String s) {
  [on: { sep ->
    [trimming: { ch -> s.split(sep).collect { it.trim().replaceAll("^${ch}+|${ch}+\$", '') } }]
  }]
}
def parts = split "_a ,_b_ ,c__" on ',' trimming '_'
println parts

10.0
[a, b, c]

import org.codehaus.groovy.ast.expr.*
import org.codehaus.groovy.control.*

def cu = new CompilationUnit()
cu.addSource('t.groovy', "water 'tomatoes' every 2.hours")
cu.compile(Phases.CONVERSION)
def stmt = cu.ast.modules[0].statementBlock.statements[0]

def show
show = { Expression e, int d = 0 ->
    def pad = '  ' * d
    switch (e) {
        case MethodCallExpression:
            println "${pad}MethodCall ${e.methodAsString}"
            println "${pad}  receiver:"; show(e.objectExpression, d + 2)
            println "${pad}  args:"; e.arguments.expressions.each { show(it, d + 2) }; break
        case PropertyExpression:
            println "${pad}Property .${e.propertyAsString}"; show(e.objectExpression, d + 1); break
        case ConstantExpression: println "${pad}Constant ${e.value.inspect()}"; break
        case VariableExpression: println "${pad}Variable ${e.name}"; break
        default: println "${pad}${e.class.simpleName} ${e.text}"
    }
}
show(stmt.expression)

MethodCall every
  receiver:
    MethodCall water
      receiver:
        Variable this
      args:
        Constant 'tomatoes'
  args:
    Property .hours
      Constant 2

import org.codehaus.groovy.control.CompilerConfiguration

abstract class CountingBase extends Script {
    int count
    abstract void scriptBody()                 // the script body becomes this method
    def run() {
        count++                                 // work done before the body
        scriptBody()
        count                                   // the evaluation result is no longer the last expression
    }
}

def shell = new GroovyShell(this.class.classLoader, new CompilerConfiguration(scriptBaseClass: 'CountingBase'))
def result = shell.evaluate("println 'Ok'")
assert result == 1

def script = shell.parse("println 'Ok'")
assert script.run() == 1
assert script.run() == 2                      // the same script instance is run twice

Ok
Ok
Ok

void body(@DelegatesTo(BodySpec) Closure cl) { /* delegate is a BodySpec, default strategy */ }

void body(@DelegatesTo(strategy = Closure.DELEGATE_ONLY, value = BodySpec) Closure cl) { /* DELEGATE_ONLY */ }

import groovy.transform.TypeChecked

class ZoneSpec {
    final String name
    final List<String> lines = []
    ZoneSpec(String name) { this.name = name }

    long hours(int n)   { n * 3600L }
    long minutes(int n) { n * 60L }
    void water(String crop, long every, long lasting) {
        lines << "${crop}: every ${every.intdiv(3600)}h for ${lasting.intdiv(60)}m"
    }
}

class GreenhouseSpec {
    final List<ZoneSpec> zones = []
    void zone(String name,
              @DelegatesTo(value = ZoneSpec, strategy = Closure.DELEGATE_ONLY) Closure body) {
        def spec = new ZoneSpec(name)
        def code = body.rehydrate(spec, this, this)
        code.resolveStrategy = Closure.DELEGATE_ONLY
        code()
        zones << spec
    }
}

GreenhouseSpec greenhouse(@DelegatesTo(value = GreenhouseSpec, strategy = Closure.DELEGATE_ONLY) Closure body) {
    def spec = new GreenhouseSpec()
    def code = body.rehydrate(spec, this, this)
    code.resolveStrategy = Closure.DELEGATE_ONLY
    code()
    spec
}

@TypeChecked
void build() {
    def g = greenhouse {
        zone('north') {
            water 'tomatoes', hours(2), minutes(10)
            water 'peppers', hours(6), minutes(4)
        }
        zone('south') {
            water 'lettuce', hours(24), minutes(15)
        }
    }
    g.zones.each { z -> println "${z.name} -> ${z.lines}" }
}
build()

north -> [tomatoes: every 2h for 10m, peppers: every 6h for 4m]
south -> [lettuce: every 24h for 15m]

import groovy.transform.CompileStatic

class Sprinkler { void spray(String zone) { println "spraying $zone" } }
class Sensor    { int moisture() { 37 } }
class Pump      { void start(int minutes) { println "pump on for $minutes min" } }
class Bed       { String crop; int litres }

// delegate to another parameter
def exec(@DelegatesTo.Target Object target, @DelegatesTo Closure code) {
    code.rehydrate(target, this, this).call()
}

// several closures, several targets
void irrigate(
        @DelegatesTo.Target('sprinkler') sprinkler,
        @DelegatesTo.Target('sensor')    sensor,
        @DelegatesTo.Target('pump')      pump,
        @DelegatesTo(target = 'sprinkler') Closure cl1,
        @DelegatesTo(target = 'sensor')    Closure cl2,
        @DelegatesTo(target = 'pump')      Closure cl3) {
    cl1.rehydrate(sprinkler, this, this).call()
    println "moisture: ${cl2.rehydrate(sensor, this, this).call()}%"
    cl3.rehydrate(pump, this, this).call()
}

// generic type of a parameter
public <T> void configureAll(@DelegatesTo.Target List<T> items,
        @DelegatesTo(strategy = Closure.DELEGATE_FIRST, genericTypeIndex = 0) Closure config) {
    items.each { e ->
        def clone = config.rehydrate(e, this, this)
        clone.resolveStrategy = Closure.DELEGATE_FIRST
        clone.call()
    }
}

// an arbitrary type
class Mapper<T, U> {
    final T value
    Mapper(T value) { this.value = value }
    U map(@DelegatesTo(type = 'T') Closure<U> producer) {
        producer.delegate = value
        producer()
    }
}

@CompileStatic
void typed() {
    exec(new Sprinkler()) { spray 'north' }

    irrigate(new Sprinkler(), new Sensor(), new Pump(),
        { spray 'south' },
        { moisture() },
        { start 5 })

    List<Bed> beds = [new Bed(), new Bed()]
    configureAll(beds) { crop = 'basil'; litres = 4 }
    assert beds.every { it.crop == 'basil' && it.litres == 4 }
    println beds*.crop

    def mapper = new Mapper<String, Integer>('tomatoes')
    assert mapper.map { length() } == 8
    println mapper.map { length() }
}
typed()

spraying north
spraying south
moisture: 37%
pump on for 5 min
[basil, basil]
8

// Span.groovy
import groovy.transform.Immutable

/** A length of time, with the operators a DSL needs. */
@Immutable
class Span implements Comparable<Span> {
    long seconds

    Span plus(Span other)      { new Span(seconds + other.seconds) }
    Span multiply(int times)   { new Span(seconds * times) }
    int compareTo(Span other)  { seconds <=> other.seconds }

    String toString() {
        long h = seconds.intdiv(3600), m = (seconds % 3600).intdiv(60), s = seconds % 60
        [h ? "${h}h" : null, m ? "${m}m" : null, s ? "${s}s" : null].findAll().join(' ') ?: '0s'
    }
}

// SpanCategory.groovy
/** Adds 2.hours, 10.minutes and 3 * span to numbers, but only inside use(SpanCategory) { } */
class SpanCategory {
    static Span getSeconds(Number n) { new Span(n.longValue()) }
    static Span getMinutes(Number n) { new Span(n.longValue() * 60) }
    static Span getHours(Number n)   { new Span(n.longValue() * 3600) }
    static Span getDays(Number n)    { new Span(n.longValue() * 86400) }

    // singular spellings read better after a 1
    static Span getMinute(Number n)  { getMinutes(n) }
    static Span getHour(Number n)    { getHours(n) }
    static Span getDay(Number n)     { getDays(n) }

    static Span multiply(Number n, Span s) { s * n.intValue() }   // 3 * 20.minutes
}

// Schedule.groovy
class WateringRule {
    String crop
    Span every
    Span lasting
    String toString() { "water ${crop} every ${every} for ${lasting}" }
}

class Schedule {
    final List<WateringRule> rules = []
    Schedule leftShift(WateringRule rule) { rules << rule; this }   // schedule << rule
    Span waterTimePerDay() {
        rules.inject(new Span(0)) { acc, r -> acc + r.lasting * (86400L.intdiv(r.every.seconds) as int) }
    }
}

// GreenhouseScript.groovy
abstract class GreenhouseScript extends Script {
    Schedule schedule = new Schedule()

    abstract void scriptBody()                       // the user's script becomes this method

    def run() {
        use(SpanCategory) { scriptBody() }          // 2.hours only works while the script body runs
        schedule
    }

    // water 'tomatoes' every 2.hours lasting 10.minutes
    //   is water('tomatoes').every(2.hours).lasting(10.minutes)
    def water(String crop) {
        def rule = new WateringRule(crop: crop)
        schedule << rule
        [every: { Span interval ->
            rule.every = interval
            [lasting: { Span duration -> rule.lasting = duration; rule }]
        }]
    }
}

// plan.greenhouse
water 'tomatoes' every 2.hours lasting 10.minutes
water 'lettuce' every 1.day lasting 3 * 5.minutes
water 'basil' every 12.hours lasting 90.seconds + 30.seconds

// Run.groovy
import org.codehaus.groovy.control.CompilerConfiguration

def config = new CompilerConfiguration(scriptBaseClass: 'GreenhouseScript')
def shell  = new GroovyShell(this.class.classLoader, config)

def schedule = shell.evaluate(new File('plan.greenhouse'))   // evaluate returns what run() returns
schedule.rules.each { println it }
println "water per day: ${schedule.waterTimePerDay()}"
assert schedule.rules*.crop == ['tomatoes', 'lettuce', 'basil']

// outside the category the number properties do not exist
try {
    2.hours
} catch (MissingPropertyException e) {
    println "outside use(SpanCategory): ${e.message.readLines()[0]}"
}

water tomatoes every 2h for 10m
water lettuce every 24h for 15m
water basil every 12h for 2m
water per day: 2h 19m
outside use(SpanCategory): No such property: hours for class: java.lang.Integer