Functional Groovy

def closure = { -> }

def closureWithArgs = { arg1, arg2 -> (1)
    println "statements" (2)
}

def closureWithImplicit = {
    println it (3)
}

Closure<?> typedClosure = {-> } (3)

void 'Declaring and executing a closure'() {
    given: 'a variable and a closure'
        def x = 1 (1)
        def c = { ->
            def y = 1 (2)
            x + y (3)
        }
    when: 'executing the closure'
        def result = c() (4)
    then: 'the value should be the expected'
        result == 2
}

void 'Using closures with collections (I)'() {
    given: 'a collection of numbers'
        def numbers = [1, 2, 3, 4]
    when: 'collecting the double of each of them'
        def doubledNumbers = numbers.collect { it * 2 } (1)
    then:
        doubledNumbers == [2, 4, 6, 8]
}

void 'Using closures with collections (II)'() {
    given: 'a collection of numbers'
        def numbers = [1, 2, 3, 4]
    when: 'collecting the double of each of them'
        def collector = { it * 2 } (1)
        def doubledNumbers = numbers.collect(collector) (2)
    then:
        doubledNumbers == [2, 4, 6, 8]
}

Integer calculate1(Integer... numbers) {
    return numbers.sum()
}

void 'Composition: Just one calculation. No composition'() {
    given: 'two numbers as input'
        def first = 1
        def second = 2
    when: 'invoking the function'
        def result = calculate1(first, second)
    then: 'we should be getting the sum'
        result == 3
}

Double calculate2(Integer... numbers) {
    return numbers
        .collect { it * 2 }
        .collect { it / 10 }
        .sum()
}

void 'Composition: Calculation gets bigger. No composition'() {
    given: 'two numbers as input'
        def first = 10
        def second = 20
    when: 'invoking the function'
        def result = calculate2(first, second)
    then: 'the result should be the expected'
        result == 6
}

Double calculate3(Integer... numbers) {
    def twoTimes = { it * 2 } (1)
    def divideByTen = { it / 10 } (2)
    def composedFn = twoTimes >> divideByTen (3)

    return numbers
        .collect(composedFn) (4)
        .sum()
}

void 'Composition: Calculation gets bigger. Composing (I)'() {
    given: 'two numbers as input'
        def first = 10
        def second = 20
    when: 'invoking the function'
        def result = calculate3(first, second)
    then: 'the result should be the expected'
        result == 6
}

(1)
Double calculate4(Integer... numbers) {
    def operation =
        Calculations.divideByTen <<
        Calculations.twoTimes

    return numbers.collect(operation).sum()
}

(2)
Double applyFunctionAndSum(Closure<Number> fn, Integer... numbers) {
    return numbers.collect(fn).sum()
}

void 'Composition: Calculation gets bigger. Composing (II)'() {
    given: 'two numbers as input'
        def first = 10
        def second = 20
    when: 'invoking the function'
        def result1 = calculate4(first, second) (3)
        def result2 =
            applyFunctionAndSum(Calculations.twoTimes, first, second) (4)
    then: 'the result should be the expected'
        result1 == 6
        result2 == 60
}

void 'default closure resolution'() {
    given: 'an instance of ClosureBehavior'
        def instance = new ClosureBehavior()
    expect: 'result to be two'
        instance.sum() == 6
}

class ClosureBehavior {

    (3)
    def a = 1
    def b = 0
    def c = 0

    def sum() {
        (2)
        def b = 2

        Closure<Integer> cl = {
            (1)
            c = 3
            a + b + c
        }

        return cl()
    }

}

@groovy.transform.Memoized
   def findUserDataById(Integer userId) {
        println "Getting user [$userId] data"

        return [id: userId, name: "john doe $userId", timestamp: System.currentTimeMillis()]
   }

void 'Using memoize for a given method'() {
    given: 'a invocation to get a user'
        def result = findUserDataById(1)
    and: 'waiting to check timestamp later'
        Thread.sleep(500)
    when: 'asking again for the same user'
        result = findUserDataById(1)
    then: 'if cache is expected timestamp should match'
        result.timestamp == old(result.timestamp)
}

