add module operator

evaluator/digit_test.go

@@ -1,6 +1,7 @@
 package evaluator
 
 import (
+	"fmt"
 	"testing"
 )
 
@@ -36,11 +37,65 @@ func TestEvalDigitExpression(t *testing.T) {
 		{
 			`[1, 3.0][1] + 1.2`,
 			4.2,
+		}, {
+			`1 - 1`,
+			0,
+		},
+		{
+			`1.0 - 1.0`,
+			0.0,
+		},
+		{
+			`1 - 1.0`,
+			0.0,
+		},
+		{
+			`1.0 - 1`,
+			0.0,
+		},
+		{
+			`1.0 - 1`,
+			0.0,
+		},
+		{
+			`[1.0, 3.0][1] - 1`,
+			2.0,
+		},
+		{
+			`[1, 3.0][1] - 1.2`,
+			1.8,
+		},
+		{
+			`2 * 2`,
+			4,
+		},
+		{
+			`4 / 2`,
+			2,
+		},
+		{
+			`4 % 2`,
+			0,
+		},
+		{
+			`4.0 % 2.0`,
+			0.0,
+		},
+		{
+			`4 % 2.0`,
+			0.0,
+		},
+		{
+			`4.0 % 2`,
+			0.0,
 		},
 	}
 
-	for _, tt := range tests {
-		evaluated := testEval(tt.input, t)
-		testObjectLiteral(t, evaluated, tt.expected)
+	for i, tt := range tests {
+		t.Run(fmt.Sprintf("TestEvalDigitExpression[%d]", i), func(t *testing.T) {
+			evaluated := testEval(tt.input, t)
+			testObjectLiteral(t, evaluated, tt.expected)
+		})
+
 	}
 }

evaluator/float.go

@@ -1,6 +1,7 @@
 package evaluator
 
 import (
+	"math"
 	"ninja/object"
 )
 
