package debruijn

type Expression interface {
	Accept(Visitor)
}

/** ------------------------------------------------------------------------- */

type Abstraction struct {
	body Expression
}

func (a *Abstraction) Body() Expression {
	return a.body
}

func (a *Abstraction) Accept(v Visitor) {
	v.VisitAbstraction(a)
}

func NewAbstraction(body Expression) *Abstraction {
	return &Abstraction{body: body}
}

/** ------------------------------------------------------------------------- */

type Application struct {
	abstraction Expression
	argument    Expression
}

func (a *Application) Abstraction() Expression {
	return a.abstraction
}

func (a *Application) Argument() Expression {
	return a.argument
}

func (a *Application) Accept(v Visitor) {
	v.VisitApplication(a)
}

func NewApplication(abstraction Expression, argument Expression) *Application {
	return &Application{abstraction: abstraction, argument: argument}
}

/** ------------------------------------------------------------------------- */

type Variable struct {
	index int
	label string
}

func (v *Variable) Index() int {
	return v.index
}

func (v *Variable) Label() string {
	return v.label
}

func (v *Variable) Accept(visitor Visitor) {
	visitor.VisitVariable(v)
}

func NewVariable(index int, label string) *Variable {
	return &Variable{index: index, label: label}
}

/** ------------------------------------------------------------------------- */

type Visitor interface {
	VisitAbstraction(*Abstraction)
	VisitApplication(*Application)
	VisitVariable(*Variable)
}