void 'Using a memoized closure'() {
     given: 'a list of words'
         def words = [\
             'car','peter','maggie',
             'ronnie','book','peter',
             'road','car','ronnie'
         ]
     and: 'building the memoized closure'
         def md5fromWord = { String word ->
             println "Word: $word" (1)
             java.security.MessageDigest
                 .getInstance("MD5")
                 .digest(word.getBytes("UTF-8"))
                 .encodeHex()
                 .toString()
         }.memoize() (2)
     when: 'collecting their md5 hashes'
         def md5Hashes = words.collect(md5fromWord) (3)
     then: 'checking figures'
         md5Hashes.size() == 9
         md5Hashes.unique().size() == 6
     // Word: car
     // Word: peter
     // Word: maggie
     // Word: ronnie
     // Word: book
     // Word: road
}

void 'Trampoline: Adding up numbers recursively'() {
    given: 'a closure prepared to call itself recursively'
        def sumRecursively (1)
        sumRecursively = { List<Integer> numbers, aggregator = 0 ->
            if (!numbers) {
                return aggregator
            } else {
                sumRecursively.trampoline( (2)
                        numbers.tail(),
                        aggregator + numbers.head())
            }
        }
    when: 'usisng the transformed version of closure'
        sumRecursively = sumRecursively.trampoline() (3)
        def result = sumRecursively(1..10000)
    then: 'we should get the result without the stackoverflow exception'
        result == 50005000
}

@groovy.transform.TailRecursive
Integer recursiveSum(List<Integer> numbers, Integer aggregator = 0) {
    if (!numbers) {
        return aggregator
    } else {
        return recursiveSum(
            numbers.tail(),
            numbers.head() + aggregator
        )
    }
}

void 'TailRecursive: recursive sum'() {
    when: 'using the transformed method'
        def result = recursiveSum(1..10000)
    then: 'we should get the result without the stackoverflow exception'
        result == 50005000
}

package groovyfp.oop2fn

interface Filter<T> {
   Boolean accept(T element)
}

package groovyfp.oop2fn

class EvenNumbersFilter implements Filter<Integer> {
    Boolean accept(Integer number) {
        return number % 2 == 0
    }
}

List<Integer> filterNumbersByFilter(List<Integer> numbers, Filter<Integer> filter) {
    List<Integer> resultList = new ArrayList()

    for (Integer number : numbers) {
        if (filter.accept(number)) {
            resultList.add(number)
        }
    }

    return resultList
}

void 'Functional Interface: the old fashioned way'() {
    given: 'a list of numbers'
        def numbers = (0..10)
    when: 'filtering using the class wrapping the filtering behavior'
        def evenNumbers = filterNumbersByFilter(numbers, new EvenNumbersFilter())
    then: 'We should get the expected result'
        evenNumbers == [0, 2, 4, 6, 8, 10]
}

void 'Functional Interface: closures coercion'() {
    given: 'a list of numbers'
        def numbers = (0..10)
    when: 'filtering using the class wrapping the filtering behavior'
        def filter = { it % 2 == 0 } as Filter (1)
        def evenNumbers = filterNumbersByFilter(numbers, filter) (2)
    then: 'We should get the expected result'
        evenNumbers == [0, 2, 4, 6, 8, 10]
}

void 'External iteration. Java like code'() {
    given: 'A collection we want to iterate'
        def expendables = ['Stallone', 'Staham', 'Couture']
    when: 'Collecting the upper case version of the names'
        def expendablesUpperCase = []
        for(String name: expendables) {
            expendablesUpperCase << name.toUpperCase()
        }
    then: 'All names should be in upper case'
      expendablesUpperCase == ['STALLONE', 'STAHAM', 'COUTURE']
}

