Functional Programming

def volume = { double rate, int minutes, String plant -> "${plant}: ${rate * minutes} L" }
def at2 = volume.curry(2.0d)
def at2for10 = at2.curry(10)
println at2for10('tomatoes')
println volume.rcurry('basil')(1.5d, 4)
println volume.ncurry(1, 5)(0.5d, 'mint')       // fix the parameter at index 1
println volume.curry(2.0d, 10, 'x').maximumNumberOfParameters
println at2.parameterTypes*.simpleName

def adder = { a, b -> a + b }
println adder.curry(10)(5)
// closures are not auto-curried
try { adder.curry(1)() } catch (e) { println e.class.simpleName }

tomatoes: 20.0 L
basil: 6.0 L
mint: 2.5 L
0
[int, String]
15
MissingMethodException

import groovy.transform.Memoized
int calls = 0
def slow = { int n -> calls++; n * n }
def fast = slow.memoize()
[3, 3, 4, 3].each { fast(it) }
println "calls: $calls"
calls = 0
def bounded = slow.memoizeAtMost(2)
[1, 2, 3, 1, 1].each { bounded(it) }
println "memoizeAtMost(2) calls: $calls"
calls = 0
def between = slow.memoizeBetween(1, 2)
[1, 2, 3, 1].each { between(it) }
println "memoizeBetween(1,2) calls: $calls"
calls = 0
def atMost0 = slow.memoizeAtLeast(1)
[5,5,5].each { atMost0(it) }
println "memoizeAtLeast(1) calls: $calls"

class Sensor {
    static int reads = 0
    @Memoized(maxCacheSize = 10)
    double calibrated(int id) { reads++; id * 1.5 }
    @Memoized
    String banner() { reads++; 'sensor' }
}
def s = new Sensor()
3.times { s.calibrated(1) }
s.calibrated(2); s.banner(); s.banner()
println "reads: ${Sensor.reads}"

def fib
fib = { long n -> n < 2 ? n : fib(n - 1) + fib(n - 2) }.memoize()
println fib(80)

calls: 2
memoizeAtMost(2) calls: 4
memoizeBetween(1,2) calls: 4
memoizeAtLeast(1) calls: 1
reads: 3
23416728348467685

def celsius = { double f -> (f - 32) / 1.8 }
def round1  = { double d -> Math.round(d * 10) / 10.0 }
def label   = { it -> "${it} C" }

def pipeline = celsius >> round1 >> label        // label(round1(celsius(x)))
println pipeline(98.6d)
def reversed = label << round1 << celsius        // the same chain written right to left
println reversed(98.6d)

def up = String.&toUpperCase
def exclaim = { it + '!' }
def shout = up >> exclaim
println shout('ok')
println pipeline.maximumNumberOfParameters

37 C
37 C
OK!
1

import groovy.transform.TailRecursive
def sumTo
sumTo = { long n, long acc = 0 -> n == 0 ? acc : sumTo.trampoline(n - 1, acc + n) }.trampoline()
println sumTo(100000)

def deep
deep = { long n -> n == 0 ? 0L : 1L + deep(n - 1) }
try { deep(200000) } catch (StackOverflowError e) { println 'StackOverflowError' }

class Counter {
    @TailRecursive
    long countdown(long n, long acc = 0) {
        n == 0 ? acc : countdown(n - 1, acc + 1)
    }
    @TailRecursive
    static BigInteger factorial(int n, BigInteger acc = 1G) {
        n <= 1 ? acc : factorial(n - 1, acc * n)
    }
}
println new Counter().countdown(500000)
println Counter.factorial(25)

5000050000
StackOverflowError
500000
15511210043330985984000000

import java.util.function.*
import java.util.stream.*

class Zone { String id; double temp }
String describe(Zone z) { "${z.id}=${z.temp}" }
def z = new Zone(id: 'bench', temp: 21.5)

def ptr = this.&describe                 // method pointer to a script method
println ptr(z)
println ptr.class.simpleName
def up = 'hello'.&toUpperCase            // bound to an instance
println up()
def max = Math.&max                      // static method
println max(3, 9)
println([1, 5, 3].collect(Integer.&toBinaryString))
def len = String.&length                 // unbound: the receiver is the first argument
println len('abcd')
println(['a', 'bb', 'ccc'].collect(String::length))   // method reference operator
def create = Zone::new                   // constructor reference
println create().class.simpleName

