Interpreter 패턴

인터프리터 패턴??

Interpreter 패턴은 특정 언어의 문법 규칙을 클래스화하고, 이를 사용하여 특정 언어로 작성된 문장을 해석하는 패턴입니다. 

 

이 패턴은 각 문법 규칙을 나타내는 AbstractExpression 클래스와 하위 클래스로 구성됩니다. 이 클래스들은 해석하고자 하는 언어의 구문 요소를 나타내며, 해석하는 데 필요한 메서드를 구현합니다.

Interpreter 패턴에서는 Context 클래스가 사용될 수있고 생략할 수 도 있어요 ..

 

Context 클래스는 해석하고자 하는 언어의 상태를 저장하며, Expression 클래스에서 이 상태를 참조하여 결과를 반환합니다. Context 클래스는 ConcreteContext 클래스로 구현되며, 해석하고자 하는 언어의 상태를 저장하는 역할을 합니다.

Interpreter 패턴은 자주 사용되지는 않지만, 복잡한 문법의 언어를 해석하는 데 유용합니다. 예를 들어, SQL 질의문이나 수학식 등을 해석하는 데 사용할 수 있습니다. 또한, Interpreter 패턴은 다른 디자인 패턴과 함께 사용될 수도 있습니다. 예를 들어, Composite 패턴과 함께 사용하여 복잡한 언어를 처리할 수 있습니다.

 

말은 어렵지만 예제를 보면 쉽게 이해할 수 있습니다. 

 

type Direction int

const (
    NORTH Direction = iota
    EAST
    SOUTH
    WEST
)

type AbstractExpression interface {
    Interpret(robot *Robot) error
}

type MoveExpression struct {
    steps int
}

func (m *MoveExpression) Interpret(robot *Robot) error {
    for i := 0; i < m.steps; i++ {
        robot.MoveForward()
    }
    return nil
}

type TurnLeftExpression struct{}

func (t *TurnLeftExpression) Interpret(robot *Robot) error {
    robot.TurnLeft()
    return nil
}

type TurnRightExpression struct{}

func (t *TurnRightExpression) Interpret(robot *Robot) error {
    robot.TurnRight()
    return nil
}

type Robot struct {
    x      int
    y      int
    facing Direction
}

func (r *Robot) MoveForward() {
    switch r.facing {
    case NORTH:
        r.y++
    case EAST:
        r.x++
    case SOUTH:
        r.y--
    case WEST:
        r.x--
    }
}

func (r *Robot) TurnLeft() {
    r.facing = (r.facing + 3) % 4
}

func (r *Robot) TurnRight() {
    r.facing = (r.facing + 1) % 4
}

type Interpreter struct {
    expressions []AbstractExpression
}

func (i *Interpreter) Interpret(robot *Robot) error {
    for _, expression := range i.expressions {
        err := expression.Interpret(robot)
        if err != nil {
            return err
        }
    }
    return nil
}

func main() {
    robot := &Robot{x: 0, y: 0, facing: EAST}

    interpreter := &Interpreter{
        expressions: []AbstractExpression{
            &MoveExpression{steps: 3},
            &TurnLeftExpression{},
            &MoveExpression{steps: 2},
            &TurnRightExpression{},
            &MoveExpression{steps: 1},
        },
    }

    err := interpreter.Interpret(robot)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Printf("Robot is at (%d, %d) facing %d\n", robot.x, robot.y, robot.facing)
    }
}

위 코드에서 Robot  클래스가 Context와 같은 역활을 수행합니다.