void 'External iteration. Groovy style code'() {
    given: 'A collection we want to iterate'
        def expendables = ['Stallone', 'Staham', 'Couture']
    when: 'Collecting the upper case version of the names'
        def expendablesUpperCase = []
        expendables.each { name ->
            expendablesUpperCase << name.toUpperCase()
        }
    then: 'All names should be in upper case'
      expendablesUpperCase == ['STALLONE', 'STAHAM', 'COUTURE']
}

void 'Internal iteration (I)'() {
    given: 'A collection we want to iterate'
        def expendables = ['Stallone', 'Staham', 'Couture']
        def upperCaseVersion = { String word -> word.toUpperCase() }
    when: 'Collecting the upper case version of the names'
        def upperCaseExpendables = expendables.collect(upperCaseVersion)
    then: 'All names should be in upper case'
      upperCaseExpendables == ['STALLONE', 'STAHAM', 'COUTURE']
}

void 'Internal iteration (II)'() {
    given: 'A collection we want to iterate'
        def expendables = ['Stallone', 'Staham', 'Couture']
    when: 'Collecting the upper case version of the names'
        def upperCaseVersion = expendables.collect { it.toUpperCase() }
    then: 'All names should be in upper case'
      upperCaseVersion == ['STALLONE', 'STAHAM', 'COUTURE']
}

void 'external iteration: adding up all numbers from a given collection'() {
    given: 'a collection of numbers'
        def numbers = (0..1000)
        def sum = 0
    when: 'summing all of them'
        numbers.each { nextnumber ->
            sum += nextnumber
        }
    then: 'the expected result should be the expected'
        sum == 500500
}

void 'External iteration: Adding numbers from 20 to 100 from a given collection'() {
    given: 'a collection of numbers'
        def numbers = (0..1000)
        def sum = 0
    when: 'adding up all of them'
        numbers.each { nextnumber ->
            if (nextnumber > 20 && nextnumber < 100) {
                sum += nextnumber
            }
        }
    then: 'the expected result should be the expected'
        sum == 4740
}

Integer sum(
    final Collection<Integer> source, (1)
    final Closure<Boolean> filter = { it }) { (2)

    return source.findAll(filter).sum() (3)
}

void 'Internal iteration: Adding up with reusability'() {
    given: 'A collection of numbers'
        def numbers = (0..1000)
    when: 'adding up'
        def all = sum(numbers)
        def from20To100 = sum(numbers) {
            it > 20 && it < 100
        }
    then: 'Results should be the expected'
        all == 500500
        from20To100 == 4740
}

void 'Internal iteration: Reusability limited ? (I)'() {
    given: 'A collection of numbers'
        def numbers1 = [100, 20, 2, 54, 33, 14]
        def numbers2 = [100, 20, 2, 54, 33, 14]
        def numbers3 = [100, 24, 6, 48, 22, 40]
    when: 'adding up all numbers of first collection'
        def numbers1Sum = sum(numbers1)
    and: 'adding up numbers > 20 and < 100 for the remaining collections'
        def numbers2Sum = sum(numbers2) {
            it > 20 && it < 100
        }
        def numbers3Sum = sum(numbers3) {
            it > 20 && it < 100
        }
    then: 'Results should be the expected'
        numbers1Sum == 223
        numbers2Sum == 87
        numbers3Sum == 134
}

void 'Internal iteration: Reusability limited ? (II)'() {
    given: 'A collection of numbers'
        def numbers1 = [100, 20, 2, 54, 33, 14]
        def numbers2 = [100, 20, 2, 54, 33, 14]
        def numbers3 = [100, 24, 6, 48, 22, 40]
    and: 'A fixed type of filter'
        def greaterThan20LessThan100 = { it > 20 && it < 100} (1)
    when: 'adding up all numbers of first collection'
        def numbers1Sum = sum(numbers1)
    and: 'adding up numbers > 20 and < 100 for the remaining collections'
        def numbers2Sum = sum(numbers2, greaterThan20LessThan100) (2)
        def numbers3Sum = sum(numbers3, greaterThan20LessThan100)
    then: 'Results should be the expected'
        numbers1Sum == 223
        numbers2Sum == 87
        numbers3Sum == 134
}

