Interpreter 1.

Prezentace na téma: "Interpreter 1."— Transkript prezentace:

1 Interpreter 1

2 Co je to interpreter (interpret)
Motivace Obecný problém, jehož různé instance je třeba často řešit Jednotlivé instance lze vyjádřit větami v jednoduchém jazyce Obecné řešení Vytvoříme interpret tohoto jazyka Forma abstraktního syntaktického stromu Interpretace věty jazyka = řešení dané instance problému MOTIVATION If a particular kind of problem occurs often enough, then it might be worth while to express instances of the problem as sentences in a simple language. Then you can build an interpreter that solves the problem by interpreting these sentences. Example: - regular expressions. Rather than building custom algorithms to match each pattern against strings, search algorithms could interpret a regular expression that specifies a set of strings to match. boolean formula parsing xml into GUI The Interpreter pattern describes how to represent sentences in the language and interpret these sentences. In this example, the pattern describes how to define a grammar for regular expressions, represent a particular regular expression, and how to interpret that regular expression. 2

3 Ukázkový problém serializace objektové struktury v nějakém API

4 JSON primitivní typy kompozitní typy String int objekt pole {
"name": "Pepík Novák", "pets": [ "name": "Evžen", "age": 314, "species": "kaktus" }, "name": "Bob", "age": 3, "species": "krokodýl" } ], "job": { "companyName": "Flynix s.r.o.", "title": "pilot" JSON primitivní typy String int kompozitní typy objekt pole

5 Jak budeme serializovat?
JSON má stromovou strukturu, kterou musíme projít celou k serializaci jednoho vrcholu stromu potřebujeme již hotovou serializaci všech podstromů rekurzivní průběh serializace

6 Vnitřní reprezentace (1)
kompozice klasických objektů statická struktura specializovaný serializátor nebo reflexe vlastnosti vhodné pokud s datovými strukturami chceme pracovat v bussiness logice složitější na implementaci serializátoru

7 Vnitřní reprezentace (2)
interface JSONSerializable { String toJSON(); }

8 Vnitřní reprezentace (3)
reprezentace pomocí AST dynamicky proměnná struktura vlastnosti jednodušší napsání serializátoru obtížná práce s daty ve zbytku programu

9 Vnitřní reprezentace (4)

10 Samotná serializace v obou případech potřebujeme na všech typech přepsat metodu toJSON() zavoláme serialize na všech potomcích ze získaných hodnot poskládáme reprezentaci objektu

11 Implementace pro JSONObject
public class JSONObject extends JSON { HashMap<String, JSON> children; public String toJSON() { return "{ " + children.entrySet() .stream() .map(entry -> String.format( "\"%s\": %s", entry.getKey(), entry.getValue().toJSON() )) .collect(Collectors.joining(", ")) + " }"; } Implementace pro JSONObject

12 Návrhové principy SOLID
porušujeme single responsibility principle máme data a funkcionalitu na jednom místě kompromis u open-closed principle je jednoduché přidávat další vlastní typy s jejich vlastním způsobem serializace je složité přidat úplně nový druh serializace porušuje interface segregation principle závisí na jedné implementaci a není možné ji vyměnit

13 Interpreter – součásti vzoru
Vzor obsahuje: Gramatiku Popisující jazyk, v němž budeme přijímat instance problému Co nejjednodušší Reprezentaci gramatiky v kódu Pro každé pravidlo gramatiky specifikuje třídu Třídy jsou jednotně zastřešeny abstraktním předkem Vztahy mezi třídami (dědičnost) odpovídají gramatice Reprezentaci kontextu interpretace Vzor neobsahuje: Parser pro konstrukci syntaktického stromu instance problému Many reasons why the parser isn’t included: - external buffers required for full construction of the syntax tree - usage of creational patterns - customized parsing methods Every grammar rule is represented by one class: - non-terminal: class contains (pointers to) other objects - terminal: node defines transcription 13

14 Interpreter – struktura obecně
AbstractExpression (RegularExpression) - declares an abstract Interpret operation that is common to all nodes in the abstract syntax tree. TerminalExpression (LiteralExpression) - implements an Interpret operation associated with terminal symbols in the grammar. - an instance is required for every terminal symbol in a sentence. NonterminalExpression (AlternationExpression,RepetitionExpression, SequenceExpressions) - one such class is required for every rule R ::= R1 R2 ... Rn in the grammar. - maintains instance variables of type AbstractExpression for each of the symbols R1 through Rn. - implements an Interpret operation for nonterminal symbols in the grammar. Interpret typically calls itself recursively on the variables representing R1 through Rn. Context - contains information that's global to the interpreter Client - builds (or is given) an abstract syntax tree representing a particular sentence in the language that the grammar defines. The abstract syntax tree is assembled from instances of the NonterminalExpression and TerminalExpression classes. - invokes the Interpret operation. 14

15 Interpreter – účastníci
AbstractExpression Deklaruje abstraktní metodu Interpret() Implementace zajišťuje interpretaci zpracovávaného pojmu TerminalExpression Implementuje metodu Interpret() asociovanou s terminálem gramatiky Instance pro každý terminální symbol ve vstupu (větě) NonterminalExpression Implementuje metodu Interpret() neterminálu gramatiky Třída pro každé pravidlo R::=R1R2…RN gramatiky Udržuje instance proměnných typu AbstractExpression pro každý symbol R1…RN Context Udržuje globální informace Client Dostane (vytvoří) abstraktní syntaktický strom reprezentující konkrétní větu jazyka složený z instancí NonterminalExpression a TerminalExpression Volá metodu Interpret() Collaborations The client builds (or is given) the sentence as an abstract syntax tree of NonterminalExpression and TerminalExpression instances. - Then the client initializes the context and invokes the Interpretoperation. Each NonterminalExpression node defines Interpret in terms of Interpret on each subexpression. The Interpret operation of each TerminalExpression defines the base case in the recursion. - The Interpret operations at each node use the context to store and access the state of the interpreter. 15

16 Interpreter - ilustrace
Hudebník = interpereter Grammar = musical notation Context = tempo 16

17 Klasický příklad – gramatika
Příklad: gramatika regulárního výrazu expression ::= literal | alternation | sequence | repetition | '(' expression ')' alternation ::= expression '|' expression sequence ::= expression '&' expression repetition ::= expression '*' literal ::= 'a' | 'b' | 'c' | ... { 'a' | 'b' | 'c' | ... }* The Interpreter pattern uses a class to represent each grammar rule. Symbols on the right-hand side of the rule are instance variables of these classes. The grammar above is represented by five classes: an abstract class RegularExpression and its four subclasses LiteralExpression, AlternationExpression, SequenceExpression, and RepetitionExpression. The last three classes define variables that hold subexpressions. 17

18 Klasický příklad – reprezentace gramatiky
Příklad: gramatika regulárního výrazu expression ::= literal | alternation | sequence | repetition | '(' expression ')' alternation ::= expression '|' expression sequence ::= expression '&' expression repetition ::= expression '*' literal ::= 'a' | 'b' | 'c' | ... { 'a' | 'b' | 'c' | ... }* Abstraktní třída Její reprezentace v kódu Třída pro každé pravidlo gramatiky (instance udržují podvýraz), symboly na pravých stranách pravidel jsou v proměnných We can create an interpreter for these regular expressions by defining the Interpret operation on each subclass of RegularExpression. Interpret takes as an argument the context in which to interpret the expression. The context contains the input string and information on how much of it has been matched so far. Each subclass of RegularExpression implements Interpret to match the next part of the input string based on the current context. For example, - LiteralExpression will check if the input matches the literal it defines, - AlternationExpression will check if the input matches any of its alternatives, - RepetitionExpression will check if the input has multiple copies of expression it repeats, and so on. 18

19 Klasický příklad – reprezentace vět
Příklad: gramatika regulárního výrazu expression ::= literal | alternation | sequence | repetition | '(' expression ')' alternation ::= expression '|' expression sequence ::= expression '&' expression repetition ::= expression '*' literal ::= 'a' | 'b' | 'c' | ... { 'a' | 'b' | 'c' | ... }* Abstraktní syntaktický strom Každý regulární výraz je reprezentován abstraktním syntaktickým stromem, tvořeným instancemi zmíněných tříd Every regular expression defined by this grammar is represented by an abstract syntax tree made up of instances of these classes. For example, the abstract syntax tree. 19

20 Reprezentace regulárního výrazu
Klasický příklad – reprezentace vět Příklad: gramatika regulárního výrazu expression ::= literal | alternation | sequence | repetition | '(' expression ')' alternation ::= expression '|' expression sequence ::= expression '&' expression repetition ::= expression '*' literal ::= 'a' | 'b' | 'c' | ... { 'a' | 'b' | 'c' | ... }* Abstraktní syntaktický strom Každý regulární výraz je reprezentován abstraktním syntaktickým stromem, tvořeným instancemi zmíněných tříd Every regular expression defined by this grammar is represented by an abstract syntax tree made up of instances of these classes. For example, the abstract syntax tree. Reprezentace regulárního výrazu raining & ( dog | cats ) * 20

21 Příklad s booleovskými výrazy v Java(1)
Práce s booleovskými výrazy BooleanExp ::= VariableExp | Constant | OrExp | AndExp | NotExp | '(' BooleanExp ')' AndExp ::= BooleanExp 'and' BooleanExp OrExp ::= BooleanExp 'or' BooleanExp NotExp ::= 'not' BooleanExp Constant ::= 'true' | 'false' VariableExp ::= 'A' | 'B' | ... | 'X' | 'Y' | 'Z' Interface pro všechny třídy definující booleovský výraz interface BooleanExp { public bool interpret(Context context); }; Kontext definuje mapování proměnných na booleovské hodnoty tj. konstanty ‘true’ a ‘false’ The example is a system for manipulating and evaluating Boolean expressions implemented in C++The terminal symbols in this language are Boolean variables, that is, the constants true and false. Nonterminal symbols represent expressions containing the operators and, or, and not. We define two operations on Boolean expressions. The first, Evaluate, evaluates a Boolean expression in a context that assigns a true or false value to each variable. The second operation, Replace, produces a new Boolean expression by replacing a variable with an expression. Replace show the Interpreter pattern can be used for more than just evaluating expressions. In this case, it manipulates the expression itself. The class Context defines a mapping from variables to Boolean values, which we represent with the C++ constants true and false. For simplicity, we ignore operator precedence and assume it's the responsibility of which ever object constructs the syntax tree. class Context { public bool lookup(String name); public void assign(VariableExp exp, boolean bool); }; 21

22 Příklad s booleovskými výrazy v Java(2)
Třída pro reprezentaci pravidla VariableExp ::= 'A' | 'B' | ... | 'X' | 'Y' | 'Z‘ class VariableExp implements BooleanExp { private String name; VariableExp(String name){ this.name = name; }; public boolean interpret(Context context){ return context.lookup(name); } Třída pro reprezentaci pravidla Constant ::= 'true' | 'false' class Constant implements BooleanExp { private boolean bool; Constant(boolean bool){ this.bool = bool; }; public boolean interpret(Context context){ return bool; } Evaluating a variable returns its value in the current context. To replace a variable with an expression, we check to see if the variable has the same name as the one it is passed as an argument. 22

23 Obdobně také třídy pro pravidla
Příklad s booleovskými výrazy v Java(3) Třída pro reprezentaci pravidla AndExp ::= BooleanExp 'and' BooleanExp class AndExp implements BooleanExp { private BooleanExp operand1; private BooleanExp operand2; AndExp(BooleanExp op1, BooleanExp op2){ operand1 = op1; operand2 = op2; }; public boolean interpret(Context context){ return operand1.interpret(context) && operand2.interpret(context); Evaluating an AndExp evaluates its operands and returns the logical "and" of the results. An AndExp implements Copy and Replace by making recursive calls on its operands. Obdobně také třídy pro pravidla OrExp a NotExp 23

24 Příklad s booleovskými výrazy v Java(4)
Vytvoření instance výrazu a jeho interpretace BooleanExp expression; Context context; VariableExp x = new VariableExp("X"); VariableExp y = new VariableExp("Y"); expression = new OrExp( new AndExp(new Constant(true), x), new AndExp(y, new NotExp(x)) ); context.assign(x, false); context.assign(y, true); boolean result = expression.intepret(context); Vytvoření abstraktního syntaktického stromu pro výraz (true and x) or (y and (not x)) Ohodnocení proměnných The expression evaluates to true for this assignment to x and y. We can evaluate the expression with a different assignment to the variables simply by changing the context. Many kinds of operations can "interpret" a sentence. Of the three operations defined for BooleanExp, Evaluate fits our idea of what an interpreter should do most closely—that is, it interprets a program or expression and returns a simple result. However, Replace can be viewed as an interpreter as well. It's an interpreter whose context is the name of the variable being replaced along with the expression that replaces it, and whose result is a new expression. Even Copy can be thought of as an interpreter with an empty context. It may seem a little strange to consider Replace and Copy to be interpreters, because these are just basic operations on trees. The examples in Visitor (366) illustrate how all three operations can be refactored into a separate "interpreter" visitor, thus showing that the similarity is deep. Interpretuje výraz jako true, můžeme změnit ohodnocení a znovu provést interpretaci 24

25 Interpreter – použití s dalšími vzory
Composite Nejčastější kombinace Struktura stromu je implementace Composite Visitor podobný způsob procházení stromu oddělena funkcionalita od dat může nejen vypočítávat nějakou hodnotu, ale i data transformovat Iterator Klasické procházení strukturou Důležitý společný abstraktní předek Flyweight Typické pro překladače Sdílení konstantních výrazů vyhodnocovaných v compile-time 25

26 Interpreter – použití s dalšími vzory
Visitor Můžeme použít pro zvýšení udržitelnosti a možnosti rozšíření metody interpret S užitím polymorfismu na Visitor můžeme dosáhnout zcela různých interpretací Příklady: Aritmetické výrazy a přepínání mezi prefix, postfix a infix notací Booleovské výrazy – různá chování, např. vyhodnocení pravdivostní hodnoty formule a převod CNF Konfigurační soubory: převod mezi XML a plain-text formátem ... 26

27 Složitější příklad - kalkulačka
expression ::= plus | minus | variable | number plus ::= expression '+' expression minus ::= expression '-' expression variable ::= 'a' | 'b' | 'c' | ... | 'z' digit ::= '0' | '1' | ... | '9' number ::= digit | digit number Expression Language (also referred to as the EL), provides an important mechanism for enabling the presentation layer (web pages) to communicate with the application logic (managed beans). EL provides a way to use simple expressions to perform the following tasks: Dynamically read application data stored in JavaBeans components, various data structures, and implicit objects Dynamically write data, such as user input into forms, to JavaBeans components Invoke arbitrary static and public methods Dynamically perform arithmetic operations 27

28 Složitější příklad (2) – kalkulačka (java)
import java.util.Map; interface Expression { public int interpret(final Map<String, Expression> variables); } class Number implements Expression { private int number; public Number(final int number) { this.number = number; public int interpret(final Map<String, Expression> variables) { return number;

29 Složitější příklad (3) – kalkulačka (java)
class Plus implements Expression { Expression leftOperand; Expression rightOperand; public Plus(final Expression left, final Expression right) { leftOperand = left; rightOperand = right; } public int interpret(final Map<String, Expression> variables) { return leftOperand.interpret(variables) + rightOperand.interpret(variables); class Minus implements Expression { public Minus(final Expression left, final Expression right) { return leftOperand.interpret(variables) -

30 Složitější příklad (4) – kalkulačka (java)
class Variable implements Expression { private String name; public Variable(final String name) { this.name = name; } public int interpret(final Map<String, Expression> variables) { if (null == variables.get(name)) return 0; return variables.get(name).interpret(variables);

31 Interpreter - shrnutí KNOWN USAGE
Typické použití Parsery a kompilátory Omezení použitelnosti Interpretace jazyka, jehož věty lze vyjádřit abstraktním syntaktickým stromem Gramatika jazyka je jednoduchá Složitější gramatiky → nepřehledný kód, exploze tříd Efektivita není kriticky důležitá Jinak lépe nekonstruovat syntaktický strom → stavový automat Výhody lehce rozšířitelná/změnitelná gramatika jednoduchá implementace gramatiky přidávání dalších metod interpretace Nevýhody složitá gramatika těžce udržovatelná KNOWN USAGE The Interpreter pattern is widely used in compilers implemented with object-oriented languages, as the Smalltalk compilers are. SPECTalk uses the pattern to interpret descriptions of input file formats [Sza92]. The QOCA constraint-solving toolkit uses it to evaluate constraints [HHMV92]. Considered in its most general form (i.e., an operation distributed over a class hierarchy based on the Composite pattern), nearly every use of the Composite pattern will also contain the Interpreter pattern. But the Interpreter pattern should be reserved for those cases in which you want to think of the class hierarchy as defining a language. Specialized database query languages such as SQL. Specialized computer languages which are often used to describe communication protocols APPLICABILITY Use the Interpreter pattern when there is a language to interpret, and you can represent statements in the language as abstract syntax trees. The Interpreter pattern works best when - the grammar is simple. For complex grammars, the class hierarchy for the grammar becomes large and unmanageable. Tools such as parser generators are a better alternative in such cases. They can interpret expressions without building abstract syntax trees, which can save space and possibly time. - efficiency is not a critical concern. The most efficient interpreters are usually not implemented by interpreting parse trees directly but by first translating them into another form. For example, regular expressions are often transformed into state machines. But even then, the translator can be implemented by the Interpreter pattern, so the pattern is still applicable. 31