added return expression

Author: RednibCoding

README.md

@@ -459,30 +459,6 @@ sayHello(person)
 
 The Rune language is a simple, dynamic scripting language. The following chapter describes the syntax and features of the Rune language, including how to define and call functions, use variables, control flow with `if` and `while` statements, data types, arrays, tables and more.
 
-## Defining and Calling Functions
-
-### Defining Functions
-
-Functions in Rune are defined by assigning a function to a name.
-
-Example:
-
-```js
-greet = func() {
-    print("Greetings")
-}
-```
-
-### Calling Functions
-
-Functions are called using the name followed by parentheses and optional arguments.
-
-Example:
-
-```js
-greet()
-```
-
 ## Defining and Using Variables
 
 ### Defining Variables
@@ -629,6 +605,75 @@ if false {
 
 ```
 
+## Defining and Calling Functions
+
+### Defining Functions
+
+Functions in Rune are defined by assigning a function to a name.
+
+Example:
+
+```js
+greet = func() {
+    print("Greetings")
+}
+```
+
+### Calling Functions
+
+Functions are called using the name followed by parentheses and optional arguments.
+
+Example:
+
+```js
+greet()
+```
+
+## Return
+The last expression of a function will be returned, so the return keyword is optional.
+
+However, you can use `return` to early exit a function.
+
+>**Differences:** In Rune, you have to explicitly bind the return value with `<` to `return`.
+
+The example below does not return 42, because 42 is not part of the return expression even though it is on the same line. It will return `false` because no return value has been given to `return`.
+```js
+main = fun() {
+    println("Hello, World!")
+    return 42
+    println("After return")
+}
+val = main()
+println(val)
+```
+output:
+```
+Hello, World!
+false
+```
+
+To explicitly provide a return value to `return`, you have to bind it to `return` with `<`.
+```js
+main = fun() {
+    println("Hello, World!")
+    return < 42
+    println("After return")
+
+}
+val = main()
+println(val)
+```
+
+output:
+```
+Hello, World!
+42
+```
+
+>**Note:** using `return` to return a value from a function is not ideomatic in Rune. Because the last expression in a function will be returned, `return` with a value is rarely needed.
+
+>**Nice to know:** `return` skips all further expression in the scope where it was used. So using it in the top level will quit further execution of the script, basically acting as a program exit.
+
 ## Arrays
 In Rune you can define an array by binding it to a name:
 ```js

ast.go

@@ -14,6 +14,7 @@ const (
 	If     ExprType = "if"
 	Prog   ExprType = "prog"
 	Call   ExprType = "call"
+	Return ExprType = "return"
 	While  ExprType = "while"
 	Array  ExprType = "array"
 	Table  ExprType = "table"

editor/vscode/rune/rune-1.0.0.vsix

@@ -41,7 +41,7 @@
 		"patterns": [
 		  {
 			"name": "keyword.control.rune",
-			"match": "\\b(if|then|elif|else|while|import)\\b"
+			"match": "\\b(if|then|elif|else|while|import|return)\\b"
 		  },
 		  {
 			"name": "constant.language.rune",

editor/vscode/rune/syntaxes/rune.tmLanguage.json

@@ -17,6 +17,10 @@ func NewEvaluator() *Evaluator {
 	return e
 }
 
+type ReturnValue struct {
+	Value interface{}
+}
+
 func (e *Evaluator) evaluate(exp *Expr, env *Environment) interface{} {
 	if exp == nil {
 		Error(exp, "Null expression error, this is a bug and should never happen!. Please file a bug!")
@@ -50,6 +54,7 @@ func (e *Evaluator) evaluate(exp *Expr, env *Environment) interface{} {
 				Error(exp, "Variable %v is not an array or table", exp.Value)
 			}
 		}
+
 		return value
 
 	case Assign:
@@ -174,7 +179,11 @@ func (e *Evaluator) evaluate(exp *Expr, env *Environment) interface{} {
 	case Prog:
 		var val interface{} = false
 		for _, ex := range exp.Prog {
-			val = e.evaluate(ex, env)
+			result := e.evaluate(ex, env)
+			if ret, ok := result.(ReturnValue); ok {
+				return ret.Value
+			}
+			val = result
 		}
 		return val
 
@@ -205,6 +214,9 @@ func (e *Evaluator) evaluate(exp *Expr, env *Environment) interface{} {
 		}
 		return ret
 
+	case Return:
+		return ReturnValue{Value: e.evaluate(exp.Right, env)}
+
 	case Import:
 		path := e.evaluate(exp.Left, env).(string) + ".rune"
 		if _, alreadyImported := e.importedPaths[path]; alreadyImported {

evaluator.go

@@ -1,23 +1,14 @@
 # Hello World
 main = fun() {
-    print("Hello, World!")
-}
-
-# Factorial
-factorial = fun(n) {
-    if n == 0 then 1
-    n * factorial(n - 1)
-}
-println(factorial(5)) # Outputs 120
+    println("Hello, World!")
+    return
+    println("After return")
 
-# Fibonacci
-fibonacci = fun(n) {
-    if n <= 1 then n
-    fibonacci(n - 1) + fibonacci(n - 2)
 }
-print(fibonacci(10)) # Outputs 55
-exit()
+val = main()
+println(val)
 
+return 42
 myvar = "12"
 
 mybool = not 13 # false because 13 is truthy

example/test.rune

@@ -393,9 +393,7 @@ func (p *Parser) parseNotExpr() *Expr {
 	tok := p.input.Peek()
 	p.skipKw("not")
 	expr := p.parseExpression()
-	// if expr.Type != Bool && expr.Type != Binary && expr.Type != Assign && expr.Type != Call && expr.Type != Var {
-	// 	p.unexpected(tok)
-	// }
+
 	return &Expr{
 		Type:     Unary,
 		Operator: "not",
@@ -406,6 +404,26 @@ func (p *Parser) parseNotExpr() *Expr {
 	}
 }
 
+func (p *Parser) parseReturnExpr() *Expr {
+	tok := p.input.Peek()
+	p.skipKw("return")
+	var expr *Expr
+	if p.isOp("<") != nil {
+		p.input.Next()
+		expr = p.parseExpression()
+	} else {
+		// Inject a false expression if the return has no argument
+		expr = FALSE
+	}
+	return &Expr{
+		Type:  Return,
+		Right: expr,
+		File:  tok.File,
+		Line:  tok.Line,
+		Col:   tok.Col,
+	}
+}
+
 func (p *Parser) parseAtom() *Expr {
 	var expr *Expr
 	if p.isPunc("(") != nil {
@@ -431,6 +449,8 @@ func (p *Parser) parseAtom() *Expr {
 		expr = p.parseImport()
 	} else if p.isKw("not") != nil {
 		expr = p.parseNotExpr()
+	} else if p.isKw("return") != nil {
+		expr = p.parseReturnExpr()
 
 	} else {
 		tok := p.input.Next()

parser.go

@@ -18,12 +18,13 @@ type Token struct {
 type TokenStream struct {
 	input    *InputStream
 	current  *Token
+	last     *Token
 	keywords map[string]bool
 }
 
 func NewTokenStream(input *InputStream) *TokenStream {
 	keywords := map[string]bool{
-		"if": true, "then": true, "elif": true, "else": true, "while": true, "fun": true,
+		"if": true, "then": true, "elif": true, "else": true, "while": true, "fun": true, "return": true,
 		"true": true, "false": true, "array": true, "table": true, "import": true, "not": true,
 	}
 	return &TokenStream{input: input, keywords: keywords}
@@ -117,10 +118,12 @@ func (ts *TokenStream) skipComment() {
 
 func (ts *TokenStream) readNext() *Token {
 	ts.readWhile(ts.isWhitespace)
+
 	if ts.input.Eof() {
 		return nil
 	}
 	ch := ts.input.Peek()
+
 	switch {
 	case ch == '#':
 		ts.skipComment()
@@ -151,12 +154,17 @@ func (ts *TokenStream) Peek() *Token {
 	return ts.current
 }
 
+func (ts *TokenStream) Last() *Token {
+	return ts.last
+}
+
 func (ts *TokenStream) Next() *Token {
 	tok := ts.current
 	ts.current = nil
 	if tok == nil {
-		return ts.readNext()
+		tok = ts.readNext()
 	}
+	ts.last = ts.copyToken(tok)
 	return tok
 }
 
@@ -167,3 +175,15 @@ func (ts *TokenStream) Eof() bool {
 func (ts *TokenStream) Error(tok *Token, msg string) {
 	ts.input.Error(tok, msg)
 }
+
+func (ts *TokenStream) copyToken(tok *Token) *Token {
+	t := &Token{
+		Type:   tok.Type,
+		Value:  tok.Value,
+		File:   tok.File,
+		Line:   tok.Line,
+		Col:    tok.Col,
+		Length: tok.Length,
+	}
+	return t
+}