void 'Internal iteration: Reusability limited ?'() {
    given: 'A collection of numbers'
        def numbers1 = [100, 20, 2, 54, 33, 14]
        def numbers2 = [100, 20, 2, 54, 33, 14]
        def numbers3 = [100, 24, 6, 48, 22, 40]
    and: 'A fixed type of behavior'
        def customSum = this.&sum.rcurry { it > 20 && it < 100} (1)
    when: 'adding up all numbers of first collection'
        def numbers1Sum = sum(numbers1)
    and: 'adding up numbers > 20 and < 100 for the remaining collections'
        def numbers2Sum = customSum(numbers2) (2)
        def numbers3Sum = customSum(numbers3)
    then: 'Results should be the expected'
        numbers1Sum == 223
        numbers2Sum == 87
        numbers3Sum == 134
}

void 'Specifications change. Looping Twice'() {
    given: 'a list of words'
        def words = [' animal', ' person', 'something else ']
    and: 'a couple of transformations'
        def trim = { it.trim() }
        def toUpperCase = { it.toUpperCase() }
    when: 'applying transformations one after another'
        def result =
            words
                .collect(trim) (1)
                .collect(toUpperCase) (2)
    then: 'we should get a cleaned list of words'
        result == ['ANIMAL', 'PERSON', 'SOMETHING ELSE']
}

void 'Specifications change. Composition'() {
    given: 'a list of words'
        def words = [' animal', ' person', 'something else ']
    and: 'a couple of transformations'
        def trim = { it.trim() }
        def toUpperCase = { it.toUpperCase() }
        def trimAndUpperCase = toUpperCase << trim (1)
    when: 'applying transformations one after another'
        def result = words.collect(trimAndUpperCase)
    then: 'we should get a cleaned list of words'
        result == ['ANIMAL', 'PERSON', 'SOMETHING ELSE']
}

void 'Multiply even numbers 10 times'() {
    given: 'A collection of numbers'
        def numbers = (0..10)
    when: 'Filtering and transforming numbers'
        def result =
            numbers
                .findAll { it % 2 == 0} (1)
                .collect { it * 10 } (2)
                .collect { it + 1 } (3)
    then: 'We should get the expected result'
        result == [1, 21, 41, 61, 81, 101]
}

void 'Multiply even numbers 10 times'() {
    given: 'A collection of numbers'
        def numbers = (0..10)
        def multiplyTenTimes = { x -> x * 10}
        def byEvenNumber = { x -> x % 2 == 0 }
        def plusOne = { x -> x + 1 }
    when: 'Filtering and transforming numbers'
        def result =
            numbers
                .findAll(byEvenNumber) (1)
                .collect(multiplyTenTimes >> plusOne) (2)
    then: 'We should get the expected result'
        result == [1, 21, 41, 61, 81, 101]
}

void 'Multiply even numbers 10 times lazily'() {
    given: 'A collection of numbers'
        def emptyList = []
        def numbers = (0..10)
        def multiplyTenTimes = { x -> x * 10}
        def byEvenNumber = { x -> x % 2 == 0 }
        def plusOne = { x -> x + 1 }
    when: 'Filtering and transforming numbers'
        def result =
            numbers.inject(emptyList) { acc, val ->
                if (val % 2 == 0) {
                    acc << plusOne(multiplyTenTimes(val))
                }
                acc
            }
    then: 'We should get the expected result'
        result == [1, 21, 41, 61, 81, 101]
}

package groovyfp.streams

final class Stream {

    final Collection<?> col
    Closure<Boolean> filter
    Closure<?> transformer
    Integer howMany

    Stream(Collection<?> col) {
       this.col = col
    }

    static Stream from(Collection<?> source) {
        return new Stream(source)
    }

    Stream filter(Closure<Boolean> filter) {
        this.filter = filter
        this
    }

    Stream map(Closure<?> transformer) {
        this.transformer = transformer
        this
    }

