Ah, I though we are discussing the real usage/support, not just the documentation (which of course can be always improved).
Most probably the proper solution would be change the documentation to something more-or-less like === [def explained without mentioning var] Note that for a seamless compatibility with a Java legacy code, you can also use var, which can be placed where Java allows it (typically variable declarations) and where applicable, it is fully equivalent to def. === Myself, I would also add something like === Although var does work and will work in future all right, when (if ever) the code is “groovyfied” by removing semicolons, replacing for(:) by for/in etc., we also recommend to replace vars by defs for consistence (there is no functional difference though; if you like var personally, feel free to stick with it, just like you can freely stick with semicolons). === Incidentally, myself, I don't like the “Object alias” part. To me it seems rather misleading. Frankly I don't know how it currently works (and what changes, if any, are presumed for future), but in my personal opinion there's a subtle but important difference: def is just about anything (and should support type inference far as reasonably possible). Object is an instance of the Object class (and whether it should infer types even if possible or not is highly arguable). Nevertheless this path leads to a need to support something like ObjC __kindof, which Groovy (far as I know) currently has not, along with better dynamic typechecking etc., and would open another big can of worms. To me, nothing of this seems too important though (and had I understood we are debating docs only, I would not write my previous message quoted below). Even if the documentation is imperfect (any documentation always is), it gives a good overall idea how things work; the fine details can be easily learnt later. Thanks and all the best, OC > On 10. 12. 2024, at 15:21, Gianluca Sartori <g.sart...@gmail.com> wrote: > > I might be wrong and I might have misunderstood something of importance, but > it seems to me there is one (and only one) very specific need to use var: > ensuring a code copy/pasted from Java works (with as little number of > problems as reasonably possible). > > This is what I understood as well reading the docs, but it looks like `var` > is starting to become a full part of the Groovy syntax because it has been > documented along with `def` as equal to `def` (but only for variable > definitions). > >> I would like to use `var` as a return type placeholder meaning "this method >> returns a variable" > > What does it mean? Far as I know (but of course, my knowledge is limited), > there's no var-ref type in Java (nor Groovy), and thus no method can return a > variable. Have I missed something of importance again? > > You have missed that part in the docs where it says: > > If you think of def and var as an alias of Object, you will understand in > > an instant. > > So if `var` is an alias for `Object` one should be able to use it as a type > placeholder in method return types as well, but that's not the case > > >