@@ -18,6 +19,8 @@ func evalFloatInfixExpression(
 		return &object.Float{Value: leftVal - rightVal}
 	case "*":
 		return &object.Float{Value: leftVal * rightVal}
+	case "%":
+		return &object.Float{Value: math.Mod(leftVal, rightVal)}
 	case "/":
 		return &object.Float{Value: leftVal / rightVal}
 	case "<":

evaluator/integer.go

@@ -16,6 +16,8 @@ func evalIntegerInfixExpression(
 		return &object.Integer{Value: leftVal - rightVal}
 	case "*":
 		return &object.Integer{Value: leftVal * rightVal}
+	case "%":
+		return &object.Integer{Value: leftVal % rightVal}
 	case "/":
 		return &object.Integer{Value: leftVal / rightVal}
 	case "<":

lexer/lexer.go

@@ -33,11 +33,9 @@ func (l *Lexer) NextToken() token.Token {
 	l.skipWhitespace()
 	switch l.ch {
 	case '=':
-
 		tok = l.newTokenPeekOrDefault(token.ASSIGN, map[byte]token.TokenType{
 			'=': token.EQ,
 		})
-
 	case ';':
 		tok = l.newToken(token.SEMICOLON, []byte{l.ch})
 	case '"':
@@ -71,7 +69,6 @@ func (l *Lexer) NextToken() token.Token {
 			l.readChar()
 			tok = l.newToken(token.AND, []byte{ch, l.ch})
 		}
-
 	case '|':
 		if l.peekChar() != '|' {
 			ch := l.ch
@@ -82,36 +79,30 @@ func (l *Lexer) NextToken() token.Token {
 			l.readChar()
 			tok = l.newToken(token.OR, []byte{ch, l.ch})
 		}
-
 	case '-':
-
 		tok = l.newTokenPeekOrDefault(token.MINUS, map[byte]token.TokenType{
 			'-': token.DECRE,
 		})
-
 	case '+':
-
 		tok = l.newTokenPeekOrDefault(token.PLUS, map[byte]token.TokenType{
 			'+': token.INCRE,
 		})
+	case '%':
+		tok = l.newTokenPeekOrDefault(token.MOD, map[byte]token.TokenType{
+			'%': token.MOD,
+		})
 	case '>':
-
 		tok = l.newTokenPeekOrDefault(token.GT, map[byte]token.TokenType{
 			'=': token.GTE,
 		})
-
 	case '<':
-
 		tok = l.newTokenPeekOrDefault(token.LT, map[byte]token.TokenType{
 			'=': token.LTE,
 		})
-
 	case '!':
-
 		tok = l.newTokenPeekOrDefault(token.BANG, map[byte]token.TokenType{
 			'=': token.NEQ,
 		})
-
 	case ':':
 		tok = l.newToken(token.COLON, []byte{l.ch})
 	case '(':

lexer/lexer_test.go

@@ -12,7 +12,7 @@ func TestNextToken(t *testing.T) {
 var true false if else
 break for () [] {} . ; : 
 != == <= >= < > && || = 
-+ - * / 
++ - * / % 
 // comment 
 ! 100 100.5 "hello" 
 ++5 --5 5++ 5-- count 
@@ -55,6 +55,8 @@ function delete @
 		{token.MINUS, "-"},
 		{token.ASTERISK, "*"},
 		{token.SLASH, "/"},
+
+		{token.MOD, "%"},
 		{token.BANG, "!"},
 
 		{token.INT, "100"},
@@ -79,13 +81,13 @@ function delete @
 	l := New(strings.NewReader(input))
 
 	for i, tt := range tests {
-		t.Run(fmt.Sprintf("Test_%s", tt.expectedType.String()), func(t *testing.T) {
+		t.Run(fmt.Sprintf("Test[%d]", i), func(t *testing.T) {
 			tok := l.NextToken()
 			if tok.Type != tt.expectedType {
-				t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q", i, tt.expectedType, tok.Type)
+				t.Fatalf("testdata[%d] - tokentype wrong. expected=%q, got=%q", i, tt.expectedType, tok.Type)
 			}
 			if string(tok.Literal) != tt.expectedLiteral {
-				t.Fatalf("tests[%d] - literal wrong. expected=%q, got=%q", i, tt.expectedLiteral, tok.Literal)
+				t.Fatalf("testdata[%d] - literal wrong. expected=%q, got=%q", i, tt.expectedLiteral, tok.Literal)
 			}
 		})
 

main_test.go

@@ -95,7 +95,7 @@ func TestMain_execCodeSpecialCharacter(t *testing.T) {
 	defer os.Remove(temporaryStdOut.Name())
 	os.Stdout = temporaryStdOut
 
-	execCode("import \"./tests/multiple_lines.nj\"; input.split(\"\n\")", temporaryStdOut)
+	execCode("import \"./testdata/multiple_lines.nj\"; input.split(\"\n\")", temporaryStdOut)
 
 	resultOut, err := os.ReadFile(temporaryStdOut.Name())
 	if err != nil {
@@ -118,8 +118,8 @@ func TestMain_execCodeAssertions(t *testing.T) {
 	defer os.Remove(temporaryStdOut.Name())
 	os.Stdout = temporaryStdOut
 
-	code := readFile(t, "./tests/assertions.nj")
-	expected := readFile(t, "./tests/expected.txt")
+	code := readFile(t, "./testdata/assertions.nj")
+	expected := readFile(t, "./testdata/expected.txt")
 	execCode(code, temporaryStdOut)
 
 	resultOut, err := os.ReadFile(temporaryStdOut.Name())

object/state.go

@@ -3,8 +3,15 @@ package object
 import "io"
 
 var (
-	Arguments      []string
-	StandardInput  io.Reader
+	// Arguments is argument that is passed from CLI arguments
+	Arguments []string
+
+	// StandardInput where is standard input
+	StandardInput io.Reader
+
+	// StandardOutput where is standard output
 	StandardOutput io.Writer
-	ExitFunction   func(int)
+
+	// ExitFunction where function responsible for exit
+	ExitFunction func(int)
 )

parser/float_test.go

@@ -39,6 +39,7 @@ func TestFloatLiteralExpression(t *testing.T) {
 	}
 
 	for i, tt := range tests {
+
 		stmt, ok := program.Statements[i].(*ast.ExpressionStatement)
 		if !ok {
 			t.Fatalf("program.Statements[%d] is not ast.ExpressionStatement. got=%T", i, program.Statements[i])

parser/parser.go

@@ -56,6 +56,7 @@ var precedences = map[token.TokenType]int{
 	token.INCRE:    SUM,
 	token.SLASH:    PRODUCT,
 	token.ASTERISK: PRODUCT,
+	token.MOD:      PRODUCT,
 	token.LPAREN:   CALL,
 	token.LBRACKET: INDEX,
 	token.DOT:      CALL,
@@ -92,6 +93,7 @@ func New(l *lexer.Lexer) *Parser {
 	p.registerInfix(token.MINUS, p.parseInfixExpression)
 	p.registerInfix(token.SLASH, p.parseInfixExpression)
 	p.registerInfix(token.ASTERISK, p.parseInfixExpression)
+	p.registerInfix(token.MOD, p.parseInfixExpression)
 	p.registerInfix(token.EQ, p.parseInfixExpression)
 	p.registerInfix(token.NEQ, p.parseInfixExpression)
 	p.registerInfix(token.LT, p.parseInfixExpression)

parser/parser_test.go

@@ -59,6 +59,14 @@ func TestOperatorPrecedenceParsing(t *testing.T) {
 			"a + b * c + d / e - f",
 			"(((a + (b * c)) + (d / e)) - f)",
 		},
+		{
+			"a + b % c",
+			"(a + (b % c))",
+		},
+		{
+			"a * b % c",
+			"((a * b) % c)",
+		},
 		{
 			"3 + 4; -5 * 5",
 			"(3 + 4)((-5) * 5)",

tests/assertions.nj → testdata/assertions.nj

@@ -22,17 +22,17 @@ function assertTrue() {
 Assertion basic variables
 */
 
-import "./tests/assert_variable.nj";
+import "./testdata/assert_variable.nj";
 
 /*
  Assertion Index
 */
 
-import "./tests/assert_index.nj";
+import "./testdata/assert_index.nj";
 
 
 /*
  Assertion advance stuff
 */
 
-import "./tests/assert_advance.nj";
+import "./testdata/assert_advance.nj";

token/token.go

@@ -33,6 +33,7 @@ func (t TokenType) String() string {
 		"-",
 		"!",
 		"*",
+		"%",
 		"/",
 		"++",
 		"--",
@@ -90,6 +91,7 @@ const (
 	MINUS    // "-"
 	BANG     // "!"
 	ASTERISK // "*"
+	MOD      // "%"
 	SLASH    // "/"
 	INCRE    // "++"
 	DECRE    // "--"