    Stream take(Integer howMany) {
        this.howMany = howMany
        this
    }

    Collection<?> collect() {
        def result = []

        col.takeWhile { val ->
            if (filter(val)) {
                result << transformer(val)
            }
            howMany ? (result.size() < howMany) : true
        }

        return result
    }

}

void 'Multiply even numbers 10 times lazily (nicer way)'() {
    given: 'A collection of numbers'
        def numbers = (0..10)
        def multiplyTenTimes = { x -> x * 10}
        def byEvenNumber = { x -> x % 2 == 0 }
        def plusOne = { x -> x + 1 }
    when: 'Filtering and transforming numbers'
        def result =
            Stream
                .from(numbers)
                .filter(byEvenNumber)
                .map(multiplyTenTimes >> plusOne)
                .take(2)
                .collect()
    then: 'We should get the expected result'
        result == [1, 21]
}

void 'Creating streams'() {
    when: 'building streams from collections and iterables'
        def stream1 = Stream.from({ x++ }).using(x: 1) (1)
        def stream2 = Stream.from([1, 2, 3]) (2)
        def stream3 = Stream.from(50..100) (3)
        def stream4 = Stream.from(x: 0..2, y: 4..2) (4)
    and: 'from an iterator instance'
        def x = 0
        def iterator = [hasNext: { true }, next: { x++ }] as Iterator
        def stream5 = Stream.from(iterator) (5)
    and: 'also from another stream'
        def stream6 = Stream.from(stream1) (6)
    then: 'values generated by the stream invocations'
        stream1.take(2).collect() == [1, 2]
        stream2.take(2).collect() == [1, 2]
        stream3.take(4).collect() == [50, 51, 52, 53]
        stream4.take(2).collect() == [[x:0, y:4], [x:0, y:3]]
    and: 'using until instead of take'
        stream5.until{ it > 3}.collect() == [0, 1, 2, 3]
        stream6.until{ it > 6}.collect() == [3, 4, 5, 6]
}

void 'Maximum difference in an NBA game: non lazy'() {
    when: 'Csv iterable'
        def result = csv
                .findAll(byDateFunction)
                .collect(differenceFunction)
                .max()
    then: 'The result should be the expected'
        result == 45
}

void 'Maximum difference in an NBA game: lazy'() {
    when: 'Csv iterable'
        def result =
            Stream
                .from(csv)
                .filter(byDateFunction)
                .map(differenceFunction)
                .max()
    then: 'The result should be the expected'
        result == 45
}

def getByDateFunction() {
    return { row ->
       row.date.endsWith('2013')
    }
}

def getDifferenceFunction() {
    return { row ->
        [row.homePoints, row.visitorPoints]*.
            toInteger().
            sort().
            with {
                last() - first()
            }
    }
}

void 'State: using state wrong (I)'() {
    given: 'an object used in a closure'
        def state = new State(discount:50) (1)
        def closure = { price ->
            price * (state.discount / 100) (2)
        }
    when: 'calculating the price discount'
        def result1 = closure(100)
    and: 'changing state value'
        state = new State(discount:20) (3)
        def result2 = closure(100)
    then: 'the second result is different'
        result1 != result2
}

void 'State: using state wrong (II)'() {
    given: 'an object used in a closure'
        def state = new State(discount:50) (1)
    and: 'reducing the closure avaiable scope when is created'
        def closure = { State st -> (2)
            return { price ->
                price * (st.discount / 100)
            }
        }
    when: 'calculating the price discount'
        def closureWithImmutableState  = closure(state)
        def result1 = closureWithImmutableState(100)
    and: 'changing state value'
        state = new State(discount:20) (3)
        def result2 = closureWithImmutableState(100)
    then: 'the second result is different'
        result1 == result2
}

package groovyfp.oop2fn

class PurchaseEntry {

    BigDecimal price

    BigDecimal applyPurchaseProcess(PurchaseProcess process) {
        return process.calculate(price)
    }

}

