Blocks
We can embed a sequence of statements inside "try", called a "block". Defined variables are only visible within that block, not outside:
def a = 'good morning' try{ def b = 'greetings', c = 'nice day' //'def' keyword applies to both 'b' and 'c' assert a == 'good morning' assert b == 'greetings' } assert a == 'good morning' //println b //a compile error if uncommented: b not visible here
Using the "def" keyword is optional because we are inside a script:
def c = 5 assert c == 5 d = 6 assert d == 6 //def keyword optional because we're within a script context assert binding.variables.c == null assert binding.variables.d == 6 //when def not used, variable becomes part of binding.variables
But variables without "def" are visible outside the block:
try{ h = 9 assert binding.variables.h == 9 } assert h == 9 assert binding.variables.h == 9
We can't define a variable (using "def") with the same name as another already visible (ie, another "in scope"):
def a = 'island' //def a = 'snake' //a compile error if uncommented: a already defined try{ //def a = 'jewel' //a compile error if uncommented: a already defined }
We can nest blocks:
def a = 123 try{ try{ try{ assert a == 123 } } }
Closures
We can take a sequence of statements that refers to its external context and assign it to a variable, then execute it later. It's technically called a "closable block", commonly called a "closure":
def a = 'coffee'
def c = {
def b = 'tea'
a + ' and ' + b //a refers to the variable a outside the closure,
//and is remembered by the closure
}
assert c() == 'coffee and tea' //short for c.call()
The closure assigned to the variable (here, c) will remember its context (here, including a) even if that context is not in scope when the closure is called:
def c try{ def a = 'sugar' c = { a } //a closure always returns its only value } assert c() == 'sugar' def d = c //we can also assign the closure to another variable assert d() == 'sugar'
A closure always returns a value, the result of its last statement:
giveSeven = { 7 }
assert giveSeven() == 7 //value of last statement is returned
giveNull = { def a }
assert giveNull() == null //null returned if last statement has no value
By putting a closure within another, we can create two instances of it:
c = { def e = { 'milk' }; e }
d = c
assert c == d
v1 = c()
v2 = c()
assert v1 != v2
Closure Parameters
We can put parameters at the beginning of a closure definition, and pass values in when we call the closure:
def toTriple = {n -> n * 3}
assert toTriple.call( 5 ) == 15
We can also pass information out using the parameters:
def f = { list, value -> list << value }
x = []
f(x, 1)
f(x, 2,) //trailing comma in argument list OK
f(x, 3)
assert x == [1, 2, 3]
One parameter is always available, called "it", if no explicit parameters are named:
c = { it*3 }
assert c( 'run' ) == 'runrunrun'
If parameters aren't specified, "it" will still be implicitly defined, but be null:
//c = { def it = 789 } //a compile error when uncommented: 'it' already implicitly defined c = { value1 -> def it = 789; [value1, it] } //works OK because no 'it' among parameters assert c( 456 ) == [456, 789] c = {-> def it = 789; it } //zero parameters, not even 'it', so works OK assert c() == 789
Parameters can't have the same name as another variable in scope, except for the implicit parameter 'it':
def name= 'cup' //def c={ name-> println (name) } //a compile error when uncommented: //current scope already contains name 'name' c= { def d= { 2 * it }; 3 * d(it) } //'it' refers to immediately-surrounding closure's parameter in each case assert c(5) == 30
If there's already a variable called 'it' in scope, we can access it using owner.it:
it= 2
c= { assert it == 3; assert owner.it == 2 }
c(3)
We can pass one closure into another as a parameter:
toTriple = {n -> n * 3}
runTwice = { a, c -> c( c(a) )}
assert runTwice( 5, toTriple ) == 45
We can return a closure from another:
def times= { x -> { y -> x * y }}
assert times(3)(4) == 12
There's a shortcut syntax when explicitly defining a closure within another closure call, where that closure is the last or only parameter:
def runTwice = { a, c -> c(c(a)) }
assert runTwice( 5, {it * 3} ) == 45 //usual syntax
assert runTwice( 5 ){it * 3} == 45
//when closure is last param, can put it after the param list
def runTwiceAndConcat = { c -> c() + c() }
assert runTwiceAndConcat( { 'plate' } ) == 'plateplate' //usual syntax
assert runTwiceAndConcat(){ 'bowl' } == 'bowlbowl' //shortcut form
assert runTwiceAndConcat{ 'mug' } == 'mugmug'
//can skip parens altogether if closure is only param
def runTwoClosures = { a, c1, c2 -> c1(c2(a)) }
//when more than one closure as last params
assert runTwoClosures( 5, {it*3}, {it*4} ) == 60 //usual syntax
assert runTwoClosures( 5 ){it*3}{it*4} == 60 //shortcut form
Arguments in a closure call can be named. They are interpreted as the keys in a map passed in as the first parameter:
def f= {m, i, j-> i + j + m.x + m.y }
assert f(6, x:4, y:3, 7) == 20
def g= {m, i, j, k, c-> c(i + j + k, m.x + m.y) }
assert g(y:5, 1, 2, x:6, 3){a,b-> a * b } == 66
We can enquire the number of parameters for a closure, both from inside and outside the closure:
c= {x,y,z-> getMaximumNumberOfParameters() }
assert c.getMaximumNumberOfParameters() == 3
assert c(4,5,6) == 3
A closure may have its last parameter/s assigned default value/s:
def e = { a, b, c=3, d='a' -> "${a+b+c}$d" }
assert e( 7, 4 ) == '14a'
assert e( 9, 8, 7 ) == '24a' //override default value of 'c'
A closure can take a varying number of arguments by prefixing its last parameter with Object[], and accessing them using 'each':
def c = { arg, Object[] extras ->
def list= []
list<< arg
extras.each{ list<< it }
list
}
assert c( 1 ) == [ 1 ]
assert c( 1, 2 ) == [ 1, 2 ]
assert c( 1, 2, 3 ) == [ 1, 2, 3 ]
assert c( 1, 2, 3, 4 ) == [ 1, 2, 3, 4 ]
We can also prefix the last parameter of a closure with Closure[] to pass in a varying number of other closures, even using the shortcut syntax:
def apply = { a, Closure[] cc ->
(cc as List).inject(a){ flo, it-> it(flo) }
//apply the closures nestedly to the initial value
}
assert apply(7){it*3}{it+1}{it*2}.toString() == '44'
When we call a closure with a list argument, if there's no closure defined with a list parameter, the arguments are passed in as separate parameters:
def c= {a, b, c-> a + b + c}
def list=[1,2,3]
assert c(list) == 6
A closure may be copied with its first parameter/s fixed to a constant value/s, using curry:
def concat = { p1, p2, p3 -> "$p1 $p2 $p3" }
def concatAfterFly = concat.curry( 'fly' )
assert concatAfterFly( 'drive', 'cycle' ) == 'fly drive cycle'
def concatAfterFlySwim = concatAfterFly.curry( 'swim' )
assert concatAfterFlySwim( 'walk' ) == 'fly swim walk'
In closures, we can use currying and parameter-count-varying together:
def c = { arg, Object[] extras -> arg + ', ' + extras.join(', ') }
def d = c.curry( 1 ) //curry first param only
assert d( 2, 3, 4 ) == '1, 2, 3, 4'
def e = c.curry( 1, 3 ) //curry part of Object[] also
assert e( 5 ) == '1, 3, 5'
def f = e.curry( 5, 7, 9, 11 ) //currying continues on Object
assert f( 13, 15 ) == '1, 3, 5, 7, 9, 11, 13, 15'
We can make closures recursive:
def gcd //predefine closure name gcd={ m,n-> m%n==0? n: gcd(n,m%n) } assert gcd( 28, 35 ) == 7
Functions
A function is similar to a closure, though a function can't access defined variables in its surrounding context:
a = 32 //def keyword not used for this one def c = 'there', d = 'yonder' def f(){ assert a == 32 //outer 'a' visible because 'def' keyword wasn't used with it def c = 'here' //compiles OK because other defined c invisible inside function definition //println d //a compile error when uncommented: d not accessable c } assert f() == 'here' //syntax to invoke a function
The def keyword is compulsory when defining functions:
def f(){
a = 1
c = { 'here, again' }
c()
}
assert f() == 'here, again'
//g(){ println 'there, again' }
//a compile error when uncommented: def keyword required
We use a special syntax to assign a function to another variable when using the original definition name:
def f(){ 77 } //define function using name 'f'
assert f() == 77
def g = this.&f //special syntax to assign function to another variable
assert g() == 77
def h = g //don't use special syntax here
assert h() == 77
f = 'something else' //this 'f' is a VARIABLE, not the function NAME
assert f() == 77 //the function name can't be reassigned
Unlike blocks and closures, we can't nest functions:
def f(){
//def g1(){ println 'there' }
//a compile error when uncommented: can't nest functions
'here'
}
assert f() == 'here'
try{
//def g2(){ println 'yonder' }
//a compile error when uncommented: can't nest functions
}
c = {
//def g3(){ println 'outer space' }
//a compile error when uncommented: can't nest functions
}
def h(){
try{ def c = { 'here, again' } }
//we can have blocks and closures within functions
}
Function Parameters
A function can have parameters, with which we can pass information both in and out:
def foo( list, value ){
list << value
}
x = []
foo(x, 1)
foo(x, 2)
assert x == [1, 2]
We can have more than one function of the same name if they each have different numbers of (untyped) parameters.
def foo(value){ 'v1' }
def foo(list, value){ 'v2' }
assert foo(9) == 'v1'
assert foo([], 1) == 'v2'
A function returns a value, unless prefixed by void instead of def, when it always returns null:
def f1(){ 7 }
assert f1() == 7 //value of last statement is returned
def f2(){ return 8; 3 }
assert f2() == 8 //return explicitly using return
void f3(){ 10 }
assert f3() == null //null always returned
//void f4(){ return 9 }
//a compile error when uncommented: can't use 'return' in a void function
When there's a method and closure with the same name and parameters, the method is chosen instead of the closure:
def c(){'method c'}
def c= {-> 'closure c'}
assert c() == 'method c'
def d(i){'method d'}
def d= {'closure d'}
assert d(9) == 'method d'
Some Similarities with Closures
We can use the shortcut invocation syntax for closure parameters:
def f(Closure c){ c() }
assert f{ 'heehee' } == 'heehee'
A function may have its last parameter/s assigned default value/s:
def dd( a, b=2 ){ "$a, $b" }
assert dd( 7, 4 ) == '7, 4'
assert dd( 9 ) == '9, 2'
Arguments in a function call can be named, interpreted as keys in a map passed in as first parameter:
def f(m, i, j){ i + j + m.x + m.y }
assert f(6, x:4, y:3, 7) == 20
def g(m, i, j, k, c){ c(i + j + k, m.x + m.y) }
assert g(y:5, 1, 2, x:6, 3){a,b-> a * b } == 66
A function can take a varying number of arguments by prefixing its last argument by Object[], and accessing them using each:
def c( arg, Object[] extras ){ def list= [] list<< arg extras.each{ list<< it } list } assert c( 1 ) == [ 1 ] assert c( 1, 2, 3, 4 ) == [ 1, 2, 3, 4 ]
When we call a function with a list argument, if there's none defined with a list parameter, the arguments are passed in separately:
def x(a, b, c){a + b + c}
def list=[1,2,3]
assert x(list) == 6
We can call a function recursively by referencing its own name:
def gcd( m, n ){ if( m%n == 0 )return n; gcd(n,m%n) }
assert gcd( 28, 35 ) == 7
