Merge pull request #21 from JunNishimura/feature/add_quote_function

add quote function

ast/ast.go

@@ -69,7 +69,30 @@ type ConsCell struct {
 }
 
 func (cc *ConsCell) String() string {
-	return fmt.Sprintf("(%s . %s)", cc.CarField.String(), cc.CdrField.String())
+	var out bytes.Buffer
+
+	out.WriteString("(")
+
+	consCell := cc
+	for {
+		out.WriteString(consCell.Car().String())
+
+		if _, ok := consCell.Cdr().(*Nil); ok {
+			break
+		}
+
+		if cdr, ok := consCell.Cdr().(*ConsCell); ok {
+			out.WriteString(" ")
+			consCell = cdr
+		} else {
+			out.WriteString(" . ")
+			out.WriteString(consCell.Cdr().String())
+			break
+		}
+	}
+	out.WriteString(")")
+
+	return out.String()
 }
 func (cc *ConsCell) Car() SExpression { return cc.CarField }
 func (cc *ConsCell) Cdr() SExpression { return cc.CdrField }

evaluator/evaluator.go

@@ -89,6 +89,10 @@ func evalMinusPrefix(right object.Object) object.Object {
 }
 
 func evalSymbol(symbol *ast.Symbol, env *object.Environment) object.Object {
+	if specialForm, ok := specialForms[symbol.Value]; ok {
+		return specialForm
+	}
+
 	if val, ok := env.Get(symbol.Value); ok {
 		return val
 	}
@@ -102,17 +106,17 @@ func evalSymbol(symbol *ast.Symbol, env *object.Environment) object.Object {
 
 // evaluate cdr of the cons cell as arguments to the command car
 func evalList(sexp *ast.ConsCell, env *object.Environment) object.Object {
-	// check if the car is a special form
-	if specialForm, ok := sexp.Car().(*ast.SpecialForm); ok {
-		return specialForms[specialForm.TokenLiteral()].Fn(sexp.Cdr(), env)
-	}
-
 	// Evaluate the car of the cons cell
 	car := Eval(sexp.Car(), env)
 	if isError(car) {
 		return car
 	}
 
+	// check if the car is a special form
+	if specialForm, ok := car.(*object.SpecialForm); ok {
+		return specialForm.Fn(sexp.Cdr(), env)
+	}
+
 	// Evaluate the arguments
 	args := evalArgs(sexp.Cdr(), env)
 	if len(args) == 1 && isError(args[0]) {

evaluator/evaluator_test.go

@@ -54,20 +54,3 @@ func TestEvalIntegerExpression(t *testing.T) {
 		testIntegerObject(t, evaluated, tt.expected)
 	}
 }
-
-func TestLambdaExpression(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected int64
-	}{
-		{"((lambda () 5))", 5},
-		{"((lambda (x) x) 5)", 5},
-		{"((lambda (x y) (+ x y)) 5 5)", 10},
-		{"(+ ((lambda () 1)) ((lambda (x y) (+ x y)) 1 2))", 4},
-	}
-
-	for _, tt := range tests {
-		evaluated := testEval(tt.input)
-		testIntegerObject(t, evaluated, tt.expected)
-	}
-}

evaluator/specialform.go

@@ -30,6 +30,18 @@ var specialForms = map[string]*object.SpecialForm{
 			return &object.Function{Parameters: params, Body: body, Env: env}
 		},
 	},
+	"quote": {
+		Fn: func(sexp ast.SExpression, env *object.Environment) object.Object {
+			consCell, ok := sexp.(*ast.ConsCell)
+			if !ok {
+				return newError("quote must be a cons cell, got %T", sexp)
+			}
+
+			return &object.Quote{
+				SExpression: consCell.Car(),
+			}
+		},
+	},
 }
 
 func evalLambdaParams(sexp ast.SExpression) ([]*ast.Symbol, error) {

evaluator/specialform_test.go

@@ -0,0 +1,43 @@
+package evaluator
+
+import "testing"
+
+func TestLambdaExpression(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected int64
+	}{
+		{"((lambda () 5))", 5},
+		{"((lambda (x) x) 5)", 5},
+		{"((lambda (x y) (+ x y)) 5 5)", 10},
+		{"(+ ((lambda () 1)) ((lambda (x y) (+ x y)) 1 2))", 4},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		testIntegerObject(t, evaluated, tt.expected)
+	}
+}
+
+func TestQuote(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"'5", "5"},
+		{"'-5", "-5"},
+		{"'(+ 1 2)", "(+ 1 2)"},
+		{"'(+ . (1 . (2 . nil)))", "(+ 1 2)"},
+		{"(quote 5)", "5"},
+		{"(quote -5)", "-5"},
+		{"(quote (+ 1 2))", "(+ 1 2)"},
+		{"(quote (+ . (1 . (2 . nil))))", "(+ 1 2)"},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		if evaluated.Inspect() != tt.expected {
+			t.Errorf("expected=%q, got=%q", tt.expected, evaluated.Inspect())
+		}
+	}
+}

