はじめに
皆さん、こんにちは！「JavaとPythonで比べるデザインパターン」シリーズの第17回目です。
今回は、独自の文法やドメイン固有言語（DSL）を構築し、それを解釈・実行するためのInterpreter（インタープリター）パターンについて詳しく解説します。
Interpreterパターンとは？
Interpreterパターンは、特定の文法規則を持つ言語を定義し、その文を解釈・実行する振る舞いパターンです。このパターンでは、文法の各ルールをクラスで表現し、抽象構文木（AST: Abstract Syntax Tree）を構築して、再帰的に文を解釈します。
身近な例：スマート家電の音声コマンド解釈システム
現代のスマート家電では、自然言語に近い音声コマンドを解釈する機能があります：
音声コマンドの例
"リビングの照明を50%にして、温度を22度に設定"
↓ 解釈・分解
├── "リビングの照明を50%にして" → SetBrightnessCommand(room="living", value=50)
└── "温度を22度に設定" → SetTemperatureCommand(value=22)
従来の固定コマンド方式
switch(command) {
case "LIGHT_ON": turnOnLight(); break;
case "LIGHT_OFF": turnOffLight(); break;
case "TEMP_UP": increaseTemp(); break;
// 新しいコマンド追加時にはコード修正が必要
}
Interpreterパターン適用後
Command Grammar Definition:
SetCommand := "set" + Device + "to" + Value
Device := "light" | "temperature" | "volume" | ...
Value := Number | Percentage | State
新しいコマンドは文法定義の追加のみで対応可能
Interpreterパターンの核心価値
1. 文法とロジックの分離
- 文法定義: 言語の構造を抽象構文木として表現
- 解釈ロジック: 各ノードが自身の解釈方法を知っている
- 実行エンジン: 構文木を走査して処理を実行
2. 拡張性の確保
- 新しい文法ルールの追加が既存コードに影響しない
- コンポジットパターンとの組み合わせで柔軟な構造
- 再帰的な処理により複雑な式も単純な構造で表現
3. ドメイン固有言語（DSL）の構築
- ビジネスルールを自然な形で表現
- 非プログラマーでも理解しやすい記法
- 設定ファイルやクエリ言語の実装基盤
抽象構文木（AST）の構造理解
Expression: (x + 5) * (y - 2)
MultiplyExpression
/ \
AddExpression SubtractExpression
/ \ / \
Variable(x) Number(5) Variable(y) Number(2)
各ノードがinterpret()メソッドを持ち、子ノードの結果を使って自身の計算を行います。
Javaでの実装：型安全性と厳密な文法定義
Javaでは、インターフェースと抽象クラスを活用して、厳密で拡張可能な言語処理システムを構築できます。
実装例：ビジネスルール評価エンジン
import java.util.*;
import java.util.function.Function;
// 抽象式インターフェース
interface Expression {
Object interpret(Context context);
String toString();
}
// コンテキスト（実行時の状態管理）
class Context {
private final Map<String, Object> variables = new HashMap<>();
private final Map<String, Function<Object[], Object>> functions = new HashMap<>();
public void setVariable(String name, Object value) {
variables.put(name, value);
}
public Object getVariable(String name) {
return variables.get(name);
}
public void defineFunction(String name, Function<Object[], Object> function) {
functions.put(name, function);
}
public Object callFunction(String name, Object... args) {
Function<Object[], Object> function = functions.get(name);
if (function != null) {
return function.apply(args);
}
throw new RuntimeException("Undefined function: " + name);
}
public boolean hasVariable(String name) {
return variables.containsKey(name);
}
}
// 終端式：数値リテラル
class NumberExpression implements Expression {
private final double value;
public NumberExpression(double value) {
this.value = value;
}
@Override
public Object interpret(Context context) {
return value;
}
@Override
public String toString() {
return String.valueOf(value);
}
}
// 終端式：文字列リテラル
class StringExpression implements Expression {
private final String value;
public StringExpression(String value) {
this.value = value;
}
@Override
public Object interpret(Context context) {
return value;
}
@Override
public String toString() {
return "\"" + value + "\"";
}
}
// 終端式：変数参照
class VariableExpression implements Expression {
private final String name;
public VariableExpression(String name) {
this.name = name;
}
@Override
public Object interpret(Context context) {
if (context.hasVariable(name)) {
return context.getVariable(name);
}
throw new RuntimeException("Undefined variable: " + name);
}
@Override
public String toString() {
return name;
}
}
// 抽象基底クラス：二項演算
abstract class BinaryExpression implements Expression {
protected final Expression left;
protected final Expression right;
public BinaryExpression(Expression left, Expression right) {
this.left = left;
this.right = right;
}
protected abstract Object operate(Object leftValue, Object rightValue);
protected abstract String getOperator();
@Override
public Object interpret(Context context) {
Object leftValue = left.interpret(context);
Object rightValue = right.interpret(context);
return operate(leftValue, rightValue);
}
@Override
public String toString() {
return "(" + left.toString() + " " + getOperator() + " " + right.toString() + ")";
}
}
// 具象二項演算：加算
class AddExpression extends BinaryExpression {
public AddExpression(Expression left, Expression right) {
super(left, right);
}
@Override
protected Object operate(Object leftValue, Object rightValue) {
if (leftValue instanceof Number && rightValue instanceof Number) {
return ((Number) leftValue).doubleValue() + ((Number) rightValue).doubleValue();
}
// 文字列結合もサポート
return leftValue.toString() + rightValue.toString();
}
@Override
protected String getOperator() {
return "+";
}
}
// 具象二項演算：減算
class SubtractExpression extends BinaryExpression {
public SubtractExpression(Expression left, Expression right) {
super(left, right);
}
@Override
protected Object operate(Object leftValue, Object rightValue) {
if (leftValue instanceof Number && rightValue instanceof Number) {
return ((Number) leftValue).doubleValue() - ((Number) rightValue).doubleValue();
}
throw new RuntimeException("Subtraction requires numeric operands");
}
@Override
protected String getOperator() {
return "-";
}
}
// 具象二項演算：乗算
class MultiplyExpression extends BinaryExpression {
public MultiplyExpression(Expression left, Expression right) {
super(left, right);
}
@Override
protected Object operate(Object leftValue, Object rightValue) {
if (leftValue instanceof Number && rightValue instanceof Number) {
return ((Number) leftValue).doubleValue() * ((Number) rightValue).doubleValue();
}
throw new RuntimeException("Multiplication requires numeric operands");
}
@Override
protected String getOperator() {
return "*";
}
}
// 具象二項演算：比較
class GreaterThanExpression extends BinaryExpression {
public GreaterThanExpression(Expression left, Expression right) {
super(left, right);
}
@Override
protected Object operate(Object leftValue, Object rightValue) {
if (leftValue instanceof Number && rightValue instanceof Number) {
return ((Number) leftValue).doubleValue() > ((Number) rightValue).doubleValue();
}
throw new RuntimeException("Comparison requires numeric operands");
}
@Override
protected String getOperator() {
return ">";
}
}
// 条件式（三項演算子）
class ConditionalExpression implements Expression {
private final Expression condition;
private final Expression trueExpression;
private final Expression falseExpression;
public ConditionalExpression(Expression condition, Expression trueExpression, Expression falseExpression) {
this.condition = condition;
this.trueExpression = trueExpression;
this.falseExpression = falseExpression;
}
@Override
public Object interpret(Context context) {
Object conditionValue = condition.interpret(context);
boolean isTrue = false;
if (conditionValue instanceof Boolean) {
isTrue = (Boolean) conditionValue;
} else if (conditionValue instanceof Number) {
isTrue = ((Number) conditionValue).doubleValue() != 0;
}
return isTrue ? trueExpression.interpret(context) : falseExpression.interpret(context);
}
@Override
public String toString() {
return condition + " ? " + trueExpression + " : " + falseExpression;
}
}
// 関数呼び出し式
class FunctionCallExpression implements Expression {
private final String functionName;
private final List<Expression> arguments;
public FunctionCallExpression(String functionName, Expression... arguments) {
this.functionName = functionName;
this.arguments = Arrays.asList(arguments);
}
@Override
public Object interpret(Context context) {
Object[] argValues = arguments.stream()
.map(arg -> arg.interpret(context))
.toArray();
return context.callFunction(functionName, argValues);
}
@Override
public String toString() {
return functionName + "(" +
arguments.stream().map(Object::toString).reduce((a, b) -> a + ", " + b).orElse("") +
")";
}
}
// 使用例とテストケース
public class BusinessRuleEngine {
public static void main(String[] args) {
Context context = new Context();
// 変数の設定
context.setVariable("customerAge", 25);
context.setVariable("purchaseAmount", 1000.0);
context.setVariable("customerType", "PREMIUM");
// 関数の定義
context.defineFunction("max", args -> {
double max = Double.NEGATIVE_INFINITY;
for (Object arg : args) {
if (arg instanceof Number) {
max = Math.max(max, ((Number) arg).doubleValue());
}
}
return max;
});
context.defineFunction("discount", args -> {
if (args.length >= 2 && args[0] instanceof Number && args[1] instanceof String) {
double amount = ((Number) args[0]).doubleValue();
String type = (String) args[1];
switch (type) {
case "PREMIUM": return amount * 0.1;
case "STANDARD": return amount * 0.05;
default: return 0.0;
}
}
return 0.0;
});
// 複雑なビジネスルールの構築
// "年齢が18歳以上で、購入額が500以上の場合、割引を適用"
Expression ageCheck = new GreaterThanExpression(
new VariableExpression("customerAge"),
new NumberExpression(18)
);
Expression amountCheck = new GreaterThanExpression(
new VariableExpression("purchaseAmount"),
new NumberExpression(500)
);
Expression discountCalculation = new FunctionCallExpression(
"discount",
new VariableExpression("purchaseAmount"),
new VariableExpression("customerType")
);
Expression finalDiscount = new ConditionalExpression(
new MultiplyExpression(ageCheck, amountCheck), // AND演算（数値的）
discountCalculation,
new NumberExpression(0)
);
// ルールの実行
System.out.println("Business Rule: " + finalDiscount);
System.out.println("Result: " + finalDiscount.interpret(context));
// より複雑な例：動的価格計算
Expression dynamicPrice = new AddExpression(
new VariableExpression("purchaseAmount"),
new SubtractExpression(
new FunctionCallExpression("max",
new NumberExpression(50),
new MultiplyExpression(new VariableExpression("purchaseAmount"), new NumberExpression(0.02))
),
discountCalculation
)
);
System.out.println("Dynamic Price Calculation: " + dynamicPrice);
System.out.println("Final Price: " + dynamicPrice.interpret(context));
}
}
Javaの特徴と利点
- 型安全性: コンパイル時に文法違反を検出
- 拡張性: 新しい演算子や関数を簡単に追加
- デバッグ支援: スタックトレースによる詳細なエラー情報
- パフォーマンス: JIT コンパイルによる最適化
Pythonでの実装：動的性と柔軟性を活かす
Pythonでは、動的型付けの特性とメタプログラミング機能を活用して、より柔軟で表現力豊かな言語処理システムを構築できます。
from abc import ABC, abstractmethod
from typing import Any, Dict, Callable, List, Union
import operator
import re
# 抽象基底クラス
class Expression(ABC):
@abstractmethod
def interpret(self, context: 'Context') -> Any:
pass
@abstractmethod
def __str__(self) -> str:
pass
# コンテキスト（実行時状態管理）
class Context:
def __init__(self):
self.variables: Dict[str, Any] = {}
self.functions: Dict[str, Callable] = {}
# 組み込み関数の定義
self.define_function('max', max)
self.define_function('min', min)
self.define_function('abs', abs)
self.define_function('round', round)
def set_variable(self, name: str, value: Any) -> None:
self.variables[name] = value
def get_variable(self, name: str) -> Any:
if name in self.variables:
return self.variables[name]
raise NameError(f"Variable '{name}' is not defined")
def define_function(self, name: str, func: Callable) -> None:
self.functions[name] = func
def call_function(self, name: str, *args) -> Any:
if name in self.functions:
return self.functions[name](*args)
raise NameError(f"Function '{name}' is not defined")
def has_variable(self, name: str) -> bool:
return name in self.variables
# 終端式：数値
class NumberExpression(Expression):
def __init__(self, value: Union[int, float]):
self.value = value
def interpret(self, context: Context) -> Union[int, float]:
return self.value
def __str__(self) -> str:
return str(self.value)
# 終端式：文字列
class StringExpression(Expression):
def __init__(self, value: str):
self.value = value
def interpret(self, context: Context) -> str:
return self.value
def __str__(self) -> str:
return f'"{self.value}"'
# 終端式：変数参照
class VariableExpression(Expression):
def __init__(self, name: str):
self.name = name
def interpret(self, context: Context) -> Any:
return context.get_variable(self.name)
def __str__(self) -> str:
return self.name
# 二項演算の基底クラス
class BinaryExpression(Expression):
def __init__(self, left: Expression, right: Expression):
self.left = left
self.right = right
@abstractmethod
def operate(self, left_value: Any, right_value: Any) -> Any:
pass
@abstractmethod
def get_operator(self) -> str:
pass
def interpret(self, context: Context) -> Any:
left_value = self.left.interpret(context)
right_value = self.right.interpret(context)
return self.operate(left_value, right_value)
def __str__(self) -> str:
return f"({self.left} {self.get_operator()} {self.right})"
# 具象二項演算（演算子モジュールを活用）
class AddExpression(BinaryExpression):
def operate(self, left_value: Any, right_value: Any) -> Any:
return operator.add(left_value, right_value)
def get_operator(self) -> str:
return "+"
class SubtractExpression(BinaryExpression):
def operate(self, left_value: Any, right_value: Any) -> Any:
return operator.sub(left_value, right_value)
def get_operator(self) -> str:
return "-"
class MultiplyExpression(BinaryExpression):
def operate(self, left_value: Any, right_value: Any) -> Any:
return operator.mul(left_value, right_value)
def get_operator(self) -> str:
return "*"
class DivideExpression(BinaryExpression):
def operate(self, left_value: Any, right_value: Any) -> Any:
if right_value == 0:
raise ZeroDivisionError("Division by zero")
return operator.truediv(left_value, right_value)
def get_operator(self) -> str:
return "/"
class GreaterThanExpression(BinaryExpression):
def operate(self, left_value: Any, right_value: Any) -> bool:
return operator.gt(left_value, right_value)
def get_operator(self) -> str:
return ">"
class LogicalAndExpression(BinaryExpression):
def operate(self, left_value: Any, right_value: Any) -> bool:
return bool(left_value) and bool(right_value)
def get_operator(self) -> str:
return "and"
# 条件式
class ConditionalExpression(Expression):
def __init__(self, condition: Expression, true_expr: Expression, false_expr: Expression):
self.condition = condition
self.true_expr = true_expr
self.false_expr = false_expr
def interpret(self, context: Context) -> Any:
condition_value = self.condition.interpret(context)
if bool(condition_value):
return self.true_expr.interpret(context)
else:
return self.false_expr.interpret(context)
def __str__(self) -> str:
return f"{self.condition} ? {self.true_expr} : {self.false_expr}"
# 関数呼び出し
class FunctionCallExpression(Expression):
def __init__(self, func_name: str, *args: Expression):
self.func_name = func_name
self.args = args
def interpret(self, context: Context) -> Any:
arg_values = [arg.interpret(context) for arg in self.args]
return context.call_function(self.func_name, *arg_values)
def __str__(self) -> str:
args_str = ", ".join(str(arg) for arg in self.args)
return f"{self.func_name}({args_str})"
# リスト式（Pythonらしい機能）
class ListExpression(Expression):
def __init__(self, *elements: Expression):
self.elements = elements
def interpret(self, context: Context) -> List[Any]:
return [element.interpret(context) for element in self.elements]
def __str__(self) -> str:
elements_str = ", ".join(str(element) for element in self.elements)
return f"[{elements_str}]"
# インデックスアクセス
class IndexExpression(Expression):
def __init__(self, collection: Expression, index: Expression):
self.collection = collection
self.index = index
def interpret(self, context: Context) -> Any:
collection_value = self.collection.interpret(context)
index_value = self.index.interpret(context)
return collection_value[index_value]
def __str__(self) -> str:
return f"{self.collection}[{self.index}]"
# 簡易パーサー（DSLの構文解析）
class SimpleParser:
def __init__(self, expression_string: str):
self.tokens = self._tokenize(expression_string)
self.pos = 0
def _tokenize(self, expr: str) -> List[str]:
# 簡単なトークナイザー（実用的にはより複雑なパーサーが必要）
pattern = r'(\d+\.?\d*|[a-zA-Z_]\w*|[+\-*/()><=]|"[^"]*")'
return re.findall(pattern, expr.replace(' ', ''))
def parse(self) -> Expression:
return self._parse_expression()
def _parse_expression(self) -> Expression:
left = self._parse_term()
while self.pos < len(self.tokens) and self.tokens[self.pos] in ['+', '-']:
op = self.tokens[self.pos]
self.pos += 1
right = self._parse_term()
if op == '+':
left = AddExpression(left, right)
else:
left = SubtractExpression(left, right)
return left
def _parse_term(self) -> Expression:
left = self._parse_factor()
while self.pos < len(self.tokens) and self.tokens[self.pos] in ['*', '/']:
op = self.tokens[self.pos]
self.pos += 1
right = self._parse_factor()
if op == '*':
left = MultiplyExpression(left, right)
else:
left = DivideExpression(left, right)
return left
def _parse_factor(self) -> Expression:
if self.pos >= len(self.tokens):
raise SyntaxError("Unexpected end of expression")
token = self.tokens[self.pos]
self.pos += 1
if token == '(':
expr = self._parse_expression()
if self.pos < len(self.tokens) and self.tokens[self.pos] == ')':
self.pos += 1
return expr
else:
raise SyntaxError("Missing closing parenthesis")
elif token.replace('.', '').isdigit():
return NumberExpression(float(token) if '.' in token else int(token))
elif token.startswith('"') and token.endswith('"'):
return StringExpression(token[1:-1])
else:
return VariableExpression(token)
# 使用例
def main():
context = Context()
# 変数設定
context.set_variable('x', 10)
context.set_variable('y', 5)
context.set_variable('price', 100)
context.set_variable('discount_rate', 0.1)
# カスタム関数の定義
def calculate_discount(amount, rate):
return amount * rate
context.define_function('discount', calculate_discount)
# 手動でのAST構築
print("=== Manual AST Construction ===")
# 式: (x + y) * 2 - discount(price, discount_rate)
expression = SubtractExpression(
MultiplyExpression(
AddExpression(VariableExpression('x'), VariableExpression('y')),
NumberExpression(2)
),
FunctionCallExpression('discount', VariableExpression('price'), VariableExpression('discount_rate'))
)
print(f"Expression: {expression}")
print(f"Result: {expression.interpret(context)}")
# 条件付きロジック
conditional_expr = ConditionalExpression(
GreaterThanExpression(VariableExpression('x'), NumberExpression(5)),
StringExpression("x is greater than 5"),
StringExpression("x is not greater than 5")
)
print(f"Conditional: {conditional_expr}")
print(f"Result: {conditional_expr.interpret(context)}")
# リストとインデックス操作
print("\n=== List Operations ===")
context.set_variable('numbers', [1, 2, 3, 4, 5])
list_expr = ListExpression(
NumberExpression(1),
AddExpression(NumberExpression(2), NumberExpression(3)),
VariableExpression('x')
)
print(f"List: {list_expr}")
print(f"Result: {list_expr.interpret(context)}")
# 簡易パーサーのテスト
print("\n=== Simple Parser Test ===")
parser_expr = "x + y * 2"
parser = SimpleParser(parser_expr)
parsed_ast = parser.parse()
print(f"Parsed: {parser_expr} -> {parsed_ast}")
print(f"Result: {parsed_ast.interpret(context)}")
if __name__ == "__main__":
main()
Pythonの特徴と利点
- 動的性: 実行時の型変換と柔軟な処理
- 簡潔性: Duck Typingによるインターフェース不要
- 表現力: リスト内包表記、ラムダ式など豊富な構文
- メタプログラミング: 動的なクラス・関数生成
実践的な応用場面
1. ビジネスルールエンジン
// 保険料計算ルール
Expression premiumCalculation = new ConditionalExpression(
new GreaterThanExpression(new VariableExpression("age"), new NumberExpression(65)),
new MultiplyExpression(new VariableExpression("basePremium"), new NumberExpression(1.5)),
new VariableExpression("basePremium")
);
2. SQL風のクエリ言語
# SELECT name, age FROM users WHERE age > 18
query = SelectExpression(
["name", "age"],
FromExpression("users"),
WhereExpression(GreaterThanExpression(VariableExpression("age"), NumberExpression(18)))
)
3. 設定ファイルの動的評価
# config.rule: "if environment == 'production' then 'prod-server' else 'dev-server'"
config_rule = ConditionalExpression(
EqualExpression(VariableExpression("environment"), StringExpression("production")),
StringExpression("prod-server"),
StringExpression("dev-server")
)
4. 数式計算エンジン
// 科学計算: sin(pi * x / 180) + cos(pi * y / 180)
Expression trigExpression = new AddExpression(
new FunctionCallExpression("sin",
new DivideExpression(
new MultiplyExpression(new VariableExpression("pi"), new VariableExpression("x")),
new NumberExpression(180)
)
),
new FunctionCallExpression("cos",
new DivideExpression(
new MultiplyExpression(new VariableExpression("pi"), new VariableExpression("y")),
new NumberExpression(180)
)
)
);
パフォーマンス考慮事項
最適化戦略
Java
- AST キャッシュ: 同じ式の再利用
- コンパイル済み実行: バイトコード生成
- 型特化: プリミティブ型専用の演算子クラス
Python
-
__slots__使用: メモリ使用量削減 - キャッシュデコレータ: 計算結果のメモ化
- NumPy 統合: 数値計算の高速化
from functools import lru_cache
class OptimizedNumberExpression(Expression):
__slots__ = ['value']
def __init__(self, value: Union[int, float]):
self.value = value
@lru_cache(maxsize=128)
def interpret(self, context: Context) -> Union[int, float]:
return self.value
メモリ使用量の比較
# 標準実装
import sys
standard_expr = NumberExpression(42)
print(f"Standard expression size: {sys.getsizeof(standard_expr)} bytes")
# 最適化実装
optimized_expr = OptimizedNumberExpression(42)
print(f"Optimized expression size: {sys.getsizeof(optimized_expr)} bytes")
実装パターンの比較
| 特性 | Java | Python |
|---|---|---|
| 型安全性 | コンパイル時型チェック | 実行時型チェック（型ヒント推奨） |
| 拡張性 | インターフェース継承 | ABC継承またはDuck Typing |
| パフォーマンス | JIT最適化、静的型付け | インタープリター、動的型付け |
| デバッグ性 | スタックトレース詳細 | 動的エラー情報 |
| 文法表現力 | 厳密なクラス階層 | 柔軟なオブジェクト構造 |
| DSL構築 | 型安全なDSL | 自然言語に近いDSL |
実際のプロダクトでの活用例
1. Spring Expression Language (SpEL) - Java
// Spring FrameworkのSpEL実装例
ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("name == 'Nikola Tesla'");
EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
boolean result = exp.getValue(context, tesla, Boolean.class);
2. Django Template Engine - Python
# Djangoテンプレートエンジンの変数展開
# {{ user.name|upper }} のような構文を内部的にAST化
class VariableNode:
def __init__(self, filter_expression):
self.filter_expression = filter_expression
def render(self, context):
return self.filter_expression.resolve(context)
3. Apache Spark SQL - Scala/Java
// Spark SQLのCatalyst Optimizerは大規模なAST処理
case class Add(left: Expression, right: Expression) extends BinaryArithmetic {
override def symbol: String = "+"
override def eval(input: InternalRow): Any = numeric.plus(left.eval(input), right.eval(input))
}
アンチパターンと注意点
1. 過度な複雑化
// BAD: 単純な条件分岐をわざわざInterpreterパターンで実装
if (user.getAge() > 18) {
return "adult";
} else {
return "minor";
}
// GOOD: 複雑なビジネスルールでのみ使用
Expression ageRule = parseBusinessRule("age > 18 AND (income > 50000 OR education == 'university')");
2. パフォーマンス無視
# BAD: 毎回新しいASTを構築
def calculate_daily(data):
for item in data:
ast = build_ast("price * quantity * tax_rate") # 非効率
result = ast.interpret(create_context(item))
# GOOD: ASTを再利用
calculation_ast = build_ast("price * quantity * tax_rate") # 一度だけ構築
def calculate_daily(data):
for item in data:
result = calculation_ast.interpret(create_context(item))
3. エラーハンドリングの不備
// BAD: エラー情報が不明確
public Object interpret(Context context) {
return left.interpret(context) + right.interpret(context); // ClassCastException の可能性
}
// GOOD: 詳細なエラー情報
public Object interpret(Context context) {
try {
Object leftValue = left.interpret(context);
Object rightValue = right.interpret(context);
if (!(leftValue instanceof Number) || !(rightValue instanceof Number)) {
throw new InterpreterException(
String.format("Addition requires numeric operands, got %s and %s at %s",
leftValue.getClass().getSimpleName(),
rightValue.getClass().getSimpleName(),
this.getSourceLocation())
);
}
return ((Number) leftValue).doubleValue() + ((Number) rightValue).doubleValue();
} catch (Exception e) {
throw new InterpreterException("Error evaluating addition expression: " + this, e);
}
}
次世代の発展: ANTLR と現代的なパーサー
ANTLR（Java/Python対応）
// ANTLR4を使用した本格的なパーサー生成
grammar Calculator;
expression
: expression ('*'|'/') expression # MulDiv
| expression ('+'|'-') expression # AddSub
| '(' expression ')' # Parens
| NUMBER # Number
| VARIABLE # Variable
;
NUMBER: [0-9]+('.'[0-9]+)?;
VARIABLE: [a-zA-Z][a-zA-Z0-9]*;
WS: [ \t\r\n]+ -> skip;
PlyPlus（Python専用）
from plyplus import Grammar
# 文法定義
grammar = Grammar("""
start: expr;
expr: expr '+' term | expr '-' term | term;
term: term '*' factor | term '/' factor | factor;
factor: '(' expr ')' | number | variable;
number: /\d+(\.\d+)?/;
variable: /[a-zA-Z][a-zA-Z0-9]*/;
WS: /\s+/ (%ignore);
""")
まとめ：適用場面の見極めが重要
Interpreterパターンは強力なパターンですが、**「言語的な構造を持つ問題」**に限定して使用することが重要です。
適用すべき場面
- 複雑なビジネスルールの動的評価
- **DSL（ドメイン固有言語）**の実装
- 設定ファイルの高度な条件評価
- クエリエンジンやレポート生成システム
- 数式処理や科学計算システム
避けるべき場面
- 単純な条件分岐（if-else で十分）
- 固定的な処理フロー
- パフォーマンスが最重要な処理
- 少数の固定パターンしか存在しない場合
| 特性 | Java | Python |
|---|---|---|
| 主な強み | 型安全性、大規模システム向け | 柔軟性、プロトタイピング向け |
| 適用領域 | エンタープライズ、金融システム | データ分析、機械学習パイプライン |
| パフォーマンス | 高速（JIT最適化） | 中程度（CPython制約） |
| 保守性 | 厳密な型による安全性 | 動的性による柔軟性 |
Interpreterパターンは、**「プログラムでプログラムを作る」**メタプログラミングの一形態です。適切に使用することで、システムの表現力と拡張性を大幅に向上させることができます。
次回は、オブジェクトの状態変化に応じて振る舞いを動的に変更するStateパターンについて解説します。ステートマシンの実装とビジネスワークフローの管理について詳しく学びましょう！
次回のテーマ：「Day 18 Stateパターン：オブジェクトの状態に応じた振る舞いの動的変更」