feat(interpreter): add or operator (#26)

code.monkey

@@ -1 +1,4 @@
-1 + 2
+let LESS_THAN_OR_EQUAL = fn(x, y) {
+    return (x < y) || (x == y);
+}
+puts(LESS_THAN_OR_EQUAL(1, 2));

evaluator/evaluator.go

@@ -316,6 +316,9 @@ func evalInfixExpression(operator string, left, right object.Object) object.Obje
 	case operator == "!=":
 		return nativeBoolToBooleanObject(left != right)
 
+	case operator == "||":
+		return evalOrInfixExpression(left, right)
+
 	case left.Type() != right.Type():
 		return newError("type mismatch: %s %s %s", left.Type(), operator, right.Type())
 
@@ -324,6 +327,13 @@ func evalInfixExpression(operator string, left, right object.Object) object.Obje
 	}
 }
 
+func evalOrInfixExpression(left, right object.Object) object.Object {
+	leftVal := left.(*object.Boolean).Value
+	rightVal := right.(*object.Boolean).Value
+
+	return nativeBoolToBooleanObject(leftVal || rightVal)
+}
+
 func evalStringInfixExpression(operator string, left, right object.Object) object.Object {
 	switch operator {
 	case "+":

evaluator/evaluator_test.go

@@ -60,6 +60,8 @@ func TestEvalBooleanExpression(t *testing.T) {
 		{"(1 < 2) == false", false},
 		{"(1 > 2) == true", false},
 		{"(1 > 2) == false", true},
+		{"true || false", true},
+		{"(1 > 2) || (5 > 4)", true},
 	}
 
 	for _, tt := range tests {

lexer/lexer.go

@@ -39,6 +39,14 @@ func (l *Lexer) NextToken() token.Token {
 		} else {
 			tok = newToken(token.ASSIGN, l.ch)
 		}
+	case '|':
+		if l.peekChar() == '|' {
+			ch := l.ch
+			l.readChar()
+			tok = token.Token{Type: token.OR, Literal: string(ch) + string(l.ch)}
+		} else {
+			tok = newToken(token.ILLEGAL, l.ch)
+		}
 	case ';':
 		tok = newToken(token.SEMICOLON, l.ch)
 	case '(':

lexer/lexer_test.go

@@ -30,6 +30,7 @@ func TestNextToken(t *testing.T) {
 	"foo bar"
 	[1, 2];
 	{"foo": "bar"}
+	true || false;
 	// this is a comment
 `
 
@@ -123,6 +124,10 @@ func TestNextToken(t *testing.T) {
 		{token.COLON, ":"},
 		{token.STRING, "bar"},
 		{token.RBRACE, "}"},
+		{token.TRUE, "true"},
+		{token.OR, "||"},
+		{token.FALSE, "false"},
+		{token.SEMICOLON, ";"},
 		{token.EOF, ""},
 	}
 

parser/parser.go

@@ -13,6 +13,7 @@ const (
 	_ int = iota
 	LOWEST
 	EQUALS      // ==
+	OR          // ||
 	LESSGREATER // > or <
 	SUM         // +
 	PRODUCT     // *
@@ -26,6 +27,7 @@ var precedences = map[token.TokenType]int{
 	token.NOT_EQ:   EQUALS,
 	token.LT:       LESSGREATER,
 	token.GT:       LESSGREATER,
+	token.OR:       OR,
 	token.PLUS:     SUM,
 	token.MINUS:    SUM,
 	token.SLASH:    PRODUCT,
@@ -86,6 +88,7 @@ func New(l *lexer.Lexer) *Parser {
 	p.registerInfix(token.ASTERISK, p.parseInfixExpression)
 	p.registerInfix(token.EQ, p.parseInfixExpression)
 	p.registerInfix(token.NOT_EQ, p.parseInfixExpression)
+	p.registerInfix(token.OR, p.parseInfixExpression)
 	p.registerInfix(token.LT, p.parseInfixExpression)
 	p.registerInfix(token.GT, p.parseInfixExpression)
 	p.registerInfix(token.LPAREN, p.parseCallExpression)

parser/parser_test.go

@@ -207,6 +207,7 @@ func TestParsingInfixExpressions(t *testing.T) {
 		{"5 < 5;", 5, "<", 5},
 		{"5 == 5;", 5, "==", 5},
 		{"5 != 5;", 5, "!=", 5},
+		{"true || false", true, "||", false},
 	}
 
 	for _, tt := range infixTests {

token/token.go

@@ -29,6 +29,7 @@ const (
 
 	EQ     = "=="
 	NOT_EQ = "!="
+	OR     = "||"
 
 	// Delimiters
 	COMMA     = ","