docs: add diagrams for facade, factory kit, factory method, factory, fan-out/fan-in, feature toggle, filterer, fluent interface, flyweight, front controller, function composition

Author: iluwatar

facade/README.md

@@ -33,6 +33,10 @@ Wikipedia says
 
 > A facade is an object that provides a simplified interface to a larger body of code, such as a class library.
 
+Sequence diagram
+
+![Facade sequence diagram](./etc/facade-sequence-diagram.png)
+
 ## Programmatic Example of Facade Pattern in Java
 
 Here's an example of the Facade Design Pattern in a goldmine scenario, demonstrating how a Java facade can streamline complex operations.

facade/etc/facade-sequence-diagram.png

@@ -32,6 +32,10 @@ In plain words
 
 > Factory kit is a configurable object builder, a factory to create factories.
 
+Sequence diagram
+
+![Factory Kit sequence diagram](./etc/factory-kit-sequence-diagram.png)
+
 ## Programmatic Example of Factory Kit Pattern in Java
 
 Imagine a magical weapon factory in Java capable of creating any desired weapon using the Factory Kit Pattern. This pattern allows for configurable object builders, making it ideal for scenarios where the types of objects are not known upfront.

factory-kit/README.md

@@ -36,6 +36,10 @@ Wikipedia says
 
 > In class-based programming, the factory method pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created. This is done by creating objects by calling a factory method — either specified in an interface and implemented by child classes, or implemented in a base class and optionally overridden by derived classes—rather than by calling a constructor.
 
+Sequence diagram
+
+![Factory Method sequence diagram](./etc/factory-method-sequence-diagram.png)
+
 ## Programmatic Example of Factory Method Pattern in Java
 
 The Factory Method approach is pivotal in Java Design Patterns for achieving flexible and maintainable code as we see in the following example.

factory-kit/etc/factory-kit-sequence-diagram.png

@@ -26,6 +26,10 @@ Wikipedia says
 
 > Factory is an object for creating other objects – formally a factory is a function or method that returns objects of a varying prototype or class.
 
+Sequence diagram
+
+![Factory sequence diagram](./etc/factory-sequence-diagram.png)
+
 ## Programmatic Example of Factory Pattern in Java
 
 Imagine an alchemist who is about to manufacture coins. The alchemist must be able to create both gold and copper coins and switching between them must be possible without modifying the existing source code. The factory pattern makes it possible by providing a static construction method which can be called with relevant parameters.

factory-method/README.md

@@ -35,6 +35,10 @@ Wikipedia says
 >
 > The fan-in concept, on the other hand, typically refers to the aggregation of multiple inputs. In digital electronics, it describes the number of inputs a logic gate can handle. Combining these concepts, the Fan-Out/Fan-In pattern in software engineering involves distributing tasks (fan-out) and then aggregating the results (fan-in).
 
+Sequence diagram
+
+![Fan-Out/Fan-In flowchart](./etc/fan-out-fan-in-flowchart.png)
+
 ## Programmatic Example of Fan-Out/Fan-In Pattern in Java
 
 The provided implementation involves a list of numbers with the objective to square them and aggregate the results. The `FanOutFanIn` class receives the list of numbers as `SquareNumberRequest` objects and a `Consumer` instance that collects the squared results as the requests complete. Each `SquareNumberRequest` squares its number with a random delay, simulating a long-running process that finishes at unpredictable times. The `Consumer` instance gathers the results from the various `SquareNumberRequest` objects as they become available at different times.