Editing Interpreter pattern (section)

==Overview==
The Interpreter
<ref name="GoF2">{{cite book|author=Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides|title=Design Patterns: Elements of Reusable Object-Oriented Software|year=1994|publisher=Addison Wesley|isbn=0-201-63361-2|pages=[https://archive.org/details/designpatternsel00gamm/page/243 243ff]|url-access=registration|url=https://archive.org/details/designpatternsel00gamm/page/243}}</ref>
design pattern is one of the twenty-three well-known 
''[[Design Patterns|GoF design patterns]]'' 
that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.

===What problems can the Interpreter design pattern solve?===

Source:<ref>{{cite web|title=The Interpreter design pattern - Problem, Solution, and Applicability|url=http://w3sdesign.com/?gr=b03&ugr=proble|website=w3sDesign.com|access-date=2017-08-12}}</ref>

* A [[Backus-Naur form|grammar]] for a simple language should be defined
* so that sentences in the language can be interpreted.

When a problem occurs very often, it could be considered to represent it as a sentence in a simple language
([[Domain-specific language|Domain Specific Languages]]) so that an interpreter can solve the problem
by interpreting the sentence.

For example, when many different or complex search expressions must be specified.
Implementing (hard-wiring) them directly into a class is inflexible
because it commits the class to particular expressions and makes it impossible to specify new expressions or change existing ones independently from (without having to change) the class.

===What solution does the Interpreter design pattern describe?===
* Define a grammar for a simple language by defining an <code>Expression</code> class hierarchy and implementing an <code>interpret()</code> operation.
* Represent a sentence in the language by an abstract syntax tree (AST) made up of <code>Expression</code> instances.
* Interpret a sentence by calling <code>interpret()</code> on the AST.

The expression objects are composed recursively into a composite/tree structure that is called
''abstract syntax tree'' (see [[Composite pattern]]).
<br>The Interpreter pattern doesn't describe how
to build an abstract syntax tree. This can
be done either manually by a client or automatically by a [[parser]].

See also the UML class and object diagram below.