task: Explanations and grammar fixes for all the GoF patterns (#1791)

* Grammatical fixes to command pattern

* Update bridge pattern readme

* Fixes to builder pattern grammar

* Update chain of responsibility

* Improvements to the composite example

* Fixes to headings

* Minor updates to decorator pattern

* Update facade

* Update factory example

* Update factory method

* Update flyweight

* Interpreter explanation

* Update iterator readme

* Add explanation for mediator pattern

* Grammatical fixes to memento

* Grammar fixes for observer

* Update explanation for the prototype pattern

* Proxy pattern grammar fixes

* Update singleton

* Grammar fixes to state pattern

* Grammar fixes for strategy

* Grammar fixes, template method

* Grammar fixes for visitor

* Fix typo

interpreter/src/main/java/com/iluwatar/interpreter/App.java

@@ -34,25 +34,33 @@ import lombok.extern.slf4j.Slf4j;
  *
  * <p>In this example we use the Interpreter pattern to break sentences into expressions ({@link
  * Expression}) that can be evaluated and as a whole form the result.
+ *
+ * <p>Expressions can be evaluated using prefix, infix or postfix notations This sample uses
+ * postfix, where operator comes after the operands.
+ *
  */
 @Slf4j
 public class App {
 
   /**
    * Program entry point.
-   *
-   * <p>Expressions can be evaluated using prefix, infix or postfix notations This sample uses
-   * postfix, where operator comes after the operands.
-   *
-   * @param args command line args
+   * @param args program arguments
    */
   public static void main(String[] args) {
-    var tokenString = "4 3 2 - 1 + *";
+
+    // the halfling kids are learning some basic math at school
+    // define the math string we want to parse
+    final var tokenString = "4 3 2 - 1 + *";
+
+    // the stack holds the parsed expressions
     var stack = new Stack<Expression>();
 
+    // tokenize the string and go through them one by one
     var tokenList = tokenString.split(" ");
     for (var s : tokenList) {
       if (isOperator(s)) {
+        // when an operator is encountered we expect that the numbers can be popped from the top of
+        // the stack
         var rightExpression = stack.pop();
         var leftExpression = stack.pop();
         LOGGER.info("popped from stack left: {} right: {}",
@@ -60,24 +68,36 @@ public class App {
         var operator = getOperatorInstance(s, leftExpression, rightExpression);
         LOGGER.info("operator: {}", operator);
         var result = operator.interpret();
+        // the operation result is pushed on top of the stack
         var resultExpression = new NumberExpression(result);
         stack.push(resultExpression);
         LOGGER.info("push result to stack: {}", resultExpression.interpret());
       } else {
+        // numbers are pushed on top of the stack
         var i = new NumberExpression(s);
         stack.push(i);
         LOGGER.info("push to stack: {}", i.interpret());
       }
     }
+    // in the end, the final result lies on top of the stack
     LOGGER.info("result: {}", stack.pop().interpret());
   }
 
+  /**
+   * Checks whether the input parameter is an operator.
+   * @param s input string
+   * @return true if the input parameter is an operator
+   */
   public static boolean isOperator(String s) {
     return s.equals("+") || s.equals("-") || s.equals("*");
   }
 
   /**
-   * Get expression for string.
+   * Returns correct expression based on the parameters.
+   * @param s input string
+   * @param left expression
+   * @param right expression
+   * @return expression
    */
   public static Expression getOperatorInstance(String s, Expression left, Expression right) {
     switch (s) {
@@ -85,8 +105,6 @@ public class App {
         return new PlusExpression(left, right);
       case "-":
         return new MinusExpression(left, right);
-      case "*":
-        return new MultiplyExpression(left, right);
       default:
         return new MultiplyExpression(left, right);
     }