Comments on: Caller context and list.add(..).add(..).add(..)

By: Helly

Helly — Fri, 02 Jun 2006 23:49:21 +0000

captive

By: Greg Dennis

Greg Dennis — Fri, 15 Apr 2005 22:40:46 +0000

I think chained-methods are nice and useful, but they give the impression that the object is immutable — that it has to return a new instance rather than perform a mutation. The last thing you want is for clients not to realize they are mutating an object when they are. I would recommend using chained methods if and only if the object is immutable.

If there’s one exception, it’s StringBuffer, because (1) it’s used so frequently; (2) it so significantly reduces the amount of code; and (3) it’s very well known that it’s mutable.

By: Roger Desroches

Roger Desroches — Thu, 14 Apr 2005 18:04:43 +0000

Just change it to

mockSubscriber.expects(once())
&nbsp .method(”receive”).
&nbsp .with( same(message) );

The line number of the exception will reflect the line call. Also, the exception itself will reflect which method call; either expects, once() method, with, same, or the calling method.

I use “chained calls” all the time with string buffers.

StringBuffer buf = new StringBuffer();
buf.append(”There have been “)
&nbsp .append(count)
&nbsp .append(” errors in the “)
&nbsp .append(systemName)
&nbsp .append(” system in the last “)
&nbsp .append(timeDelta).append(” “)
&nbsp .append(timeGranularity);

By: icoloma

icoloma — Wed, 13 Apr 2005 18:44:24 +0000

This is not a good thing. Get a NPE in this sentence and try to debug it.

Java is not english, don’t try to make it so.

mockSubscriber.expects(once()).method(”receive”).with( same(message) );

By: Sam Newman

Sam Newman — Wed, 13 Apr 2005 10:48:45 +0000

Can I suggest looking at the Law of demeter? It’s been around a while: http://c2.com/cgi/wiki?LawOfDemeter

It’s one of those OO things.

Using “it’s in the Java API!” as justification for something has left us with a large amount of code that’s as nice to use as the calendar API. The JMock example is something else entirely – there it’s using the syntax of Java to produce readable assertions – it’s an allowable exception (in my opinion) to the law of demeter.

By: David Flanagan

David Flanagan — Wed, 13 Apr 2005 08:23:44 +0000

java.nio has chained methods.

In the right API, and used in moderation, they can be cool. But Keith is right that they can easily be abused and lead to ugly, confusing code.

By: Cameron

Cameron — Wed, 13 Apr 2005 05:16:42 +0000

That Keith dude is right on. Your complaint is with the language, not with the return value declaration! What you really are asking for is a “with” clause. Peace.

By: Keith Lea

Keith Lea — Tue, 12 Apr 2005 22:42:51 +0000

I think that chained method calls are ugly, confusing, and that they pollute the simplicity of Java.

By: Ross Judson

Ross Judson — Tue, 12 Apr 2005 21:00:18 +0000

Let this be a lesson to you, young man. Do not attempt to put type annotations into comment examples ;)

By: Ross Judson

Ross Judson — Tue, 12 Apr 2005 20:59:08 +0000

I’ve been working on a JDK 5 library that lets you do something like what you’re talking about. I started with the notion that Iterable was a good thing, but Stream extends Iterable could be much better. Note that as calls are made in these examples the full type of the stream is preserved…if you create a subclass of the stream types you still get to call your subclass’s methods.

Hopefully it’ll get to the point where I can put it out somewhere. Right now I use it to do lots of different things; SQL-like data selection, reflection over object graphs, etc…

A couple of call examples follow.

public void testPipeline() {
Pipeline pipeStart = new Pipeline();

Stream> is = pipeStart
.shuffle()
.first(5)
.sort()
.transform(new Transform(){
public String transform(Integer from)
{
return “Hello ” + from;
}})
.end(pipeStart);

is = is.insert(Integers.random(25));
is.dump(”Hello “);

System.out.println(is.getClass().getName());

//.dump(”Hello”);

}

public void testAugment2() {
randomEmployees(100)
.where(new Transform() {
public Boolean transform(Employee from) {
return from.getName().startsWith(”Kurt”);
}})
.dump(”Employees starting with Kurt”)
.transform(new Transform>() {
public Tuple2 transform(Employee from) {
return Tuple.make(from, from.hashCode());
} })
.dump(”Employee–hashcode tuples”);
}