package groovyfp.oop2fn

interface PurchaseProcess {
    BigDecimal calculate(BigDecimal price)
}

void 'Command: passing behavior to another class'() {
    given: 'a given purchase has a certain price'
        def purchaseEntry = new PurchaseEntry(price: 200) (1)
    when: 'two different purchase processes'
        def result = purchaseEntry.applyPurchaseProcess(process) (2)
    then: 'the price is the expected depending on the process'
        result == expectedPrice
    where: 'possible processes are'
        process                           | expectedPrice
        { price -> price }                | 200 (3)
        { price -> price += price * 0.3 } | 260 (4)
}

package groovyfp.oop2fn

import groovy.transform.TupleConstructor

@TupleConstructor
class Video {
    String name
    String type
    long length

    void setName(String name) {}
    void setType(String type) {}
    void setLength(Long length) {}
}

package groovyfp.oop2fn

class VideoBuilder {

    String name
    String type
    Long length

    static VideoBuilder builder() {
        return new VideoBuilder()
    }

    VideoBuilder name(String name) {
        this.name = name
        return this
    }

    VideoBuilder type(String type) {
        this.name = name
        return this
    }

    VideoBuilder length(Long length) {
        this.length = length
        return this
    }

    Video build() {
        return new Video(name, type, length)
    }

}

void 'Immutability through Builder'() {
    given: 'an object built by a builder'
        def video =
            VideoBuilder
                .builder()
                .name('trip.avi')
                .type('mp4')
                .length(100000)
                .build()
    when: 'trying to mutate the object'
        video.name = 'anothervideo'
    then: 'the instance should not have been mutated'
        video.name == 'trip.avi'
}

package groovyfp.oop2fn

import groovy.transform.Immutable

@Immutable
class ImmutableVideo {
    String name
    String type
    long length
}

void 'Immutability through @Immutable'() {
    given: 'an immutable instance'
        def video = new ImmutableVideo(
            name: 'video.mp4',
            type: 'mp4',
            length: 12434
        )
    when: 'trying to mutate the object'
        video.name = 'somethingelse.avi'
    then: 'an exception will be thrown'
        thrown(Exception)
}

void 'Looping two collections at the same time'() {
    given: 'two different collections'
        def collection1 = (10..12)
        def collection2 = (60..62)
    and: 'the collection combining the result'
        def combination = []
    when: 'combining both collections'
        collection1.each { outer ->
            collection2.each { inner ->
               combination << [outer, inner]
            }
        }
    then: 'values should be the expected'
        combination == [
            [10, 60],
            [10, 61],
            [10, 62],
            [11, 60],
            [11, 61],
            [11, 62],
            [12, 60],
            [12, 61],
            [12, 62]
        ]
}

void 'Groovy comprehensions using stream-groovy'() {
    given: 'two different collections'
        def collection1 = (10..12)
        def collection2 = (60..62)
    when: 'combining both collections using stream-groovy'
        def combination =
            Stream
                .from(x: collection1, y: collection2)
                .map { [x, y] }
                .collect()
    then: 'the results should be the expected'
        combination == [
            [10, 60],
            [10, 61],
            [10, 62],
            [11, 60],
            [11, 61],
            [11, 62],
            [12, 60],
            [12, 61],
            [12, 62]
        ]
}

package groovyfp.oop2fn

abstract class AbstractFinancialProcess {

    abstract Double calculateTaxes(Double amount)
    abstract Double calculateExtras(Double amount)

    Double calculate(Double amount) {
        return amount +
            calculateTaxes(amount) +
            calculateExtras(amount)
    }

}

package groovyfp.oop2fn

class FinancialProcessSoft extends AbstractFinancialProcess {

    Double calculateTaxes(Double amount) {
        return amount * 0.01
    }

    Double calculateExtras(Double amount) {
        return amount * 0.2
    }

}

package groovyfp.oop2fn

class FinancialProcessHard extends AbstractFinancialProcess {

    Double calculateTaxes(Double amount) {
        return amount * 0.10
    }

