anchor.diff:  assert null == personInfo?['name']
   --------------------------------------
   
  +=== "var" reserved type
  +
  +Groovy supports a `def` type placeholder.
  +It can be used with fields, local variables and methods.
  +In dynamic Groovy, you use `def` when the type of the field or local variable (or return type for methods)
  +is deemed not important at compile time - normal runtime typing still applies.
  +For static Groovy, it is used when type inference is preferred over an explicit type.
  +
  +In Groovy 3.0, a new type placeholder is available: `var`.
  +It provides the syntax equivalent of Java 10's `var` reserved type (but you can use it with Groovy 3 from JDK 8).
  +It can be used for fields and local variables and can be considered an alias for `def`.
  +
  +[width="80%",align="center"]
  +|===
  +a| NOTE: _Incubating Status:_ Using `var` with `@CompileStatic` is regarded as an incubating feature.
  +Currently it is a direct alias for `def` which means in that scenario, type inference will be available
  +which yields similar behavior to Java in most cases.
  +Groovy's behavior does differ from Java in cases involving flow typing.
  +The _incubating_ status indicates that we reserve the right to change the behavior for these flow typing cases.
  +While some users have expressed the desire for a behavior closer to Java when `var` is used with `@CompileStatic` and flow typing,
  +we currently don't think the extra complexity in changing behavior is warranted.
  +We are however still exploring possibilities in this area.
  +|===
  +
   === ARM Try with resources
   
   Groovy often provides better alternatives to Java 7's `try`-with-resources statement for Automatic Resource Management (ARM).
  
positive.code: [[Groovy3.0releasenotes-Parrot]]
  == Parrot Parser
  
  Groovy 3.0, has a new parser that is far more flexible and maintainable than the parser in previous versions of Groovy. It's called the Parrot parser because in the early days of creating the parser, the goal was for the new parser's output to be an exact echo of what the old parser produced. The new parser has since been extended to support additional syntax options and language features.
  
  === Disabling the parser
  
  The new parser is enabled by default in Groovy 3.0.
  You can disable the new parser by using a system property.
  Use `-Dgroovy.antlr4=false` (set via `JAVA_OPTS` if needed).
  It is not envisaged that this property would be needed in normal
  use. However, at least initially, if you have a problematic source
  file that doesn't seem to work with the new parser, you may be
  able to revert to the old parser to compile just that file.
  You won't be able to use any of the new language features with the
  old parser. The old parser will be deprecated and eventually removed
  in future Groovy versions.
  
  === do/while loop
  
  
negative.code: 
  [width="80%",align="center"]
  |===
  a| NOTE: _Incubating Status:_ While this feature will remain, its current implementation, using traits, has incubating status.
  It results in the same behavior as Java's implementation but with less compact bytecode.
  We are still exploring approaches to also support native default methods in interfaces.
  |===
  
  === Other information about Parrot
  
  [width="80%",align="center"]
  |===
  a| NOTE: _Disabling Parrot:_ The new parser is enabled by default in Groovy 3.0.
  You can disable the new parser by using a system property.
  Use `-Dgroovy.antlr4=false` (set via `JAVA_OPTS` if needed).
  It is not envisaged that this property would be needed in normal
  use. However, at least initially, if you have a problematic source
  file that doesn't seem to work with the new parser, you may be
  able to revert to the old parser to compile just that file.
  You won't be able to use any of the new language features with the old parser.
  The old parser is deprecated and will be removed in Groovy 4.
  |===
  
  [[Groovy3.0releasenotes-Splitpackages]]
  