Groovy 101

Transcript

1. Joseph Florencio
2. Groovy ...
3. Groovy is a dynamic language Takes inspiration from Python, Ruby, Perl, ...
4. Groovy supports DSLs Expressive syntax reduces boilerplate
5. Groovy runs on the JVM Interoperable with Java
6. Groovy is not statically typed Every type check is asserted at runtime
7. Groovy is not Java
8. In Groovy... Semicolons Generics Access Modifiers Parenthesis Checked Exceptions Return Statements
9. In Groovy... Semicolons Generics Access Modifiers Parenthesis Checked Exceptions Return Statements ARE NOT REQUIRED
10. In Groovy... Semicolons Generics Access Modifiers Parenthesis Checked Exceptions Return Statements omit
11. In Groovy... Semicolons Generics Access Modifiers Parenthesis Checked Exceptions Return Statements no static type checks
12. In Groovy... Semicolons Generics Access Modifiers Parenthesis Checked Exceptions Return Statements public default
13. In Groovy... Semicolons Generics Access Modifiers Parenthesis Checked Exceptions Return Statements can omit on invoke
14. In Groovy... Semicolons Generics Access Modifiers Parenthesis Checked Exceptions Return Statements don’t exist
15. In Groovy... Semicolons Generics Access Modifiers Parenthesis Checked Exceptions Return Statements returns last expression
16. How does Groovy make me more productive?
17. == is Actually Useful assert "hi world" == ("hi" + " world") assert [1, 2, 3] == [1, 2, 3] assert ![1, 2, 3].is([1,2,3]) assert null != [1, 2, 3]
18. Properties class Foo { String bar } def f = new Foo() f.bar = "hi" assert "hi" == f.bar assert "hi" == f.getBar() f.setBar("hello") assert "hello" == f.bar
19. Groovy Beans class Profile { String name, company } def p = new Profile( name: "Joe", company: "LinkedIn") assert "Joe" == p.name assert "LinkedIn" == p.company
20. def is Object (No Type Inference) class City { String name } class Person { String name } def thing = new City( name: "Philadelphia") assert "Philadelphia" == thing.name thing = new Person(name: "Joe") assert "Joe" == thing.name
21. Safe Navigation: No NPE! class Dog { Person owner } Dog d1 = new Dog(owner: new Person(name: "Joe")) Dog d2 = new Dog(owner: null) Dog d3 = null assert "Joe" == d1?.owner?.name assert null == d2?.owner?.name assert null == d3?.owner?.name
22. Operator Overloading class Speed { int mph Speed plus(Speed s) { new Speed(mph: mph + s.mph) } } def sum = new Speed(mph: 15) + new Speed(mph: 5) assert 20 == sum.mph
23. Groovy Truth (Implicit Coercion via asBoolean) assert !"" assert "a" assert ![] assert [0] assert !null assert !0 assert 1 assert new Object()
24. Elvis Operator assert "hi" == null ?: "hi" assert [1, 2] == [] ?: [1, 2] assert "hi" == "" ?: "hi" ?: 0 // Mmmm... Groovy assert "Joe" == d3?.owner?.name ?: "Joe"
25. Built-in Collections Support assert [] == new ArrayList() def l = ['a', 'b', 'c'] assert 'b' == l[1] assert [1, 2, 3] == [1] + [2, 3] assert [:] == new LinkedHashMap() def m = [a: 1, b: 2, c: 3] assert 1 == m.a assert 2 == m["b"]
26. With Helpers! def immutableL = [1, 2].asImmutable() try { immutableL.add(3) assert false: "won't get here" } catch(UnsupportedOperationException e) {} assert [a: 1, b: 2].asSynchronized()
27. Spread Operator def ls = ["foo", "world"] assert [3, 5] == ls*.size() String someMethod(String a, int b) { a + ": " + b*2 } def args = ["hi", 5] assert "hi: 10" == someMethod(*args)
28. as Operator (asType) int[] intArray = [1, 2, 3] as int[] assert false.is("" as boolean) def hs1 = new HashSet([5, 3]) def hs2 = [ "hello", "world", "foo"]*.size() as Set assert hs1 == hs2
29. "String ${Interpolation}" def name = "joe" assert "- joe" == "- $name" assert "Name: Joe" == "Name: ${name.capitalize()}" def year = 2010 def yearExp = "Year: ${->year+1}" assert "Year: 2011" == yearExp year = 2011 assert "Year: 2012" == yearExp
30. Talking About Closures...
31. Project Lambda? JDK 8, late 2013
32. Project Lambda? JDK 8, late 2013
33. Available today in Groovy
34. Closures vs Anonymous Inner Classes final int foo = 5; new Runnable() { @Override void run() { assert 5 == foo; } }.run()
35. Closures vs Anonymous Inner Classes final int foo = 5; new Runnable() { @Override void run() { assert 5 == foo; } }.run()
36. Closures vs Anonymous Inner Classes final int foo = 5 ({ assert 5 == foo } as Runnable).run()
37. Closures vs Anonymous Inner Classes final int foo = 5 ({ assert 5 == foo } as Runnable).run()
38. Closures vs Anonymous Inner Classes int foo = 5 ({ assert 5 == foo }).run()
39. Closures vs Anonymous Inner Classes int foo = 5 ({ assert 5 == foo }).run()
40. Closures vs Anonymous Inner Classes int foo = 5 ({ assert 5 == foo })()
41. Any class Can Be a Functor (call) class CallMe { String call(String s) { "hello $s" } } def cm = new CallMe() assert "hello world" == cm("world")
42. Closure 101 def c1 = { "implicit $it" } assert "implicit param" == c1("param") assert "implicit null" == c1() def c2 = { p1, p2 -> "explicit ${p1}${p2}" } assert "explicit param!" == c2("param", "!") def c3 = { String s -> "typed $s" } assert "typed param" == c3("param")
43. Methods as Closures class FooClass { String state String appendState(boolean b) { "$state: $b" } } def fc = new FooClass(state: "Open") Closure c = fc.&appendState assert "Open: true" == c(true)
44. Closure With Custom Delegate class DelClass { String prop } def d = new DelClass(prop: "hi") def closureHi = { assert prop == "hi" } closureHi.delegate = d closureHi.resolveStrategy = Closure.DELEGATE_ONLY closureHi()
45. switch Minus the Suck (isCase) def someStuff = 5 switch(someStuff) { case 0: assert false case Float: assert false case [0..4]: assert false case [0, 2, 4]: assert false case { it % 2 == 0 }: assert false case Integer: assert true; break; case 5: assert false default: assert false }
46. Higher Order Functions
47. collect (AKA map) def names = ["Joe", "Alex"] assert ["[Joe]", "[Alex]"] == names.collect { "[$it]" }
48. findAll (AKA filter) def numbers = [1, 2, 3, 4] assert [2, 4] == numbers.findAll { it % 2 == 0 }
49. inject (AKA reduce/foldLeft) def numSum = [1, 2, 3, 4] assert 10 == numSum.inject(0) { acc, val -> acc + val }
50. every def numbers2 = [-1, 0, 1] assert !numbers2.every { it >= 0 } assert numbers2.every { it >= -1 }
51. any def numbers3 = [-1, 0, 1] assert !numbers3.any { it == 2 } assert numbers3.any { it == 0 }
52. groupBy def words = ["joe", "pie", "world"] assert [ (3): ["joe", "pie"], (5): ["world"] ] == words.groupBy { it.size() }
53. curry (partial function application) def addThree = { p1, p2, p3 -> p1 + p2 + p3 } // addOne fixes p1 and p2 to 1 and 2 def addOne = addThree.curry(1, 2) assert 6 == addOne(3) assert 7 == addOne(4)
54. Combination Play assert 6 == [-1, 0, 1, 2, 3].collect { it + 1 }.findAll { it % 2 == 0 }.inject(0) { acc, val -> acc + val }
55. Write Your Own! String doMath(int a, int b, def perform) { "perform($a,$b)=${perform(a, b)}" } assert "perform(4,3)=12" == doMath(4, 3) { a, b -> a * b } assert "perform(4,3)=7" == doMath(4, 3) { a, b -> a + b }
56. Compile Time MetaProgramming
57. @Delegate class SuperList { @Delegate List list = [] @Override boolean push(def o) { list.push(o) list.push(o) } } assert [List, Iterable, Collection, GroovyObject] == SuperList.interfaces def sl = new SuperList() sl.push(2) assert [2, 2] == sl sl.remove(0) assert [2] == sl
58. @Immutable @Immutable class ImmutableCls { int a, b } def ic1 = new ImmutableCls(a: 1, b: 2) def ic2 = new ImmutableCls(1, 2) assert ic1 == ic2 assert "ImmutableCls(a:1, b:2)" == ic1.toString() try { ic1.a = 2 assert false : "Should never get here" } catch(ReadOnlyPropertyException ignore) {}
59. @Lazy class LazyCls { int refVar = 1 @Lazy int p1 = { refVar }() @Lazy String p2 = "hi" } def lc = new LazyCls() lc.refVar = 2 assert lc.p1 == 2 assert lc.p2 == "hi" lc.refVar = 3 assert lc.p1 == 2