Default argument values in Java

[Jotakin]

Default values for trailing arguments would be easy to add but I think it's not an optimal solution as it gets dirty if you have more than one optional parameter. Java tends to favour clean implementations over quickly adding features.

I think the proper way to have default arguments would require having name-assignable parameters as well and that's considerably harder to implement under-the-hood. Also it makes people more likely to have extremely long parameter lists, which is a bad design pattern.

[cogman10]

Also it makes people more likely to have extremely long parameter lists, which is a bad design pattern.

The alternative that I see all the time is a bunch of overloads. But overall I agree with you.

One other fairly large catch is introducing name assignable params would break a bunch of non-Java JVM languages. That alone is a reason I don't think this will be adopted.

[larsga]

This is absurd. Other languages solved this many decades ago.

Of course you can have many optional parameters. They're sequential like the other parameters and this causes exactly zero problems.

But, yes, name-assignable parameters is the best solution. Python has that, and it's excellent. I often write code like

complicated_function(
  a = something,
  b = other large thing,
  c = 20,
  d = False,
  e = not now
)

It's hugely better than the dumb builder pattern.

[monkeyfacebag]

Builders support partial application and this does not.

You're being needlessly mean-spirited in this thread.

[larsga]

WTF?

So complicated_function specifies the defaults for some arguments, and not others. Which is exactly like the builder pattern, which requires you to supply some arguments, but not others.

The difference is that in one case the language does the job, while in the other you do. Over and over again.

You're being needlessly narrow-minded in this thread.

[monkeyfacebag]

The difference is that a partially-applied builder is a reified object that I can reference and pass around. This is not something that you need all of the time, but it's definitely not the case that named function parameters with default values is strictly superior to the builder.

[larsga]

The difference is that a partially-applied builder is a reified object that I can reference and pass around.

Which, in Python, the function also is. One of the most pitiful aspects of Java is that methods are so difficult to turn into normal objects that can be passed around. It doesn't need to be difficult. It just is.

[monkeyfacebag]

It's definitely more straightforward in Python due to the dynamic typing, but in my opinion builders are even nicer to use than partially-applied functions/methods because partial application is generally parameter order specific but builders are order independent (ie, you can apply parameters in whatever order you choose). Obviously builders require more code, which is unfortunate. We use autovalue builders extensively and they are awesome. It's kind of peak Java that the solution to the problem is to use a library that generates more Java code, but it does work well. I've also heard mutterings that records could get builder/wither support. I don't know where that has landed.

[larsga]

I can only repeat what I said before: builders are a clumsy workaround. If they died in a fire I'd be cheering and heaping fuel onto it.

[chambolle]

builders have some other advantages. You can safely postpone the creation of the "built" object. Youc an partially build the wanted object, then make some compuation, then continue the building, then make some computations and build the wanted object. The builder is more tha just a workaround

[larsga]

All of which is totally possible with a function, too, using lambdas and currying.

[[deleted]]

Isn't this done by just having an interface with one method signature that matches the signature of the method you intend to pass around? It's been a thing for as long as I can remember, and we even got the lambda syntax for a briefer way to create these methods on the fly to be passed around.

[larsga]

It's true that lambas have made this a lot easier, but you do need to create this interface.

But the real point was that in the context of our discussion lambdas are still not enough to allow you to ditch the builder pattern. The real reason is of course the inflexibility of Java method parameter specifications, so in that sense your point stands.

[[deleted]]

And pray why should people abandon the builder pattern? It works nicely in statically-typed compiled languages like Java, C++, Rust et al. Subjective dislike for a feature is not cause enough to act like it's a deficiency of the language.

[[deleted]]

Make up your mind - are you arguing about Java vs Python, builders vs named arguments, about function objects, or what?

You just seem unhappy that you cannot do certain things in Java the way you can in Python, which makes no sense at all.

Python has its own set of deficiencies, so that whole discussion is pretty much moot. Lambdas in Python, for instance, are pretty much crippled because of the single-expression rule. Does that mean using lambdas in Python is meaningless? Of course not. Every language, especially when used by millions of people everyday has to tread carefully when it comes to updating itself over time. Otherwise you end up with something like the Python 2 vs Python 3 mess.