[POLL] Method Chaining: Good or Evil?
Method chaining is the practice of object methods returning the object itself in order for the result to be called for another method. Like this:
This seems to be considered a good practice, since it produces readable code, or a "fluent interface". However, it instead seems to break the object calling notation implied by the object orientation itself - the resulting code does not represent performing actions to the result of a previous method, which is how object oriented code is generally expected to work:
This difference manages to create two different meanings for the dot-notation of "calling the resulting object": In the context of chaining, the above example would read as saving the participant object, even though the example is in fact intended to save the schedule object received by getSchedule.
Difference here is whether the called method should be expected to return something or not (in which case it would return the called object itself for chaining). But these two cases are not distinguishable from the notation itself, only from the semantics of the methods being called. When method chaining is not used, you can always know that a method call operates on something related to the result of the previous call - with chaining, this assumption breaks, and you have to semantically process the whole chain to understand what the actual object being called really is. For example:
There the last two method calls refer to the result of getSocialStream, whereas the ones before refer to the participant. Maybe it's bad practice to actually write chains where the context changes (is it?), but even then you'll have to constantly check whether dot-chains that look similar are in fact keep within the same context, or only work on the result.
It appears that while method chaining superficially does produce readable code, overloading the meaning of the dot-notation only results in more confusion. So: What am I missing? Do I understand method chaining somehow wrong? Are there some cases where method chaining is especially good, or some where it's especially bad?