    Double calculateExtras(Double amount) {
        return amount * 0.5
    }

}

void 'Classical template method implementation'() {
    given: 'One concrete subclass implementation'
        def softCalculation = new FinancialProcessSoft()
    and: 'another different implementation based in the same parent'
        def hardCalculation = new FinancialProcessHard()
    expect: 'both results differ using the same process'
        softCalculation.calculate(100) !=
        hardCalculation.calculate(100)
}

Closure<Double> calculate = {
        Closure<Double> calculateTaxes,
        Closure<Double> calculateExtras,
        Double amount ->

    return amount + calculateTaxes(amount) + calculateExtras(amount)
}

Closure<Double> calculateSoftTaxes = { Double amount ->
    return amount * 0.01
}

Closure<Double> calculateSoftExtras = { Double amount ->
    return amount * 0.2
}

void 'Template pattern using functions'() {
    when: 'calculating using predefined functions'
        def result1 =
            calculate(
                calculateSoftTaxes,
                calculateSoftExtras,
                100
            )
    and: 'calculating using anonymous functions'
        def result2 =
            calculate(
                { amount -> amount * 0.2 },
                { amount -> amount * 0.10 },
                100
            )
    then: 'same process...different results...with less code'
        result1 != result2
}

void 'Composing functions to reuse templates'() {
    when: 'building a preset calculation'
        Closure<Double> customCalculation = { Double amount ->
            calculate(
                calculateSoftTaxes,
                calculateSoftExtras,
                amount
            )
        }
    then: 'you can reuse it along your code'
        customCalculation(100) == 121.0
}

List<ImmutableVideo> findAllFaultyVideo(List<ImmutableVideo> videoList, Closure<Boolean> validationStrategy) {
    return videoList
        .findAll(validationStrategy) (1)
        .asImmutable() (2)
}

Closure<Boolean> strategy1 = { ImmutableVideo video -> video.type == 'mp4' } (3)
Closure<Boolean> strategy2 = { ImmutableVideo video -> video.length < 700  } (4)

void 'Changing the validation strategy'() {
    given:'A list of cars'
        List<ImmutableVideo> videoList = [
            [name: 'video1', type: 'avi', length: 1000],
            [name: 'video2', type: 'mp4', length: 1000],
            [name: 'video3', type: 'avi', length: 500] ,
            [name: 'video4', type: 'mp4', length: 1000],
            [name: 'video5', type: 'mp4', length: 50]
        ].asImmutable() as ImmutableVideo[]
    when: 'applying different strategies to the same list'
        def result1 = findAllFaultyVideo(videoList, strategy1)
        def result2 = findAllFaultyVideo(videoList, strategy2)
    then: 'you will have different result size'
        result1.size() == 3
        result2.size() == 2
}

Integer countLetters(String name) {
    return name.length() (1)
}

void 'Fighting NPE: Groovy truth (I)'() {
    given: 'A word'
        def word = null
    when: 'Invoking the method'
        def result = countLetters(word) (2)
    then: 'A NPE will be thrown'
        thrown(NullPointerException)
}

Integer countLettersGroovyTruth(String name) {
    return name?.length() (1)
}

void 'Fighting NPE: Groovy truth (II)'() {
    given: 'A word'
        def word = null
    when: 'Invoking the method'
        def result = countLettersGroovyTruth(word) (2)
    then: 'No exception will be thrown'
        notThrown(NullPointerException)
    and: 'The method to return null'
        result == null
}

void 'Null is not null'() {
    expect: 'That null is not what it seems'
        null.getClass() == org.codehaus.groovy.runtime.NullObject
}

void isNullThis(anything) {
    if (!anything) {
        println "Is null"
    } else {
        println anything.class.simpleName
    }
}

void isNullThis(anything) {
    if (!anything) {
        println "Is null"
    } else {
        println anything.class.simpleName
    }
}

List<String> doSomething(List<String> words) {
    return words
        .findAll { it.startsWith('j') }
        .collect { it.toUpperCase() }
}

