What's a fluent interface?

Question

I recently came across this expression - but reading up on Wikipedia did not clarify it much for me - I still don't get it:

1. What's the point of it
2. How is it used in practice (i.e. how does it benefit a coder in their day to day work/building systems)?

[Edit] The Wikipedia article C++ example is overly long, and conflates the discussion of a fluent interface with an example of a simple Glut app. Can someone provide a SUCCINCT C++ example of a class that illustrates a fluent interface (how does such an influence differ from an ordinary C++ interface for example)?

Answer 1

There are different interpretations of the term "fluent interface". A common way to create one in C++ is method chaining, which is commonly used in for example the iostream library:

Object.MethodA().MethodB();
cout << "a = " << a;

The Named Parameter Idiom is another nice example of a fluent interface:

Window w = CreateWindow()
               .Width(400)
               .Height(300)
               .OnTop();

The benefits? Code that's better readable and more flexible, although that still depends on the implementation of course.

Answer 2

One big difference and advantage of the fluent interface is that you don't need an instance variable to change some properties when you want to create an object and use it as an argument:

without:

Object object;
object.setcolor("red"); 
object.setstyle("solid");
object.setname("test");
world.CreateNode(object);

with fluent interface:

world.CreateNode(Object()
                                           .setcolor("red")
                                           .setstyle("solid")
                                           .setname("test")
                             );

Answer 3

CallStream aka "Why the dot's ?" :)

Nothing wrong with a bit of (very simple) JavaScript to describe new and important concepts. Perfectly doable in C++, too.cept

Key concept: using Functional Programming idiom, describe the interface. Without using: message argument as a string, to be parsed, concept.

I think it is mostly related to the "Facade" pattern, but yes, it is related to a "Builder pattern". And it seems it survived the "Monads" too.

btw: All the advocates above have presented very good use-cases.