Function<Integer, Integer> twice = { it * 2 }
Predicate<String> empty = { it.isEmpty() }
BiFunction<Integer, Integer, Integer> add = { a, b -> a + b }
Supplier<String> now = { 'tick' }
UnaryOperator<String> shout = { it.toUpperCase() }
println twice.apply(4)
println empty.negate().test('x')
println add.andThen(twice).apply(1, 2)
println now.get()
println shout.apply('x')
println IntStream.rangeClosed(1, 5).map { it * it }.sum()
println Stream.of('a', 'bb', 'ccc').filter { it.size() > 1 }.map { it.toUpperCase() }.collect(Collectors.toList())
Comparator<Zone> byTemp = { a, b -> a.temp <=> b.temp }
println([new Zone(id: 'b', temp: 30), z].toSorted(byTemp)*.id)

bench=21.5
MethodClosure
HELLO
9
[1, 101, 11]
4
[1, 2, 3]
Zone
8
true
6
tick
X
55
[BB, CCC]
[bench, b]

import groovy.transform.*

@Immutable(copyWith = true)
class Reading {
    String sensor
    double temp
    List<String> tags
}
def r = new Reading('s1', 20.5, ['a'])
try { r.temp = 3 } catch (ReadOnlyPropertyException e) { println e.message }
try { r.tags << 'b' } catch (UnsupportedOperationException e) { println 'tags: UnsupportedOperationException' }
def r2 = r.copyWith(temp: 25.0d)
println r2
println r

def list = [1, 2, 3].asImmutable()
try { list << 4 } catch (UnsupportedOperationException e) { println 'list is read-only' }

@RecordOptions(copyWith = true)
record Point(int x, int y) {}
println new Point(1, 2).copyWith(y: 5)

Cannot set read-only property: temp for class: Reading
tags: UnsupportedOperationException
Reading(s1, 25.0, [a])
Reading(s1, 20.5, [a])
list is read-only
Point[x=1, y=5]

def result = DO(a in Optional.of(2), b in Optional.of(3)) { Optional.of(a + b) }
println result
def chained = DO(a in Optional.of(10), b in Optional.of(a * 2)) { Optional.of(a + b) }
println chained
def none = DO(a in Optional.empty(), b in Optional.of(3)) { Optional.of(b) }
println none
import java.util.stream.Stream
def pairs = DO(x in Stream.of(1, 2), y in Stream.of('a', 'b')) { Stream.of("$x$y".toString()) }
println pairs.toList()

Optional[5]
Optional[30]
Optional.empty
[1a, 1b, 2a, 2b]

import groovy.transform.Field
import groovy.transform.CompileStatic
import java.util.concurrent.CompletableFuture

record Plant(String name, double minTemp) {}
@Field Map<String, Plant> plants = [t: new Plant('tomato', 12.0d), b: new Plant('basil', 10.0d)]
@Field Map<String, Double> readings = [t: 18.5d]
Optional<Plant> findPlant(String id) { Optional.ofNullable(plants[id]) }
Optional<Double> reading(String id) { Optional.ofNullable(readings[id]) }

def ok = DO(p in findPlant('t'), r in reading('t')) { Optional.of("${p.name()}: ${r - p.minTemp()} above minimum") }
println ok
def missing = DO(p in findPlant('b'), r in reading('b')) { Optional.of("${p.name()}: ${r - p.minTemp()}") }
println missing
def f = DO(a in CompletableFuture.supplyAsync { 20 }, b in CompletableFuture.supplyAsync { 22 }) { CompletableFuture.completedFuture(a + b) }
println f.get()

@CompileStatic(extensions = 'groovy.typecheckers.MonadicChecker')
class Calc {
    static int sum() { DO(a in Optional.of(2), b in Optional.of(3)) { Optional.of(a + b) }.get() }
}
println Calc.sum()

Optional[tomato: 6.5 above minimum]
Optional.empty
42
5