empty expressions no more return error, now they return nil

ast.go

@@ -5,7 +5,6 @@
 package expr
 
 import (
-	"errors"
 	"strings"
 )
 
@@ -129,8 +128,8 @@ func (self *ast) eval(ctx ExprContext, preset bool) (result any, err error) {
 		if err == nil {
 			result, err = self.root.compute(ctx)
 		}
-	} else {
+		// } else {
-		err = errors.New("empty expression")
+		// 	err = errors.New("empty expression")
 	}
 	return
 }

expr_test.go

@@ -18,17 +18,19 @@ func TestExpr(t *testing.T) {
 	}
 
 	inputs := []inputType{
-		/*   1 */ {`fact=func(n){(n)?{1}::{n*fact(n-1)}}; fact(5)`, int64(120), nil},
+		/*   1 */ {`0?{}`, nil, nil},
+		/*   2 */ {`fact=func(n){(n)?{1}::{n*fact(n-1)}}; fact(5)`, int64(120), nil},
+		/*   3 */ {`f=openFile("test-file.txt"); line=readFile(f); closeFile(f); line`, "uno", nil},
 	}
 
 	succeeded := 0
 	failed := 0
 
-	inputs1 := []inputType{
+	// inputs1 := []inputType{
-		{`f=openFile("test-file.txt"); line=readFile(f); closeFile(f); line`, "uno", nil},
+	// 	/*   1 */ {`0?{}`, nil, nil},
-	}
+	// }
 
-	for i, input := range inputs1 {
+	for i, input := range inputs {
 		var expr Expr
 		var gotResult any
 		var gotErr error

func-builtins.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// func-builtins.go
+package expr
+
+import (
+	"fmt"
+)
+
+func isNilFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+	if len(args) == 1 {
+		result = args[0] == nil
+	} else {
+		err = fmt.Errorf("%s() requires exactly one param", name)
+	}
+	return
+}
+
+func ImportBuiltinsFuncs(ctx ExprContext) {
+	ctx.RegisterFunc("isNil", &simpleFunctor{f: isNilFunc}, 1, -1)
+}
+
+func init() {
+	registerImport("builtins", ImportBuiltinsFuncs)
+}

operator-selector.go

@@ -74,18 +74,21 @@ func newSelectorTerm(tk *Token) (inst *term) {
 	}
 }
 
-func isSelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (selectedValue any, err error) {
+func isSelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (match bool, selectedValue any, err error) {
 	caseData, _ := caseSel.(*selectorCase)
 	if caseData.filterList == nil {
 		selectedValue, err = caseData.caseExpr.eval(ctx, false)
+		match = true
 	} else if filterList, ok := caseData.filterList.value().([]*term); ok {
 		if len(filterList) == 0 && exprValue == int64(caseIndex) {
 			selectedValue, err = caseData.caseExpr.eval(ctx, false)
+			match = true
 		} else {
 			var caseValue any
 			for _, caseTerm := range filterList {
 				if caseValue, err = caseTerm.compute(ctx); err != nil || caseValue == exprValue {
 					selectedValue, err = caseData.caseExpr.eval(ctx, false)
+					match = true
 					break
 				}
 			}
@@ -96,7 +99,7 @@ func isSelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (sel
 
 func evalSelector(ctx ExprContext, self *term) (v any, err error) {
 	var exprValue any
-	// var caseList []*term
+	var match bool
 
 	if err = self.checkOperands(); err != nil {
 		return
@@ -110,11 +113,11 @@ func evalSelector(ctx ExprContext, self *term) (v any, err error) {
 	caseList, _ := caseListTerm.value().([]*term)
 	for i, caseTerm := range caseList {
 		caseSel := caseTerm.value()
-		if v, err = isSelectorCase(ctx, exprValue, caseSel, i); err != nil || v != nil {
+		if match, v, err = isSelectorCase(ctx, exprValue, caseSel, i); err != nil || match {
 			break
 		}
 	}
-	if err == nil && v == nil {
+	if err == nil && !match {
 		err = exprTerm.tk.Errorf("no case catches the value (%v) of the selection expression", exprValue)
 	}
 	return

parser_test.go

@@ -64,7 +64,7 @@ func TestParser(t *testing.T) {
 		/*  43 */ {`+false`, nil, errors.New(`[1:2] prefix/postfix operator "+" do not support operand 'false' [bool]`)},
 		/*  44 */ {`false // very simple expression`, false, nil},
 		/*  45 */ {`1 + // Missing right operator`, nil, errors.New(`[1:4] infix operator "+" requires two non-nil operands, got 1`)},
-		/*  46 */ {"", nil, errors.New(`empty expression`)},
+		/*  46 */ {"", nil, nil},
 		/*  47 */ {"4!", int64(24), nil},
 		/*  48 */ {"(-4)!", nil, errors.New(`factorial of a negative integer (-4) is not allowed`)},
 		/*  49 */ {"-4!", int64(-24), nil},
@@ -158,6 +158,9 @@ func TestParser(t *testing.T) {
 		/* 137 */ {`2 + 1 ? {"a"} : {"b"} * 3`, "2bbb", nil},
 		/* 138 */ {`nil`, nil, nil},
 		/* 139 */ {`null`, nil, errors.New(`undefined variable "null"`)},
+		/* 140 */ {`isNil(nil)`, true, nil},
+		/* 141 */ {`v=nil; isNil(v)`, true, nil},
+		/* 142 */ {`v=5; isNil(v)`, false, nil},
 	}
 	check_env_expr_path := 113
 
@@ -165,7 +168,7 @@ func TestParser(t *testing.T) {
 	failed := 0
 
 	// inputs1 := []inputType{
-	// 	{`10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}`, "b", nil},
+	// 	/* 140 */ {`isNil(nil)`, true, nil},
 	// }
 
 	for i, input := range inputs {

simple-func-store.go

@@ -35,10 +35,12 @@ func (info *funcInfo) Functor() Functor {
 }
 
 func NewSimpleFuncStore() *SimpleFuncStore {
-	return &SimpleFuncStore{
+	ctx := &SimpleFuncStore{
 		SimpleVarStore: SimpleVarStore{varStore: make(map[string]any)},
 		funcStore:      make(map[string]*funcInfo),
 	}
+	ImportBuiltinsFuncs(ctx)
+	return ctx
 }
 
 func (ctx *SimpleFuncStore) Clone() ExprContext {