This is a good example of a feature that can be experimented with as an external AST transformation, there's no need to add it to core just yet.
Advantages of such approach: - faster development/release cycle. - can target specific Groovy version to begin with. - may break compatibility until feature works as expected. Adding this feature to core in an early stage (conception) is too early IMHO. Remember that @TailCall started life as an external AST xform, it was added to core when it became mature enough :-) Cheers, Andres ------------------------------------------- Java Champion; Groovy Enthusiast JCP EC Associate Seat http://andresalmiray.com http://www.linkedin.com/in/aalmiray -- What goes up, must come down. Ask any system administrator. There are 10 types of people in the world: Those who understand binary, and those who don't. To understand recursion, we must first understand recursion. On Tue, Aug 14, 2018 at 1:28 PM, ocs@ocs <o...@ocs.cz> wrote: > Gentlemen, > > some NPE-related problems of today brought me to re-interate one of my > older suggestions. > > We have the so-called “safe navigation”[*], which in some cases allows a > null to be propagated out of an expression instead of throwing a NPE. At > the moment, it can be triggered for a particular sub-expression (like > property/method-call and, as of 3, newly also indexing) using a question > mark (e.g., “foo?.bar()” or “foo?[bar]”). > > Do please correct me if I am wrong, but far as I know, there still are > expressions which do not allow the “safe mode”, e.g., arithmetic (“a+b” > etc). Furthermore, there are cases when one simply wants a bigger block of > code to contain only null-propagating expressions and never NPE; in such > case, using the question mark syntax is both inconvenient and error-prone > (for it is very easy to forget one of the lot of question marks needed in > such a code, and then get an uncaught unwanted NPE). > > For these reasons, I would suggest adding a new annotation, whose name > might be e.g., “ImplicitSafeNavigation”; it would simply force a > null-propagation to be implicitly and automatically used for *all* > expressions in the annotated scope, i.e., NPE would never be thrown for > them; for example: > > === > @ImplicitSafeNavigation class Foo { > static foo(a,b,c,d,e) { > a.bar+b*c[d]<<e.bax() // just e.g.; would work with *any* expression > which NPEs today > } > } > assert null == Foo.foo(null,null,null,null,null) > === > > I wonder whether this enhancement would be possible to implement in some > forthcoming Groovy release? Myself, I believe it would help tremendously. > > If feasible, then it is for a further discussion whether in the scope of > this annotation > (a) a safe-navigation syntax (“foo?.bar”) should be ignored as superfluous; > (b) or, whether in this scope it should reverse the behaviour to trigger > an NPE anyway; > (c) or, whether it should be ignored as (a), and aside of that it would be > worth the effort (and technically possible) to add another syntax to force > NPE over a particular sub-expression (e.g., “foo!.bar”). > > Thanks and all the best, > OC > > [*] The name might not be quite apt, for propagating a null is not > inherently safer than NPEing; those are simply two different approaches, > both of which serve best in different circumstances. A better name would be > something like “null-propagating” or “non-NPE” mode, I guess. Myself, I > don't think we should change the name though, for all are used to it. > >