void 'Collections are safe'() {
    given: 'two different collections'
        def cities = null
        def names = ['john', 'jeronimo', 'james']
    when: 'filtering and transforming cities'
        def citiesResult = doSomething(cities)
    and: 'doing the same for names'
        def namesResult = doSomething(names)
    then: 'we should get at least an empty list'
        citiesResult == []
        namesResult == ['JOHN', 'JERONIMO', 'JAMES']
}

void 'Groovy truth: insane ?'() {
    when: 'mapping values from a non safe reference'
        def result =
            source
                .collect { it }
                .join()
                .toUpperCase()
    then: 'the result should be the expected'
        result == expected
    where: 'possible values could be'
        source | expected
        null   | ""
        "john" | "JOHN"
}

void 'Using elvis operator'() {
    when: 'preparing the item'
        def name = source ?: 'john doe' (1)
    then: 'all values should have more than one letter'
        name.toUpperCase() == expected (2)
    where: 'possible values are'
        source  | expected
        null    | "JOHN DOE"
        "peter" | "PETER"
}

void 'Using elvis operator: another example'() {
    when: 'creating default reference'
        def video2Process = video ?: new ImmutableVideo(name:'unknown') (1)
        def result =
            new ImmutableVideo(
                name: "${video2Process.name}-processed",
                type: "ogg"
            )
    then: 'no exception is thrown even if it was a null ref'
        notThrown(NullPointerException)
    and: 'transformation has been applied'
        result.name?.contains('processed')
        result.type == 'ogg'
    where: 'possible values are'
        video << [
            null,
            new Video(name: 'documentary.mp4', type: 'mp4')
        ]
}

void 'Using Optional pattern: dealing with nulls'() {
    when: 'creating default reference'
        Option<ImmutableVideo> result =
            Option
                .from(video) (1)
                .map { ImmutableVideo v -> (2)
                    new ImmutableVideo(
                        name: "${v.name}-processed",
                        type: v.type)
                }
    then: 'no exception is thrown even if it was a null ref'
        notThrown(NullPointerException)
and: 'transformation has been applied'
    result.hasValue() == hasValue
    where: 'possible values are'
        video                                                        | hasValue
            new ImmutableVideo(name: 'documentary.mp4', type: 'mp4') | true
            null                                                     | false
}

@Immutable (1)
@EqualsAndHashCode (2)
class V {
    int x, y

    (3)
    def plus(final V v) {
        return new V (x: x + v.x, y: y + v.y)
    }
}

void 'simple monoid: associativity'() {
    given: 'three different entries'
        def a = new V(x: 1, y: 2)
        def b = new V(x: 1, y: 3)
        def c = new V(x: 1, y: 4)
    expect: 'applying binaryOp'
        ((a + b) + c) == (a + (b + c))
}

void 'simple monoid: identity'() {
    given: 'three different entries'
        def a = new V(x: 1, y: 200)
        def e = new V(x: 0, y: 0)
    expect: 'applying binaryOp'
        (e + a) == (a + e)
        (e + a) == a
        (a + e) == a
}

void 'simple monoid: parallelism'() {
    given: 'three different entries'
        def a = new V(x: 1, y: 2)
        def b = new V(x: 1, y: 3)
        def c = new V(x: 1, y: 4)
    when: 'applying binaryOp in order'
        def result1 = [a, b, c].sum() (1)
    and: 'applying in any order'
        def result2 = withPool { [a,b,c].sumParallel() } (2)
    then: 'both results should match'
        result1 == result2
}

class Functor f where
    fmap :: (a -> b) -> f a -> f b

(<*>) :: Applicative f => f (a->b) -> (f a -> f b)

class Monad m where
    (>>=) :: m a -> (a -> m b) -> m b

package groovyfp.categories;

/**
 *
 * @param <A>
 */
public interface Monad<A> extends Applicative<A> {
    public <B,M extends Monad<B>> M bind(Function<A,M> fn);
}