lexer/lexer.go

@@ -58,16 +58,14 @@ func (l *Lexer) NextToken() token.Token {
 		}
 	case '.':
 		tok = newToken(token.DOT, l.curChar)
+	case '\'':
+		tok = newToken(token.QUOTE, l.curChar)
 	case 0:
 		tok.Literal = ""
 		tok.Type = token.EOF
 	default:
 		if isLetter(l.curChar) || isSpecialChar(l.curChar) {
 			tok.Literal = l.readString()
-			if spForm, ok := token.LookupSpecialForm(tok.Literal); ok {
-				tok.Type = spForm
-				return tok
-			}
 			tok.Type = token.LookupSymbol(tok.Literal)
 			return tok
 		} else if isDigit(l.curChar) {

lexer/lexer_test.go

@@ -19,6 +19,7 @@ func TestNextToken(t *testing.T) {
 +(+ 1 2)
 -(- 3 4)
 (lambda (x) (+ x 1))
+'(1 2 3)
 `
 
 	tests := []struct {
@@ -76,7 +77,7 @@ func TestNextToken(t *testing.T) {
 		{token.INT, "4"},
 		{token.RPAREN, ")"},
 		{token.LPAREN, "("},
-		{token.LAMBDA, "lambda"},
+		{token.SYMBOL, "lambda"},
 		{token.LPAREN, "("},
 		{token.SYMBOL, "x"},
 		{token.RPAREN, ")"},
@@ -86,6 +87,12 @@ func TestNextToken(t *testing.T) {
 		{token.INT, "1"},
 		{token.RPAREN, ")"},
 		{token.RPAREN, ")"},
+		{token.QUOTE, "'"},
+		{token.LPAREN, "("},
+		{token.INT, "1"},
+		{token.INT, "2"},
+		{token.INT, "3"},
+		{token.RPAREN, ")"},
 		{token.EOF, ""},
 	}
 

object/object.go

@@ -14,6 +14,7 @@ const (
 	FUNCTION_OBJ    = "FUNCTION"
 	SYMBOL_OBJ      = "SYMBOL"
 	SPECIALFORM_OBJ = "SPECIALFORM"
+	QOUTE_OBJ       = "QUOTE"
 	CONSCELL_OBJ    = "CONSCELL"
 	LIST_OBJ        = "LIST"
 	BUILTIN_OBJ     = "BUILTIN"
@@ -96,6 +97,13 @@ type SpecialForm struct {
 func (sf *SpecialForm) Type() ObjectType { return SPECIALFORM_OBJ }
 func (sf *SpecialForm) Inspect() string  { return "special form" }
 
+type Quote struct {
+	SExpression ast.SExpression
+}
+
+func (q *Quote) Type() ObjectType { return QOUTE_OBJ }
+func (q *Quote) Inspect() string  { return q.SExpression.String() }
+
 type ConsCell struct {
 	Car Object
 	Cdr Object

parser/parser.go

@@ -80,6 +80,8 @@ func (p *Parser) parseSExpression() ast.SExpression {
 	switch p.curToken.Type {
 	case token.LPAREN:
 		return p.parseList()
+	case token.QUOTE:
+		return p.parseQuote()
 	default:
 		return p.parseAtom()
 	}
@@ -132,6 +134,22 @@ func (p *Parser) parseList() ast.List {
 	return consCell
 }
 
+func (p *Parser) parseQuote() ast.SExpression {
+	quote := &ast.Symbol{Token: p.curToken, Value: "quote"}
+
+	p.nextToken()
+
+	sexpression := p.parseSExpression()
+
+	return &ast.ConsCell{
+		CarField: quote,
+		CdrField: &ast.ConsCell{
+			CarField: sexpression,
+			CdrField: &ast.Nil{Token: token.Token{Type: token.NIL, Literal: "nil"}},
+		},
+	}
+}
+
 func (p *Parser) parseAtom() ast.Atom {
 	atom := p.parseAtomByType()
 
@@ -148,8 +166,6 @@ func (p *Parser) parseAtomByType() ast.Atom {
 		return p.parseIntegerLiteral()
 	case token.SYMBOL:
 		return p.parseSymbol()
-	case token.LAMBDA:
-		return &ast.SpecialForm{Token: p.curToken}
 	case token.NIL:
 		return &ast.Nil{Token: p.curToken}
 	}