commit

ast.go

@@ -5,6 +5,7 @@
 package expr
 
 import (
+	"errors"
 	"strings"
 )
 
@@ -60,10 +61,10 @@ func (self *ast) addToken(tk *Token) (err error) {
 }
 
 func (self *ast) addToken2(tk *Token) (t *term, err error) {
-	if t = newTerm(tk); t != nil {
+	if t = newTerm(tk, nil); t != nil {
 		err = self.addTerm(t)
 	} else {
-		err = tk.Errorf("unexpected token %q", tk.String())
+		err = tk.Errorf("No term constructor for token %q", tk.String())
 	}
 	return
 }
@@ -83,9 +84,8 @@ func (self *ast) insert(tree, node *term) (root *term, err error) {
 		if tree.isComplete() {
 			var subRoot *term
 			last := tree.removeLastChild()
-			if subRoot, err = self.insert(last, node); err == nil {
+			subRoot, err = self.insert(last, node)
-				subRoot.setParent(tree)
+			subRoot.setParent(tree)
-			}
 		} else {
 			node.setParent(tree)
 		}
@@ -119,7 +119,7 @@ func (self *ast) eval(ctx ExprContext, preset bool) (result any, err error) {
 		if self.forest != nil {
 			for _, root := range self.forest {
 				if result, err = root.compute(ctx); err == nil {
-					ctx.UnsafeSetVar(ControlLastResult, result)
+					ctx.setVar(ControlLastResult, result)
 				} else {
 					//err = fmt.Errorf("error in expression nr %d: %v", i+1, err)
 					break
@@ -127,12 +127,10 @@ func (self *ast) eval(ctx ExprContext, preset bool) (result any, err error) {
 			}
 		}
 		if err == nil {
-			if result, err = self.root.compute(ctx); err == nil {
+			result, err = self.root.compute(ctx)
-				ctx.UnsafeSetVar(ControlLastResult, result)
-			}
 		}
-		// } else {
+	} else {
-		// 	err = errors.New("empty expression")
+		err = errors.New("empty expression")
 	}
 	return
 }

ast_test.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// t_ast_test.go
+// ast_test.go
 package expr
 
 import (
@@ -44,7 +44,7 @@ func TestAddTokensBad(t *testing.T) {
 func TestAddUnknownTokens(t *testing.T) {
 	tk0 := NewToken(0, 0, SymPercent, "%")
 
-	wantErr := errors.New(`unexpected token "%"`)
+	wantErr := errors.New(`No term constructor for token "%"`)
 
 	tree := NewAst()
 	if gotErr := tree.addToken(tk0); gotErr != nil && gotErr.Error() != wantErr.Error() {

common-errors.go

@@ -1,55 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// common-errors.go
-package expr
-
-import (
-	"fmt"
-)
-
-func errTooFewParams(funcName string, minArgs, maxArgs, argCount int) (err error) {
-	if maxArgs < 0 {
-		err = fmt.Errorf("%s(): too few params -- expected %d or more, got %d", funcName, minArgs, argCount)
-	} else {
-		err = fmt.Errorf("%s(): too few params -- expected %d, got %d", funcName, minArgs, argCount)
-	}
-	return
-}
-
-func errTooMuchParams(funcName string, maxArgs, argCount int) (err error) {
-	err = fmt.Errorf("%s(): too much params -- expected %d, got %d", funcName, maxArgs, argCount)
-	return
-}
-
-// --- General errors
-
-func errCantConvert(funcName string, value any, kind string) error {
-	return fmt.Errorf("%s(): can't convert %s to %s", funcName, typeName(value), kind)
-}
-
-func errExpectedGot(funcName string, kind string, value any) error {
-	return fmt.Errorf("%s() expected %s, got %s (%v)", funcName, kind, typeName(value), value)
-}
-
-func errFuncDivisionByZero(funcName string) error {
-	return fmt.Errorf("%s(): division by zero", funcName)
-}
-
-func errDivisionByZero() error {
-	return fmt.Errorf("division by zero")
-}
-
-// --- Parameter errors
-
-func errMissingRequiredParameter(funcName, paramName string) error {
-	return fmt.Errorf("%s() missing required parameter %q", funcName, paramName)
-}
-
-func errInvalidParameterValue(funcName, paramName string, paramValue any) error {
-	return fmt.Errorf("%s() invalid value %s (%v) for parameter %q", funcName, typeName(paramValue), paramValue, paramName)
-}
-
-func errWrongParamType(funcName, paramName, paramType string, paramValue any) error {
-	return fmt.Errorf("%s() the %q parameter must be a %s, got a %s (%v)", funcName, paramName, paramType, typeName(paramValue), paramValue)
-}

common-params.go

@@ -1,21 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// common-params.go
-package expr
-
-const (
-	paramCount     = "count"
-	paramItem      = "item"
-	paramParts     = "parts"
-	paramSeparator = "separator"
-	paramSource    = "source"
-	paramSuffix    = "suffix"
-	paramPrefix    = "prefix"
-	paramStart     = "start"
-	paramEnd       = "end"
-	paramValue     = "value"
-	paramEllipsis  = "..."
-	paramFilepath  = "filepath"
-	paramDirpath   = "dirpath"
-)

common-type-names.go

@@ -1,18 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// common-type-names.go
-package expr
-
-const (
-	typeAny      = "any"
-	typeBoolean  = "boolean"
-	typeFloat    = "float"
-	typeFraction = "fraction"
-	typeHandle   = "handle"
-	typeInt      = "integer"
-	typeItem     = "item"
-	typeNumber   = "number"
-	typePair     = "pair"
-	typeString   = "string"
-)

context-helpers.go

@@ -1,45 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// context-helpers.go
-package expr
-
-func cloneContext(sourceCtx ExprContext) (clonedCtx ExprContext) {
-	if sourceCtx != nil {
-		clonedCtx = sourceCtx.Clone()
-	}
-	return
-}
-
-func exportVar(ctx ExprContext, name string, value any) {
-	if name[0] == '@' {
-		name = name[1:]
-	}
-	ctx.UnsafeSetVar(name, value)
-}
-
-func exportFunc(ctx ExprContext, name string, info ExprFunc) {
-	if name[0] == '@' {
-		name = name[1:]
-	}
-	// ctx.RegisterFunc(name, info.Functor(), info.MinArgs(), info.MaxArgs())
-	// ctx.RegisterFuncInfo(name, info)
-	ctx.RegisterFunc(name, info.Functor(), info.ReturnType(), info.Params())
-}
-
-func exportObjects(destCtx, sourceCtx ExprContext) {
-	exportAll := isEnabled(sourceCtx, control_export_all)
-	// fmt.Printf("Exporting from sourceCtx [%p] to destCtx [%p] -- exportAll=%t\n", sourceCtx, destCtx, exportAll)
-	// Export variables
-	for _, refName := range sourceCtx.EnumVars(func(name string) bool { return exportAll || name[0] == '@' }) {
-		// fmt.Printf("\tExporting %q\n", refName)
-		refValue, _ := sourceCtx.GetVar(refName)
-		exportVar(destCtx, refName, refValue)
-	}
-	// Export functions
-	for _, refName := range sourceCtx.EnumFuncs(func(name string) bool { return exportAll || name[0] == '@' }) {
-		if info, _ := sourceCtx.GetFuncInfo(refName); info != nil {
-			exportFunc(destCtx, refName, info)
-		}
-	}
-}

context.go

@@ -4,46 +4,39 @@
 // context.go
 package expr
 
+// ---- Function template
+type FuncTemplate func(ctx ExprContext, name string, args []any) (result any, err error)
+
 // ---- Functor interface
 type Functor interface {
 	Invoke(ctx ExprContext, name string, args []any) (result any, err error)
-	SetFunc(info ExprFunc)
-	GetFunc() ExprFunc
-	GetParams() []ExprFuncParam
 }
 
-// ---- Function Param Info
+type simpleFunctor struct {
-type ExprFuncParam interface {
+	f FuncTemplate
-	Name() string
+}
-	Type() string
+
-	IsOptional() bool
+func (functor *simpleFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
-	IsRepeat() bool
+	return functor.f(ctx, name, args)
-	DefaultValue() any
 }
 
 // ---- Function Info
 type ExprFunc interface {
-	Formatter
 	Name() string
 	MinArgs() int
 	MaxArgs() int
 	Functor() Functor
-	Params() []ExprFuncParam
-	ReturnType() string
 }
 
 // ----Expression Context
 type ExprContext interface {
 	Clone() ExprContext
-	Merge(ctx ExprContext)
 	GetVar(varName string) (value any, exists bool)
 	SetVar(varName string, value any)
-	UnsafeSetVar(varName string, value any)
+	setVar(varName string, value any)
 	EnumVars(func(name string) (accept bool)) (varNames []string)
 	EnumFuncs(func(name string) (accept bool)) (funcNames []string)
-	GetFuncInfo(name string) (item ExprFunc, exists bool)
+	GetFuncInfo(name string) ExprFunc
 	Call(name string, args []any) (result any, err error)
-	// RegisterFunc(name string, f Functor, minArgs, maxArgs int)
+	RegisterFunc(name string, f Functor, minArgs, maxArgs int)
-	RegisterFuncInfo(info ExprFunc)
-	RegisterFunc(name string, f Functor, returnType string, param []ExprFuncParam) error
 }

data-cursor.go

@@ -1,154 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// data-cursors.go
-package expr
-
-import (
-	"errors"
-	"io"
-)
-
-type dataCursor struct {
-	ds          map[string]Functor
-	ctx         ExprContext
-	index       int
-	resource    any
-	nextFunc    Functor
-	cleanFunc   Functor
-	resetFunc   Functor
-	currentFunc Functor
-}
-
-func newDataCursor(ctx ExprContext, ds map[string]Functor) (dc *dataCursor) {
-	dc = &dataCursor{
-		ds:    ds,
-		index: -1,
-		ctx:   ctx.Clone(),
-	}
-	return
-}
-
-// func mapToString(m map[string]Functor) string {
-// 	var sb strings.Builder
-// 	sb.WriteByte('{')
-// 	for key, _ := range m {
-// 		if sb.Len() > 1 {
-// 			sb.WriteString(fmt.Sprintf(", %q: func(){}", key))
-// 		} else {
-// 			sb.WriteString(fmt.Sprintf("%q: func(){}", key))
-// 		}
-// 	}
-// 	sb.WriteByte('}')
-// 	return sb.String()
-// }
-
-func (dc *dataCursor) String() string {
-	return "$()"
-	/*
-	   var sb strings.Builder
-	   sb.WriteString(fmt.Sprintf(`$(
-	   index: %d,
-	   ds:    %s,
-	   ctx:   `, dc.index, mapToString(dc.ds)))
-	   CtxToBuilder(&sb, dc.ctx, 1)
-	   sb.WriteByte(')')
-	   return sb.String()
-	*/
-}
-
-func (dc *dataCursor) HasOperation(name string) (exists bool) {
-	exists = name == indexName
-	if !exists {
-		f, ok := dc.ds[name]
-		exists = ok && isFunctor(f)
-	}
-	return
-}
-
-func (dc *dataCursor) CallOperation(name string, args []any) (value any, err error) {
-	if name == indexName {
-		value = int64(dc.Index())
-	} else if functor, ok := dc.ds[name]; ok && isFunctor(functor) {
-		if functor == dc.cleanFunc {
-			value, err = dc.Clean()
-		} else if functor == dc.resetFunc {
-			value, err = dc.Reset()
-		} else {
-			ctx := cloneContext(dc.ctx)
-			value, err = functor.Invoke(ctx, name, []any{})
-			exportObjects(dc.ctx, ctx)
-		}
-	} else {
-		err = errNoOperation(name)
-	}
-	return
-}
-
-func (dc *dataCursor) Reset() (success bool, err error) {
-	if dc.resetFunc != nil {
-		if dc.resource != nil {
-			ctx := cloneContext(dc.ctx)
-			if _, err = dc.resetFunc.Invoke(ctx, resetName, []any{dc.resource}); err == nil {
-				dc.index = -1
-			}
-			exportObjects(dc.ctx, ctx)
-		} else {
-			err = errInvalidDataSource()
-		}
-	} else {
-		err = errNoOperation(resetName)
-	}
-	success = err == nil
-	return
-}
-
-func (dc *dataCursor) Clean() (success bool, err error) {
-	if dc.cleanFunc != nil {
-		if dc.resource != nil {
-			ctx := cloneContext(dc.ctx)
-			_, err = dc.cleanFunc.Invoke(ctx, cleanName, []any{dc.resource})
-			dc.resource = nil
-			exportObjects(dc.ctx, ctx)
-		} else {
-			err = errInvalidDataSource()
-		}
-	} else {
-		err = errors.New("no 'clean' function defined in the data-source")
-	}
-	success = err == nil
-	return
-}
-
-func (dc *dataCursor) Current() (item any, err error) { // must return io.EOF at the last item
-	ctx := cloneContext(dc.ctx)
-	if item, err = dc.currentFunc.Invoke(ctx, currentName, []any{}); err == nil && item == nil {
-		err = io.EOF
-	}
-	exportObjects(dc.ctx, ctx)
-	return
-}
-
-func (dc *dataCursor) Next() (item any, err error) { // must return io.EOF after the last item
-	if dc.resource != nil {
-		ctx := cloneContext(dc.ctx)
-		// fmt.Printf("Entering Inner-Ctx [%p]: %s\n", ctx, CtxToString(ctx, 0))
-		if item, err = dc.nextFunc.Invoke(ctx, nextName, []any{dc.resource}); err == nil {
-			if item == nil {
-				err = io.EOF
-			} else {
-				dc.index++
-			}
-		}
-		// fmt.Printf("Exiting Inner-Ctx [%p]: %s\n", ctx, CtxToString(ctx, 0))
-		exportObjects(dc.ctx, ctx)
-		// fmt.Printf("Outer-Ctx [%p]: %s\n", dc.ctx, CtxToString(dc.ctx, 0))
-	} else {
-		err = errInvalidDataSource()
-	}
-	return
-}
-
-func (dc *dataCursor) Index() int {
-	return dc.index
-}

dict-type.go

@@ -1,130 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// dict-type.go
-package expr
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-)
-
-type DictType map[any]any
-
-func newDict(dictAny map[any]*term) (dict *DictType) {
-	var d DictType
-	if dictAny != nil {
-		d = make(DictType, len(dictAny))
-		for i, item := range dictAny {
-			d[i] = item
-		}
-	} else {
-		d = make(DictType)
-	}
-	dict = &d
-	return
-}
-
-func (dict *DictType) toMultiLine(sb *strings.Builder, indent int) {
-	sb.WriteString(strings.Repeat("\t", indent))
-	sb.WriteString("{\n")
-
-	first := true
-	for name, value := range *dict {
-		if first {
-			first = false
-		} else {
-			sb.WriteByte(',')
-			sb.WriteByte('\n')
-		}
-
-		sb.WriteString(strings.Repeat("\t", indent+1))
-		if key, ok := name.(string); ok {
-			sb.WriteString(string('"') + key + string('"'))
-		} else {
-			sb.WriteString(fmt.Sprintf("%v", name))
-		}
-		sb.WriteString(": ")
-		if f, ok := value.(Formatter); ok {
-			sb.WriteString(f.ToString(MultiLine))
-		} else if _, ok = value.(Functor); ok {
-			sb.WriteString("func(){}")
-		} else {
-			sb.WriteString(fmt.Sprintf("%v", value))
-		}
-	}
-	sb.WriteString(strings.Repeat("\t", indent))
-	sb.WriteString("\n}")
-}
-
-func (dict *DictType) ToString(opt FmtOpt) string {
-	var sb strings.Builder
-	if opt&MultiLine != 0 {
-		dict.toMultiLine(&sb, 0)
-	} else {
-		sb.WriteByte('{')
-		first := true
-		for key, value := range *dict {
-			if first {
-				first = false
-			} else {
-				sb.WriteString(", ")
-			}
-			if s, ok := key.(string); ok {
-				sb.WriteString(string('"') + s + string('"'))
-			} else {
-				sb.WriteString(fmt.Sprintf("%v", key))
-			}
-			sb.WriteString(": ")
-			if formatter, ok := value.(Formatter); ok {
-				sb.WriteString(formatter.ToString(opt))
-			} else if t, ok := value.(*term); ok {
-				sb.WriteString(t.String())
-			} else {
-				sb.WriteString(fmt.Sprintf("%#v", value))
-			}
-		}
-		sb.WriteByte('}')
-	}
-	return sb.String()
-}
-
-func (dict *DictType) String() string {
-	return dict.ToString(0)
-}
-
-func (dict *DictType) TypeName() string {
-	return "dict"
-}
-
-func (dict *DictType) hasKey(target any) (ok bool) {
-	for key := range *dict {
-		if ok = reflect.DeepEqual(key, target); ok {
-			break
-		}
-	}
-	return
-}
-
-func (dict *DictType) clone() (c *DictType) {
-	c = newDict(nil)
-	for k, v := range *dict {
-		(*c)[k] = v
-	}
-	return
-}
-
-func (dict *DictType) merge(second *DictType) {
-	if second != nil {
-		for k, v := range *second {
-			(*dict)[k] = v
-		}
-	}
-}
-
-func (dict *DictType) setItem(key any, value any) (err error) {
-	(*dict)[key]=value
-	return
-}
-

doc/Expr.adoc

@@ -22,242 +22,49 @@ Expressions calculator
 
 toc::[]
 
-#TODO: Work in progress (last update on 2024/06/02, 08:18 a.m.)#
+#TODO: Work in progress#
 
 == Expr
 _Expr_ is a GO package capable of analysing, interpreting and calculating expressions.
 
+
 === Concepts and terminology
 #TODO#
 
-image::expression-diagram.png[]
-
-=== `dev-expr` test tool
-`dev-expr` is a simple program that can be used to evaluate expressions interactively. As its name suggests, it was created for testing purpose.  In fact, in additon to the automatic verification test suite based on the Go test framework, `dev-expr` provides an important aid for quickly testing of new features during their development.
-
-`dev-expr` can work as a _REPL_, _**R**ead-**E**xecute-**P**rint-**L**oop_, or it can process expression acquired from files or standard input.
-
-The program can be downloaded from https://git.portale-stac.it/go-pkg/-/packages/generic/dev-expr/[dev-expr].
-
-Here are some examples of execution.
-
-.Run `dev-expr` in REPL mode and ask for help
-[source,shell]
-----
-# Type 'exit' or Ctrl+D to quit the program.
-
-[user]$ ./dev-expr
-expr -- Expressions calculator v1.7.1(build 2),2024/05/16 (celestino.amoroso@portale-stac.it)
-	Based on the Expr package v0.10.0
-	Type help to get the list of available commands
-	See also https://git.portale-stac.it/go-pkg/expr/src/branch/main/README.adoc
-
->>> help
---- REPL commands:
-      source -- Load a file as input
-         tty -- Enable/Disable ansi output <1>
-        base -- Set the integer output base: 2, 8, 10, or 16
-        exit -- Exit the program
-        help -- Show command list
-          ml -- Enable/Disable multi-line output
-        mods -- List builtin modules
-
---- Command line options:
-    -b <builtin>       Import builtin modules.
-                       <builtin> can be a list of module names or a glob-pattern.
-                       Use the special value 'all' or the pattern '*' to import all modules.
-    -e <expression>    Evaluate <expression> instead of standard-input
-    -i                 Force REPL operation when all -e occurences have been processed
-    -h, --help, help   Show this help menu
-    -m, --modules      List all builtin modules
-    -p                 Print prefix form
-    -t                 Print tree form <2>
-
->>> 
-----
-
-<1> Only available for single fraction values
-<2> Work in progress
-
-.REPL examples
-[source,shell]
-----
-[user]$ ./dev-expr
-expr -- Expressions calculator v1.7.1(build 2),2024/05/16 (celestino.amoroso@portale-stac.it)
-	Based on the Expr package v0.10.0
-	Type help to get the list of available commands
-	See also https://git.portale-stac.it/go-pkg/expr/src/branch/main/README.adoc
-
->>> 2+3
-5
->>> 2+3*(4-1.5)
-9.5
->>> 0xFD + 0b1 + 0o1 <1>
-255
->>> 1|2 + 2|3 <2>
-7|6
->>> ml <3>
->>> 1|2 + 2|3
-7
--
-6
->>> 1+2 but 5|2+0.5 <4>
-3
->>> 1+2; 5|2+0.5 <5>
-3
->>>
-----
-
-<1> Number bases: 0x = hexadecimal, 0o = octal, 0b = binary.
-<2> Fractions: numerator | denominator.
-<3> Activate multi-line output of fractions.
-<4> But operator, see <<_but_operator>>.
-<5> Multi-expression: the same result of the previous single expression but this it is obtained with two separated calculations.
-
 == Data types
 _Expr_ supports numerical, string, relational, boolean expressions, and mixed-type lists.
 
 === Numbers
-_Expr_ supports three type of numbers:
+Numbers can be integers (GO int64) or float (GO float64). In mixed operations involving integers and floats, integers are automatically promoted to floats.
-
-. [blue]#Integers#
-. [blue]#Floats#
-. [blue]#Factions#
-
-In mixed operations involving integers, fractions and floats, automatic type promotion to the largest type take place.
-
-==== Integers
-__Expr__'s integers are a subset of the integer set. Internally they are stored as Golang _int64_ values.
-
-.Integer literal syntax
-====
-*_integer_* = [_sign_] _digit-seq_ +
-_sign_ = "**+**" | "**-**" +
-_digit-seq_ = _dec-seq_ | _bin-seq_ | _oct-seq_ | _hex-seq_ +
-_dec-seq_ = {__dec-digit__} +
-_dec-digit_ = "**0**"|"**1**"|...|"**9**" +
-_bin-seq_ = "**0b**"{__bin-digit__} +
-_bin-digit_ = "**0**"|"**1**" +
-_oct-seq_ = "**0o**"{__oct-digit__} +
-_oct-digit_ = "**0**"|"**1**"|...|"**7**" +
-_hex-seq_ = "**0x**"{__hex-digit__} +
-_hex-digit_ = "**0**"|"**1**"|...|"**9**"|"**a**"|...|"**z**"|"**A**"|...|"**Z**"
-====
-
-Value range: *-9223372036854775808* to *9223372036854775807*
 
 .Arithmetic operators
 [cols="^1,^2,6,4"]
 |===
 | Symbol    | Operation     | Description               | Examples
-| [blue]`+` | _sum_         | Add two values            | [blue]`-1 + 2` -> 1
+
-| [blue]`-` | _subtraction_ | Subtract the right value from the left one | [blue]`3 - 1` -> 2
+| [blue]`+` / [blue]`-` | _change sign_ | Change the sign of values | [blue]`-1` _[-1]_ +
-| [blue]`*` | _product_     | Multiply two values       | [blue]`-1 * 2` -> -2
+[blue]`-(+2)` _[-2]_
-| [blue]`/` | _Division_    | Divide the left value by the right one^(*)^ | [blue]`-10 / 2` -> 5
+
-| [blue]`%` | _Modulo_      | Remainder of the integer division | [blue]`5 % 2` -> 1
+| [blue]`+` | _sum_ | Add two values | [blue]`-1 + 2` _[1]_ +
+[blue]`4 + 0.5` _[4.5]_
+
+| [blue]`-` | _subtraction_ | Subtract the right value from the left one | [blue]`3 - 1` _[2]_ +
+[blue]`4 - 0.5` _[3.5]_
+
+| [blue]`*` | _product_ | Multiply two values | `-1 * 2` _[-2]_ +
+[blue]`4 * 0.5` _[2.0]_
+
+| [blue]`/` | _Division_ | Divide the left value by the right one | [blue]`-1 / 2` _[0]_ +
+[blue]`1.0 / 2` _[0.5]_
+
+| [blue]`./` | _Float division_ | Force float division | [blue]`-1 ./ 2` _[-0.5]_
+
+| [blue]`%` | _Modulo_ | Remainder of the integer division | [blue]`5 % 2` _[1]_
+
 |=== 
 
-^(*)^ See also the _float division_ [blue]`./` below.
+=== String
-
+Strings are character sequences enclosed between two double quote [blue]`"`. Example: [blue]`"I'm a string"`.
-
-==== Floats
-__Expr__'s floats are a subset of the rational number set. Note that they can't hold the exact value of an unlimited number; floats can only approximate them. Internally floats are stored as Golang's _float64_ values.
-
-
-.Float literal syntax
-====
-*_float_* = [_sign_] _dec-seq_ "**.**" [_dec-seq_] [("**e**"|"**E**") [_sign_] _dec-seq_] +
-_sign_ = "**+**" | "**-**" +
-_dec-seq_ = _see-integer-literal-syntax_
-====
-
-.Examples
-`>>>` [blue]`1.0` +
-[green]`1` +
-`>>>` [blue]`0.123` +
-[green]`0.123` +
-`>>>` [blue]`4.5e+3` +
-[green]`4500` +
-`>>>` [blue]`4.5E-33` +
-[green]`4.5e-33` +
-`>>>` [blue]`4.5E-3` +
-[green]`0.0045` +
-`>>>` [blue]`4.5E10` +
-[green]`4.5e+10`
-
-
-.Arithmetic operators
-[cols="^1,^2,6,4"]
-|===
-| Symbol    | Operation     | Description               | Examples
-| [blue]`+` | _sum_         | Add two values            | [blue]`4 + 0.5` -> 4.5
-| [blue]`-` | _subtraction_ | Subtract the right value from the left one | [blue]`4 - 0.5` -> 3.5
-| [blue]`*` | _product_     | Multiply two values       | [blue]`4 * 0.5` -> 2.0
-| [blue]`/` | _Division_    | Divide the left value by the right one | [blue]`1.0 / 2` -> 0.5
-| [blue]`./`| _Float division_ | Force float division   | [blue]`-1 ./ 2` -> -0.5
-|===
-
-==== Fractions
-_Expr_ also supports fractions. Fraction literals are made with two integers separated by a vertical bar `|`.
-
-.Fraction literal syntax
-====
-*_fraction_* = [__sign__] (_num-den-spec_ | _float-spec_) +
-_sign_ = "**+**" | "**-**" +
-_num-den-spec_ = _digit-seq_ "**|**" _digit-seq_ +
-_float-spec_ = _dec-seq_ "**.**" [_dec-seq_] "**(**" _dec-seq_ "**)**" +
-_dec-seq_ = _see-integer-literal-syntax_ +
-_digit-seq_ = _see-integer-literal-syntax_
-====
-
-.Examples
-// [source,go]
-// ----
-`>>>` [blue]`1 | 2` +
-[green]`1|2` +
-`>>>` [blue]`4|6`  [gray]_// Fractions are always reduced to their lowest terms_ +
-[green]`2|3` +
-`>>>` [blue]`1|2 + 2|3` +
-[green]`7|6` +
-`>>>` [blue]`1|2 * 2|3` +
-[green]`1|3` +
-`>>>` [blue]`1|2 / 1|3` +
-[green]`3|2` +
-`>>>` [blue]`1|2 ./ 1|3` [gray]_// Force decimal division_ +
-[green]`1.5` +
-`>>>` [blue]`-1|2` +
-[green]`-1|2` +
-`>>>` [blue]`1|-2` [gray]_// Invalid sign specification_ +
-[red]_Eval Error: [1:3] infix operator "|" requires two non-nil operands, got 1_ +
-`>>>` [blue]`1|(-2)` +
-[green]`-1|2`
-// ----
-
-Fractions can be used together with integers and floats in expressions.
-
-.Examples
-`>>>` [blue]`1|2 + 5` +
-[green]`11|2` +
-`>>>` [blue]`4 - 1|2` +
-[green]`7|2` +
-`>>>` [blue]`1.0 + 1|2` +
-[green]`1.5`
-
-
-
-=== Strings
-Strings are character sequences enclosed between two double quote [blue]`"`.
-
-.Examples
-`>>>` [blue]`"I'm a string"` +
-[green]`I'm a string` +
-`>>>` [blue]`"123abc?!"` +
-[green]`123abc?!` +
-`>>>` [blue]`"123\nabc"` +
-[green]`123` +
-[green]`abc` +
-`>>>` [blue]`"123\tabc"` +
-[green]`123{nbsp}{nbsp}{nbsp}{nbsp}abc`
 
 Some arithmetic operators can also be used with strings.
 
@@ -266,75 +73,55 @@ Some arithmetic operators can also be used with strings.
 |===
 | Symbol    | Operation     | Description               | Examples
 
-| [blue]`+` | _concatenation_ | Join two strings or two _stringable_ values | [blue]`"one" + "two"` -> _"onetwo"_ +
+| [blue]`+` | _concatenation_ | Join two strings or two _stringable_ values | [blue]`"one" + "two"` _["onetwo"]_ +
-[blue]`"one" + 2` -> _"one2"_
+[blue]`"one" + 2` _["one2"]_
 
-| [blue]`*` | _repeat_ | Make _n_ copy of a string  | [blue]`"one" * 2` -> _"oneone"_
+| [blue]`*` | _repeat_ | Make _n_ copy of a string  | [blue]`"one" * 2` _["oneone"]_
 |===
 
-The items of strings can be accessed using the dot `.` operator.
 
-.Item access syntax
+=== Boolean
-====
+Boolean data type has two values only: _true_ and _false_. Relational and Boolean expressions produce Boolean values.
-_item_ = _string-expr_ "**.**" _integer-expr_
-====
-
-.String examples
-`>>>` [blue]`s="abc"`  [gray]_// assign the string to variable s_ +
-[green]`abc` +
-`>>>` [blue]`s.1`      [gray]_// char at position 1 (starting from 0)_ +
-[green]`b` +
-`>>>` [blue]`s.(-1)`   [gray]_// char at position -1, the rightmost one_ +
-[green]`c` +
-`>>>` [blue]`\#s`       [gray]_// number of chars_ +
-[gren]`3` +
-`>>>` [blue]`#"abc"`   [gray]_// number of chars_ +
-[green]`3`
 
 
-=== Booleans
+.Relational operators
-Boolean data type has two values only: [blue]_true_ and [blue]_false_. Relational and boolean expressions result in boolean values.
-
-.Relational operators^(*)^
 [cols="^1,^2,6,4"]
 |===
 | Symbol    | Operation     | Description               | Examples
 
-| [blue]`==` | _Equal_ | True if the left value is equal to the right one | [blue]`5 == 2` -> _false_ +
+| [blue]`==` | _Equal_ | True if the left value is equal to the right one | [blue]`5 == 2` _[false]_ +
-[blue]`"a" == "a"` -> _true_
+[blue]`"a" == "a"` _[true]_
-| [blue]`!=` | _Not Equal_ | True if the left value is NOT equal to the right one | [blue]`5 != 2` -> _true_ +
+| [blue]`!=` | _Not Equal_ | True if the left value is NOT equal to the right one | [blue]`5 != 2` _[true]_ +
-[blue]`"a" != "a"` -> _false_
+[blue]`"a" != "a"` _[false]_
-| [blue]`<` | _Less_ | True if the left value is less than the right one | [blue]`5 < 2` -> _false_ +
+| [blue]`<` | _Less_ | True if the left value is less than the right one | [blue]`5 < 2` _[false]_ +
-[blue]`"a" < "b"` -> _true_
+[blue]`"a" < "b"` _[true]_
-| [blue]`\<=` | _Less or Equal_ | True if the left value is less than or equal to the right one | [blue]`5 \<= 2` -> _false_ +
+| [blue]`\<=` | _Less or Equal_ | True if the left value is less than or equal to the right one | [blue]`5 \<= 2` _[false]_ +
-[blue]`"b" \<= "b"` -> _true_
+[blue]`"b" \<= "b"` _[true]_
-| [blue]`>` | _Greater_ | True if the left value is greater than the right one | [blue]`5 > 2` -> _true_ +
+| [blue]`>` | _Greater_ | True if the left value is greater than the right one | [blue]`5 > 2` _[true]_ +
-[blue]`"a" < "b"` -> _false_
+[blue]`"a" < "b"` _[false]_
-| [blue]`>=` | _Greater or Equal_ | True if the left value is greater than or equal to the right one | [blue]`5 >= 2` -> _true_ +
+| [blue]`>=` | _Greater or Equal_ | True if the left value is greater than or equal to the right one | [blue]`5 >= 2` _[true]_ +
-[blue]`"b" \<= "b"` -> _true_
+[blue]`"b" \<= "b"` _[true]_
 |===
 
-^(*)^ See also the  [blue]`in` operator in the _list_ and _dictionary_ sections.
-
 
 .Boolean operators
 [cols="^2,^2,5,4"]
 |===
 | Symbol    | Operation     | Description               | Examples
 
-| [blue]`NOT` | _Not_ | True if the right value is false | [blue]`NOT true` -> _false_ +
+| [blue]`NOT` | _Not_ | True if the right value is false | [blue]`NOT true` _[false]_ +
-[blue]`NOT (2 < 1)` -> _true_
+[blue]`NOT (2 < 1)` _[true]_
 
-| [blue]`AND` / [blue]`&&` | _And_ | True if both left and right values are true  | [blue]`false && true` -> _false_ +
+| [blue]`AND` / [blue]`&&` | _And_ | True if both left and right values are true  | [blue]`false && true` _[false]_ +
-[blue]`"a" < "b" AND NOT (2 < 1)` -> _true_
+[blue]`"a" < "b" AND NOT (2 < 1)` _[true]_
 
-| [blue]`OR` / [blue]`\|\|` | _Or_ | True if at least one of the left and right values integers true| [blue]`false or true` -> _true_ +
+| [blue]`OR` / [blue]`\|\|` | _Or_ | True if at least one of the left and right values integers true| [blue]`false or true` _[true]_ +
-[blue]`"a" == "b" OR (2 == 1)` -> _false_
+[blue]`"a" == "b" OR (2 == 1)` _[false]_
 |===
 
 [CAUTION]
 ====
-Currently, boolean operations are evaluated using _short cut evaluation_. This means that, if the left expression of the [blue]`and` and [blue]`or` operators is sufficient to establish the result of the whole operation, the right expression would not evaluated at all.
+Currently, boolean operations are evaluated using _short cut evaluation_. This means that, if the left expression of operators [blue]`and` and [blue]`or` is sufficient to establish the result of the whole operation, the right expression would not evaluated at all.
 
 .Example
 [source,go]
@@ -344,281 +131,132 @@ Currently, boolean operations are evaluated using _short cut evaluation_. This m
 <1> This multi-expression returns _1_ because in the first expression the left value of [blue]`or` is _true_ and as a conseguence its right value is not computed. Therefore the _a_ variable only receives the integer _1_.
 ====
 
-=== Lists
+=== List
-_Expr_ supports list of mixed-type values, also specified by normal expressions. Internally, _Expr_'s lists are Go arrays.
+_Expr_ supports list of mixed-type values, also specified by normal expressions.
 
-.List literal syntax
+.List examples
-====
+[source,go]
-*_list_* = _empty-list_ | _non-empty-list_ +
+----
-_empty-list_ = "**[]**" +
+[1, 2, 3]                   // List of integers
-_non-empty-list_ = "**[**" _any-value_ {"**,**" _any-value} "**]**" +
+["one", "two", "three"]     // List of strings
-====
+["one", 2, false, 4.1]      // List of mixed-types
+["one"+1, 2.0*(9-2)]        // List of expressions
+[ [1,"one"], [2,"two"]]     // List of lists
+----
 
-.Examples
-`>>>` [blue]`[1,2,3]`                     [gray]_// List of integers_ +
-[green]`[1, 2, 3]` +
-`>>>` [blue]`["one", "two", "three"]`     [gray]_// List of strings_ +
-[green]`["one", "two", "three"]` +
-`>>>` [blue]`["one", 2, false, 4.1]`      [gray]_// List of mixed-types_ +
-[green]`["one", 2, false, 4.1]` +
-`>>>` [blue]`["one"+1, 2.0*(9-2)]`        [gray]_// List of expressions_ +
-[green]`["one1", 14]` +
-`>>>` [blue]`[ [1,"one"], [2,"two"]]`     [gray]_// List of lists_ +
-[green]`[[1, "one"], [2, "two"]]`
 
 .List operators
 [cols="^2,^2,5,4"]
 |===
 | Symbol    | Operation     | Description               | Examples
 
-| [blue]`+` | _Join_ | Joins two lists | [blue]`[1,2] + [3]` -> _[1,2,3]_
+| [blue]`+` | _Join_ | Joins two lists | [blue]`[1,2] + [3]` _[ [1,2,3] ]_
-| [blue]`-` | _Difference_ | Left list without elements in the right list  | [blue]`[1,2,3] - [2]` -> _[1,3]_
+
-| [blue]`>>` | _Front insertion_ | Insert an item in front | [blue]`0 >> [1,2]` -> _[0,1,2]_
+| [blue]`-` | _Difference_ | Left list without elements in the right list  | [blue]`[1,2,3] - [2]` _[ [1,3] ]_
-| [blue]`<<` | _Back insertion_ | Insert an item at end | [blue]`[1,2] << 3` -> _[1,2,3]_
-| [blue]`.` | _List item_ | Item at given position | [blue]`[1,2.3].1` -> _2_
-| [blue]`in` | _Item in list_ | True if item is in list | [blue]`2 in [1,2,3]` -> _true_ +
-[blue]`6 in [1,2,3]` -> _false_
 |===
 
-The items of array can be accessed using the dot `.` operator.
-
-.Item access syntax
-====
-_item_ = _list-expr_ "**.**" _integer-expr_
-====
-
-.Items of list
-`>>>` [blue]`[1,2,3].1` +
-[green]`2` +
-`>>>` [blue]`list=[1,2,3]; list.1` +
-[green]`2` +
-`>>>` [blue]`["one","two","three"].1` +
-[green]`two` +
-`>>>` [blue]`list=["one","two","three"]; list.(2-1)` +
-[green]`two` +
-`>>>` [blue]`list.(-1)` +
-[green]`three` +
-`>>>` [blue]`list.(10)` +
-[red]`Eval Error: [1:9] index 10 out of bounds` +
-`>>>` [blue]`#list` +
-[green]`3` +
-`>>>` [blue]`index=2; ["a", "b", "c", "d"].index` +
-[green]`c`
-
-
-
-=== Dictionaries
-The _dictionary_, or _dict_, data-type is set of pairs _key/value_. It is also known as _map_ or _associative array_.
-
-Dictionary literals are sequences of pairs separated by comma [blue]`,` enclosed between brace brackets.
-
-.Dict literal syntax
-====
-*_dict_* = _empty-dict_ | _non-empty-dict_ +
-_empty-dict_ = "**{}**" +
-_non-empty-dict_ = "**{**" _key-scalar_ "**:**" _any-value_ {"**,**" _key-scalar_ "**:**" _any-value} "**}**" +
-====
-
-.Examples
-`>>>` [blue]`{1:"one", 2:"two"}` +
-[green]`{1: "one", 2: "two"}` +
-`>>>` [blue]`{"one":1, "two": 2}` +
-[green]`{"one": 1, "two": 2}` +
-`>>>` [blue]`{"sum":1+2+3, "prod":1*2*3}` +
-[green]`{"sum": 6, "prod": 6}`
-
-
-.Dict operators
-[cols="^2,^2,4,5"]
-|===
-| Symbol    | Operation     | Description               | Examples
-
-| [blue]`+` | _Join_ | Joins two dicts | [blue]`{1:"one"}+{6:"six"}` -> _{1: "one", 6: "six"}_
-| [blue]`.` | _Dict item value_ | Item value of given key | [blue]`{"one":1, "two":2}."two"` -> _2_
-| [blue]`in` | _Key in dict_ | True if key is in dict | [blue]`"one" in {"one":1, "two":2}` -> _true_ +
-[blue]`"six" in {"one":1, "two":2}` -> _false_
-|===
-
-
 == Variables
-_Expr_, like most programming languages, supports variables. A variable is an identifier with an assigned value. Variables are stored in _contexts_.
+A variable is an identifier with an assigned value. Variables are stored in the object that implements the _ExprContext_ interface.
-
-.Variable literal syntax
-====
-*_variable_* = _identifier_ "*=*" _any-value_ +
-_identifier_ = _alpha_ {(_alpha_)|_dec-digit_|"*_*"} +
-__alpha__ = "*a*"|"*b*"|..."*z*"|"*A*"|"*B*"|..."*Z*"
-====
-
-NOTE: The assign operator [blue]`=` returns the value assigned to the variable.
 
 .Examples
-`>>>` [blue]`a=1` +
+[source,go]
-[green]`1` +
+----
-`>>>` [blue]`a_b=1+2` +
+a=1
-[green]`1+2` +
+x = 5.2 * (9-3)
-`>>>` [blue]`a_b` +
+x = 1; y = 2*x
-[green]`3` +
+----
-`>>>` [blue]`x = 5.2 * (9-3)`  [gray]_// The assigned value has the approximation error typical of the float data-type_ +
-[green]`31.200000000000003` +
-`>>>` [blue]`x = 1; y = 2*x` +
-[green]`2` +
-`>>>` [blue]`_a=2` +
-[red]`Parse Error: [1:2] unexpected token "_"` +
-`>>>` [blue]`1=2` +
-[red]`Parse Error: assign operator ("=") must be preceded by a variable`
-
 
 == Other operations
 
 === [blue]`;` operator
-The semicolon operator [blue]`;` is an infixed pseudo-operator. It evaluates the left expression first and then the right expression. The value of the latter is the final result.
+The semicolon operator [blue]`;` is an infixed operator. It evaluates the left expression first and then the right expression. The latter is the final result.
-
-An expression that contains [blue]`;` is called a _multi-expression_ and each component expressione is called a _sub-expression_.
 
 IMPORTANT: Technically [blue]`;` is not treated as a real operator. It acts as a separator in lists of expressions.
 
 TIP: [blue]`;` can be used to set some variables before the final calculation.
 
 .Example
-`>>>` [blue]`a=1; b=2; c=3; a+b+c` +
+[source,go]
-[green]`6`
+----
-
+a=1; b=2; c=3; a+b+c    // returns 6
-The value of each sub-expression is stored in the automatica variable _last_.
+----
-
-.Example
-`>>>` [blue]`2+3; b=last+10; last` +
-[green]`15`
-
 
 === [blue]`but` operator
-[blue]`but` is an infixed operator. Its operands can be expressions of any type. It evaluates the left expression first, then the right expression. The value of the right expression is the final result.
+[blue]`but` is an infixed operator. Its operands can be any type of expression. It evaluates the left expression first, then the right expression. The value of the right expression is the final result. Examples: [blue]`5 but 2` returns 2, [blue]`x=2*3 but x-1` returns 5.
 
-.Examples
+[blue]`but` is very similar to [blue]`;`. The only difference is that [blue]`;` can't be used inside parenthesis [blue]`(` and [blue]`)`.
-[blue]`5 but 2` +
-[green]`2` +
-[blue]`x=2*3 but x-1` +
-[green]`5`.
-
-[blue]`but` behavior is very similar to [blue]`;`. The only difference is that [blue]`;` is not a true operator and can't be used inside parenthesis [blue]`(` and [blue]`)`.
 
 === Assignment operator [blue]`=`
-The assignment operator [blue]`=` is used to define variables or to change their value in the evaluation context (see _ExprContext_).
+The assignment operator [blue]`=` is used to define variable in the evaluation context or to change their value (see _ExprContext_).
-
 The value on the left side of [blue]`=` must be an identifier. The value on the right side can be any expression and it becomes the result of the assignment operation.
 
 .Example
-`>>>` [blue]`a=15+1`
+[source,go]
-[green]`16`
+----
-
+a=15+1    // returns 16
+----
 
 === Selector operator [blue]`? : ::`
 The _selector operator_ is very similar to the _switch/case/default_ statement available in many programming languages.
 
-.Selector literal Syntax
+.Syntax
-_selector-operator_ = _select-expression_ "*?*" _selector-case_ { "*:*" _selector-case_ } ["*::*" _default-multi-expression_] +
+[source,bnf]
-_selector-case_ = [_match-list_] _case-value_ +
+----
-_match-list_ = "*[*" _item_ {"*,*" _items_} "*]*" +
+<selector-operator> ::= <expression> "?" <selector-case> { ":" <selector-case> } ["::" <case-value>]
-_item_ = _expression_ +
+<selector-case> ::= [<list>] <case-value>
-_case-multi-expression_ = "*{*" _multi-expression_ "*}*" +
+<case-value> ::= "{" <multi-expr> "}"
-_multi-expression_ = _expression_ { "*;*" _expression_ } +
+<multi-expr> ::= <expr> {";" <expr>}
-_default-multi-expression_ = _multi-expression_
+----
 
-In other words, the selector operator evaluates the _select-expression_ on the left-hand side of the [blue]`?` symbol; it then compares the result obtained with the values listed in the __match-list__'s, from left to right. If the comparision finds a match with a value in a _match-list_, the associated _case-multi-expression_ is evaluted, and its result will be the final result of the selection operation.
+.Example
-
+[source,go]
-The match lists are optional. In that case, the position, from left to right, of the _selector-case_ is used as _match-list_. Of course, that only works if the _select-expression_ results in an integer.
+----
-
+1 ? {"a"} : {"b"}                           // returns "b"
-The [blue]`:` symbol (colon) is the separator of the selector-cases. Note that if the value of the _select-expression_ does not match any _match-list_, an error will be issued. Therefore, it is strongly recommended to provide a default (multi-)expression introduced by the [blue]`::` symbol (double-colon). Also note that the default expression has no _match-list_.
+10 ? {"a"} : {"b"} :: {"c"}                 // returns "c"
-
+10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}      // returns "b"
-.Examples
+10 ? {"a"} :[true, 2+8] {"b"} ::[10] {"c"}  // error:  "... case list in default clause"
-`>>>` [blue]`1 ? {"a"} : {"b"}` +
+10 ? {"a"} :[10] {x="b" but x} :: {"c"}     // returns "b"
-[green]`b` +
+10 ? {"a"} :[10] {x="b"; x} :: {"c"}        // returns "b"
-`>>>` [blue]`10 ? {"a"} : {"b"} :: {"c"}` +
+10 ? {"a"} : {"b"}                          // error:  "... no case catches the value (10) of the selection expression
-[green]`c' +
+----
-[green]`>>>` [blue]`10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}` +
-[green]`b` +
-`>>>` [blue]`10 ? {"a"} :[true, 2+8] {"b"} ::[10] {"c"}` +
-[red]`Parse Error: [1:34] case list in default clause` +
-[green]`>>>` [blue]`10 ? {"a"} :[10] {x="b" but x} :: {"c"}` +
-[green]`b` +
-`>>>` [blue]`10 ? {"a"} :[10] {x="b"; x} :: {"c"}` +
-[green]`b` +
-`>>>` [blue]`10 ? {"a"} : {"b"}` +
-[red]`Eval Error: [1:3] no case catches the value (10) of the selection expression`
-
-
-=== Variable default value [blue]`??` and [blue]`?=`
-The left operand of these two operators must be a variable. The right operator can be any expression. They return the value of the variable if this is define; otherwise they return the value of the right expression.
-
-IMPORTANT: If the left variable is defined, the right expression is not evuated at all.
-
-The [blue]`??` do not change the status of the left variable.
-
-The [blue]`?=` assigns the calculated value of the right expression to the left variable.
-
-.Examples
-`>>>` [blue]`var ?? (1+2)`'
-[green]`3` +
-`>>>` [blue]`var` +
-[red]`Eval Error: undefined variable or function "var"` +
-`>>>` [blue]`var ?= (1+2)` +
-[green]`3` +
-`>>>` [blue]`var` +
-[green]`3`
-
-NOTE: These operators have a high priority, in particular higher than the operator [blue]`=`.
 
 == Priorities of operators
 The table below shows all supported operators by decreasing priorities.
 
 .Operators priorities
-[cols="^2,^2,^2,^5,^6"]
+[cols="^2,^2,^2,^5,<5"]
 |===
 | Priority | Operators     | Position | Operation | Operands and results
 
-.2+|*ITEM*| [blue]`.` | _Infix_ | _List item_| _list_ `"."` _integer_ -> _any_
+1+|*FACT*| [blue]`!` | _Postfix_ | _Factorial_| _integer_ "!" -> _integer_
-| [blue]`.` | _Infix_ | _Dict item_ | _dict_ `"."` _any_ -> _any_
+1+|*SIGN*| [blue]`+`, [blue]`-` | _Prefix_ | _Change-sign_| ("+"\|"-") _number_ -> _number_
-.2+|*INC*| [blue]`++` | _Postfix_ | _Post increment_| _integer-variable_ `"++"` -> _integer_
+.5+|*PROD*| [blue]`*` | _Infix_ | _Product_ | _number_ "*" _number_ -> _number_
-| [blue]`++` | _Postfix_ | _Next item_ | _iterator_ `"++"` -> _any_
+| [blue]`*` | _Infix_ | _String-repeat_ | _string_ "*" _integer_ -> _string_
-.1+|*FACT*| [blue]`!` | _Postfix_ | _Factorial_| _integer_ `"!"` -> _integer_
+| [blue]`/` | _Infix_ | _Division_ | _number_ "/" _number_ -> _number_
-.3+|*SIGN*| [blue]`+`, [blue]`-` | _Prefix_ | _Change-sign_| (`"+"`\|`"-"`) _number_ -> _number_
+| [blue]`./` | _Infix_ | _Float-division_ | __number__ "./" _number_ -> _float_
-| [blue]`#` | _Prefix_ | _Lenght-of_ | `"#"` _collection_ -> _integer_
+| [blue]`%` | _Infix_ | _Integer-remainder_ | _integer_ "%" _integer_ -> _integer_
-| [blue]`#` | _Prefix_ | _Size-of_ | `"#"` _iterator_ -> _integer_
+.5+|*SUM*| [blue]`+` | _Infix_ | _Sum_ | _number_ "+" _number_ -> _number_
-.5+|*PROD*| [blue]`*` | _Infix_ | _Product_ | _number_ `"*"` _number_ -> _number_
+| [blue]`+` | _Infix_ |  _String-concat_ | (_string_\|_number_) "+" (_string_\|_number_) -> _string_
-| [blue]`*` | _Infix_ | _String-repeat_ | _string_ `"*"` _integer_ -> _string_
+| [blue]`+` | _Infix_ |  _List-join_ | _list_ "+" _list_ -> _list_
-| [blue]`/` | _Infix_ | _Division_ | _number_ `"/"` _number_ -> _number_
+| [blue]`-` | _Infix_ | _Subtraction_ | _number_ "-" _number_ -> _number_
-| [blue]`./` | _Infix_ | _Float-division_ | __number__ `"./"` _number_ -> _float_
+| [blue]`-` | _Infix_ | _List-difference_ | _list_ "-" _list_ -> _list_
-| [blue]`%` | _Infix_ | _Integer-remainder_ | _integer_ `"%"` _integer_ -> _integer_
+.6+|*RELATION*| [blue]`<` | _Infix_ | _less_ | _comparable_ "<" _comparable_ -> _boolean_
-.6+|*SUM*| [blue]`+` | _Infix_ | _Sum_ | _number_ `"+"` _number_ -> _number_
+| [blue]`\<=` | _Infix_ |  _less-equal_ | _comparable_ "\<=" _comparable_ -> _boolean_
-| [blue]`+` | _Infix_ |  _String-concat_ | (_string_\|_number_) `"+"` (_string_\|_number_) -> _string_
+| [blue]`>` | _Infix_ |  _greater_ | _comparable_ ">" _comparable_ -> _boolean_
-| [blue]`+` | _Infix_ |  _List-join_ | _list_ `"+"` _list_ -> _list_
+| [blue]`>=` | _Infix_ |  _greater-equal_ | _comparable_ ">=" _comparable_ -> _boolean_
-| [blue]`+` | _Infix_ |  _Dict-join_ | _dict_ `"+"` _dict_ -> _dict_
+| [blue]`==` | _Infix_ |  _equal_ | _comparable_ "==" _comparable_ -> _boolean_
-| [blue]`-` | _Infix_ | _Subtraction_ | _number_ `"-"` _number_ -> _number_
+| [blue]`!=` | _Infix_ |  _not-equal_ | _comparable_ "!=" _comparable_ -> _boolean_
-| [blue]`-` | _Infix_ | _List-difference_ | _list_ `"-"` _list_ -> _list_
+.1+|*NOT*| [blue]`not` | _Prefix_ | _not_ | "not" _boolean_ -> _boolean_
-.8+|*RELATION*| [blue]`<` | _Infix_ | _less_ | _comparable_ `"<"` _comparable_ -> _boolean_
+.2+|*AND*| [blue]`and` | _Infix_ | _and_ | _boolean_ "and" _boolean_ -> _boolean_
-| [blue]`\<=` | _Infix_ |  _less-equal_ | _comparable_ `"\<="` _comparable_ -> _boolean_
+| [blue]`&&` | _Infix_ | _and_ | _boolean_ "&&" _boolean_ -> _boolean_
-| [blue]`>` | _Infix_ |  _greater_ | _comparable_ `">"` _comparable_ -> _boolean_
+.2+|*OR*| [blue]`or` | _Infix_ | _or_ | _boolean_ "or" _boolean_ -> _boolean_
-| [blue]`>=` | _Infix_ |  _greater-equal_ | _comparable_ `">="` _comparable_ -> _boolean_
+| [blue]`\|\|` | _Infix_ | _or_ | _boolean_ "\|\|" _boolean_ -> _boolean_
-| [blue]`==` | _Infix_ |  _equal_ | _comparable_ `"=="` _comparable_ -> _boolean_
+.1+|*ASSIGN*| [blue]`=` | _Infix_ | _assignment_ | _identifier_ "=" _any_ -> _any_
-| [blue]`!=` | _Infix_ |  _not-equal_ | _comparable_ `"!="` _comparable_ -> _boolean_
+.1+|*BUT*| [blue]`but` | _Infix_ | _but_ | _any_ "but" _any_ -> _any_
-| [blue]`in` | _Infix_ |  _member-of-list_ | _any_ `"in"` _list_ -> _boolean_
-| [blue]`in` | _Infix_ |  _key-of-dict_ | _any_ `"in"` _dict_ -> _boolean_
-.1+|*NOT*| [blue]`not` | _Prefix_ | _not_ | `"not"` _boolean_ -> _boolean_
-.2+|*AND*| [blue]`and` | _Infix_ | _and_ | _boolean_ `"and"` _boolean_ -> _boolean_
-| [blue]`&&` | _Infix_ | _and_ | _boolean_ `"&&"` _boolean_ -> _boolean_
-.2+|*OR*| [blue]`or` | _Infix_ | _or_ | _boolean_ `"or"` _boolean_ -> _boolean_
-| [blue]`\|\|` | _Infix_ | _or_ | _boolean_ `"\|\|"` _boolean_ -> _boolean_
-.3+|*ASSIGN*| [blue]`=` | _Infix_ | _assignment_ | _identifier_ "=" _any_ -> _any_
-| [blue]`>>` | _Infix_ | _front-insert_ | _any_ ">>" _list_ -> _list_
-| [blue]`<<` | _Infix_ | _back-insert_ | _list_ "<<" _any_ -> _list_
- .1+|*BUT*| [blue]`but` | _Infix_ | _but_ | _any_ "but" _any_ -> _any_
 |===
 
 == Functions
-Functions in _Expr_ are very similar to functions available in many programming languages. Actually, _Expr_ supports two types of function, _expr-functions_ and _go-functions_.
+Functions in _Expr_ are very similar to functions in many programming languages.
-
-* _expr-functions_ are defined using _Expr_'s syntax. They can be passed as arguments to other functions and can be returned from functions. Moreover, they bind themselves to the defining context, thus becoming closures.
-* _go-functions_ are regular Golang functions callable from _Expr_ expressions. They are defined in Golang source files called _modules_ and compiled within the _Expr_ package. To make Golang functions available in _Expr_ contextes, it is required to _import_ the module in which they are defined.
 
 In _Expr_ functions compute values in a local context (scope) that do not make effects on the calling context. This is the normal behavior. Using the reference operator [blue]`@` it is possibile to export local definition to the calling context.
 

expr_test.go

@@ -0,0 +1,72 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// expr_test.go
+package expr
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestExpr(t *testing.T) {
+	type inputType struct {
+		source     string
+		wantResult any
+		wantErr    error
+	}
+
+	inputs := []inputType{
+		/*   1 */ {`fact=func(n){(n)?{1}::{n*fact(n-1)}}; fact(5)`, int64(120), nil},
+	}
+
+	succeeded := 0
+	failed := 0
+
+	inputs1 := []inputType{
+		{`f=openFile("/tmp/test2.txt"); line=readFile(f); closeFile(f); line`, "ciao", nil},
+		//{`f = func(op){op()}; f(func(){2})`, int64(2), nil},
+	}
+
+	for i, input := range inputs1 {
+		var expr Expr
+		var gotResult any
+		var gotErr error
+
+		ctx := NewSimpleFuncStore()
+		// ImportMathFuncs(ctx)
+		// ImportImportFunc(ctx)
+		ImportOsFuncs(ctx)
+		parser := NewParser(ctx)
+
+		logTest(t, i+1, input.source, input.wantResult, input.wantErr)
+
+		r := strings.NewReader(input.source)
+		scanner := NewScanner(r, DefaultTranslations())
+
+		good := true
+		if expr, gotErr = parser.Parse(scanner); gotErr == nil {
+			gotResult, gotErr = expr.Eval(ctx)
+		}
+
+		if gotResult != input.wantResult {
+			t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
+			good = false
+		}
+
+		if gotErr != input.wantErr {
+			if input.wantErr == nil || gotErr == nil || (gotErr.Error() != input.wantErr.Error()) {
+				t.Errorf("%d: %q -> err = <%v>, want <%v>", i+1, input.source, gotErr, input.wantErr)
+				good = false
+			}
+		}
+
+		if good {
+			succeeded++
+		} else {
+			failed++
+		}
+	}
+	t.Log(fmt.Sprintf("test count: %d, succeeded count: %d, failed count: %d", len(inputs), succeeded, failed))
+}

file-reader.expr

@@ -1,33 +0,0 @@
-builtin ["os.file", "base"];
-
-readInt=func(fh){
-	line=readFile(fh);
-	line ? [nil] {nil} :: {int(line)}
-};
-
-ds={
-	"init":func(filename){
-		fh=openFile(filename);
-		fh ? [nil] {nil} :: { @current=readInt(fh); @prev=@current };
-		fh
-	},
-	"current":func(){
-		prev
-	},
-	"next":func(fh){
-		current ? 
-			[nil] {current}
-			:: {@prev=current; @current=readInt(fh) but current}
-	},
-	"clean":func(fh){
-		closeFile(fh)
-	}
-}
-
-//;f=$(ds, "int.list")
-/*
-;f++
-;f++
-;f++
-*/
-//;add(f)

formatter.go

@@ -1,67 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// formatter.go
-package expr
-
-import "fmt"
-
-type FmtOpt uint16
-
-const (
-	TTY FmtOpt = 1 << iota
-	MultiLine
-	Truncate
-	Base2
-	Base8
-	Base10
-	Base16
-)
-
-const (
-	TruncateEllipsis = "(...)"
-	MinTruncateSize  = 10
-	TruncateSize     = MinTruncateSize + 15
-)
-
-func TruncateString(s string) (trunc string) {
-	finalPart := len(s) - (MinTruncateSize - len(TruncateEllipsis))
-	trunc = s[0:len(s)-MinTruncateSize] + TruncateEllipsis + s[finalPart:]
-	return
-}
-
-type Formatter interface {
-	ToString(options FmtOpt) string
-}
-
-func getFormatted(v any, opt FmtOpt) (text string) {
-	if v == nil {
-		text = "(nil)"
-	} else if s, ok := v.(string); ok {
-		text = s
-	} else if formatter, ok := v.(Formatter); ok {
-		text = formatter.ToString(opt)
-	} else {
-		text = fmt.Sprintf("%v", v)
-	}
-	return
-}
-
-type Typer interface {
-	TypeName() string
-}
-
-func typeName(v any) (name string) {
-	if v == nil {
-		name = "nil"
-	} else if typer, ok := v.(Typer); ok {
-		name = typer.TypeName()
-	} else if IsInteger(v) {
-		name = "integer"
-	} else if IsFloat(v) {
-		name = "float"
-	} else {
-		name = fmt.Sprintf("%T", v)
-	}
-	return
-}

fraction-type.go

@@ -1,359 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// fraction-type.go
-package expr
-
-//https://www.youmath.it/lezioni/algebra-elementare/lezioni-di-algebra-e-aritmetica-per-scuole-medie/553-dalle-frazioni-a-numeri-decimali.html
-
-import (
-	"errors"
-	"fmt"
-	"math"
-	"strconv"
-	"strings"
-)
-
-type FractionType struct {
-	num, den int64
-}
-
-func newFraction(num, den int64) *FractionType {
-	num, den = simplifyIntegers(num, den)
-	return &FractionType{num, den}
-}
-
-func float64ToFraction(f float64) (fract *FractionType, err error) {
-	var sign string
-	intPart, decPart := math.Modf(f)
-	if decPart < 0.0 {
-		sign = "-"
-		intPart = -intPart
-		decPart = -decPart
-	}
-	dec := fmt.Sprintf("%.12f", decPart)
-	s := fmt.Sprintf("%s%.f%s", sign, intPart, dec[1:])
-	return makeGeneratingFraction(s)
-}
-
-// Based on https://cs.opensource.google/go/go/+/refs/tags/go1.22.3:src/math/big/rat.go;l=39
-func makeGeneratingFraction(s string) (f *FractionType, err error) {
-	var num, den int64
-	var sign int64 = 1
-	var parts []string
-	if len(s) == 0 {
-		goto exit
-	}
-	if s[0] == '-' {
-		sign = int64(-1)
-		s = s[1:]
-	} else if s[0] == '+' {
-		s = s[1:]
-	}
-	if strings.HasSuffix(s, "()") {
-		s = s[0 : len(s)-2]
-	}
-	parts = strings.SplitN(s, ".", 2)
-	if num, err = strconv.ParseInt(parts[0], 10, 64); err != nil {
-		return
-	}
-	if len(parts) == 1 {
-		f = newFraction(sign*num, 1)
-	} else if len(parts) == 2 {
-		subParts := strings.SplitN(parts[1], "(", 2)
-		if len(subParts) == 1 {
-			den = 1
-			dec := parts[1]
-			lsd := len(dec)
-			for i := lsd - 1; i >= 0 && dec[i] == '0'; i-- {
-				lsd--
-			}
-			for _, c := range dec[0:lsd] {
-				if c < '0' || c > '9' {
-					return nil, errExpectedGot("fract", "digit", c)
-				}
-				num = num*10 + int64(c-'0')
-				den = den * 10
-			}
-			f = newFraction(sign*num, den)
-		} else if len(subParts) == 2 {
-			sub := num
-			mul := int64(1)
-			for _, c := range subParts[0] {
-				if c < '0' || c > '9' {
-					return nil, errExpectedGot("fract", "digit", c)
-				}
-				num = num*10 + int64(c-'0')
-				sub = sub*10 + int64(c-'0')
-				mul *= 10
-			}
-			if len(subParts) == 2 {
-				if s[len(s)-1] != ')' {
-					goto exit
-				}
-				p := subParts[1][0 : len(subParts[1])-1]
-				for _, c := range p {
-					if c < '0' || c > '9' {
-						return nil, errExpectedGot("fract", "digit", c)
-					}
-					num = num*10 + int64(c-'0')
-					den = den*10 + 9
-				}
-				den *= mul
-			}
-			num -= sub
-			f = newFraction(sign*num, den)
-		}
-	}
-exit:
-	if f == nil {
-		err = errors.New("bad syntax")
-	}
-	return
-}
-
-func (f *FractionType) toFloat() float64 {
-	return float64(f.num) / float64(f.den)
-}
-
-func (f *FractionType) String() string {
-	return f.ToString(0)
-}
-
-func (f *FractionType) ToString(opt FmtOpt) string {
-	var sb strings.Builder
-	if opt&MultiLine == 0 {
-		sb.WriteString(fmt.Sprintf("%d|%d", f.num, f.den))
-	} else {
-		var s, num string
-		if f.num < 0 && opt&TTY == 0 {
-			num = strconv.FormatInt(-f.num, 10)
-			s = "-"
-		} else {
-			num = strconv.FormatInt(f.num, 10)
-		}
-		den := strconv.FormatInt(f.den, 10)
-		size := max(len(num), len(den))
-		if opt&TTY != 0 {
-			sb.WriteString(fmt.Sprintf("\x1b[4m%[1]*s\x1b[0m\n", -size, fmt.Sprintf("%[1]*s", (size+len(num))/2, s+num)))
-		} else {
-			if len(s) > 0 {
-				sb.WriteString("  ")
-			}
-			sb.WriteString(fmt.Sprintf("%[1]*s", -size, fmt.Sprintf("%[1]*s", (size+len(num))/2, num)))
-			sb.WriteByte('\n')
-			if len(s) > 0 {
-				sb.WriteString(s)
-				sb.WriteByte(' ')
-			}
-			sb.WriteString(strings.Repeat("-", size))
-			sb.WriteByte('\n')
-			if len(s) > 0 {
-				sb.WriteString("  ")
-			}
-		}
-		sb.WriteString(fmt.Sprintf("%[1]*s", -size, fmt.Sprintf("%[1]*s", (size+len(den))/2, den)))
-	}
-
-	return sb.String()
-}
-
-func (f *FractionType) TypeName() string {
-	return "fraction"
-}
-
-// -------- fraction utility functions
-
-// greatest common divider
-func gcd(a, b int64) (g int64) {
-	if a < 0 {
-		a = -a
-	}
-	if b < 0 {
-		b = -b
-	}
-	if a < b {
-		a, b = b, a
-	}
-	r := a % b
-	for r > 0 {
-		a, b = b, r
-		r = a % b
-	}
-	g = b
-	return
-}
-
-// lower common multiple
-func lcm(a, b int64) (l int64) {
-	g := gcd(a, b)
-	l = a * b / g
-	return
-}
-
-// Sum two fractions
-func sumFract(f1, f2 *FractionType) (sum *FractionType) {
-	m := lcm(f1.den, f2.den)
-	sum = newFraction(f1.num*(m/f1.den)+f2.num*(m/f2.den), m)
-	return
-}
-
-// Multiply two fractions
-func mulFract(f1, f2 *FractionType) (prod *FractionType) {
-	prod = newFraction(f1.num*f2.num, f1.den*f2.den)
-	return
-}
-
-func anyToFract(v any) (f *FractionType, err error) {
-	var ok bool
-	if f, ok = v.(*FractionType); !ok {
-		if n, ok := v.(int64); ok {
-			f = intToFraction(n)
-		}
-	}
-	if f == nil {
-		err = errExpectedGot("fract", typeFraction, v)
-	}
-	return
-}
-
-func anyPairToFract(v1, v2 any) (f1, f2 *FractionType, err error) {
-	if f1, err = anyToFract(v1); err != nil {
-		return
-	}
-	if f2, err = anyToFract(v2); err != nil {
-		return
-	}
-	return
-}
-
-func sumAnyFract(af1, af2 any) (sum any, err error) {
-	var f1, f2 *FractionType
-	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
-		return
-	}
-	f := sumFract(f1, f2)
-	if f.num == 0 {
-		sum = 0
-	} else {
-		sum = simplifyFraction(f)
-	}
-	return
-}
-
-// Returns
-//
-//		 <0 if af1 < af2
-//		 =0 if af1 == af2
-//		 >0 if af1 > af2
-//	 err if af1 or af2 is not convertible to fraction
-func cmpAnyFract(af1, af2 any) (result int, err error) {
-	var f1, f2 *FractionType
-	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
-		return
-	}
-	result = cmpFract(f1, f2)
-	return
-}
-
-// Returns
-//
-//	<0 if af1 < af2
-//	=0 if af1 == af2
-//	>0 if af1 > af2
-func cmpFract(f1, f2 *FractionType) (result int) {
-	f2.num = -f2.num
-	f := sumFract(f1, f2)
-	if f.num < 0 {
-		result = -1
-	} else if f.num > 0 {
-		result = 1
-	} else {
-		result = 0
-	}
-	return
-}
-
-func subAnyFract(af1, af2 any) (sum any, err error) {
-	var f1, f2 *FractionType
-	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
-		return
-	}
-	f2.num = -f2.num
-	f := sumFract(f1, f2)
-	if f.num == 0 {
-		sum = 0
-	} else {
-		sum = simplifyFraction(f)
-	}
-	return
-}
-
-func mulAnyFract(af1, af2 any) (prod any, err error) {
-	var f1, f2 *FractionType
-	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
-		return
-	}
-	if f1.num == 0 || f2.num == 0 {
-		prod = 0
-	} else {
-		f := &FractionType{f1.num * f2.num, f1.den * f2.den}
-		prod = simplifyFraction(f)
-	}
-	return
-}
-
-func divAnyFract(af1, af2 any) (quot any, err error) {
-	var f1, f2 *FractionType
-	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
-		return
-	}
-	if f2.num == 0 {
-		err = errors.New("division by zero")
-		return
-		return
-	}
-	if f1.num == 0 || f2.den == 0 {
-		quot = 0
-	} else {
-		f := &FractionType{f1.num * f2.den, f1.den * f2.num}
-		quot = simplifyFraction(f)
-	}
-	return
-}
-
-func simplifyFraction(f *FractionType) (v any) {
-	f.num, f.den = simplifyIntegers(f.num, f.den)
-	if f.den == 1 {
-		v = f.num
-	} else {
-		v = &FractionType{f.num, f.den}
-	}
-	return v
-}
-
-func simplifyIntegers(num, den int64) (a, b int64) {
-	if num == 0 {
-		return 0, 1
-	}
-	if den == 0 {
-		panic("fraction with denominator == 0")
-	}
-	if den < 0 {
-		den = -den
-		num = -num
-	}
-	g := gcd(num, den)
-	a = num / g
-	b = den / g
-	return
-}
-
-func intToFraction(n int64) *FractionType {
-	return &FractionType{n, 1}
-}
-
-func isFraction(v any) (ok bool) {
-	_, ok = v.(*FractionType)
-	return ok
-}

func-base.go

@@ -1,186 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// func-builtins.go
-package expr
-
-import (
-	"math"
-	"strconv"
-)
-
-func isNilFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	result = args[0] == nil
-	return
-}
-
-func isIntFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	result = IsInteger(args[0])
-	return
-}
-
-func isFloatFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	result = IsFloat(args[0])
-	return
-}
-
-func isBoolFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	result = IsBool(args[0])
-	return
-}
-
-func isStringFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	result = IsString(args[0])
-	return
-}
-
-func isFractionFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	result = IsFract(args[0])
-	return
-}
-
-func isRationalFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	result = IsRational(args[0])
-	return
-}
-
-func isListFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	result = IsList(args[0])
-	return
-}
-
-func isDictionaryFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	result = IsDict(args[0])
-	return
-}
-
-func boolFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	switch v := args[0].(type) {
-	case int64:
-		result = (v != 0)
-	case *FractionType:
-		result = v.num != 0
-	case float64:
-		result = v != 0.0
-	case bool:
-		result = v
-	case string:
-		result = len(v) > 0
-	default:
-		err = errCantConvert(name, v, "bool")
-	}
-	return
-}
-
-func intFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	switch v := args[0].(type) {
-	case int64:
-		result = v
-	case float64:
-		result = int64(math.Trunc(v))
-	case bool:
-		if v {
-			result = int64(1)
-		} else {
-			result = int64(0)
-		}
-	case string:
-		var i int
-		if i, err = strconv.Atoi(v); err == nil {
-			result = int64(i)
-		}
-	default:
-		err = errCantConvert(name, v, "int")
-	}
-	return
-}
-
-func decFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	switch v := args[0].(type) {
-	case int64:
-		result = float64(v)
-	case float64:
-		result = v
-	case bool:
-		if v {
-			result = float64(1)
-		} else {
-			result = float64(0)
-		}
-	case string:
-		var f float64
-		if f, err = strconv.ParseFloat(v, 64); err == nil {
-			result = f
-		}
-	case *FractionType:
-		result = v.toFloat()
-	default:
-		err = errCantConvert(name, v, "float")
-	}
-	return
-}
-
-func fractFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	switch v := args[0].(type) {
-	case int64:
-		var den int64 = 1
-		if len(args) > 1 {
-			var ok bool
-			if den, ok = args[1].(int64); !ok {
-				err = errExpectedGot(name, "integer", args[1])
-			} else if den == 0 {
-				err = errFuncDivisionByZero(name)
-			}
-		}
-		if err == nil {
-			result = newFraction(v, den)
-		}
-	case float64:
-		result, err = float64ToFraction(v)
-	case bool:
-		if v {
-			result = newFraction(1, 1)
-		} else {
-			result = newFraction(0, 1)
-		}
-	case string:
-		result, err = makeGeneratingFraction(v)
-	case *FractionType:
-		result = v
-	default:
-		err = errCantConvert(name, v, "float")
-	}
-	return
-}
-
-func iteratorFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	return
-}
-
-func ImportBuiltinsFuncs(ctx ExprContext) {
-	anyParams := []ExprFuncParam{
-		newFuncParam(paramValue),
-	}
-
-	ctx.RegisterFunc("isNil", newGolangFunctor(isNilFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isInt", newGolangFunctor(isIntFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isFloat", newGolangFunctor(isFloatFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isBool", newGolangFunctor(isBoolFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isString", newGolangFunctor(isStringFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isFract", newGolangFunctor(isFractionFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isRational", newGolangFunctor(isRationalFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isList", newGolangFunctor(isListFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isDict", newGolangFunctor(isDictionaryFunc), typeBoolean, anyParams)
-
-	ctx.RegisterFunc("bool", newGolangFunctor(boolFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("int", newGolangFunctor(intFunc), typeInt, anyParams)
-	ctx.RegisterFunc("dec", newGolangFunctor(decFunc), typeFloat, anyParams)
-	ctx.RegisterFunc("fract", newGolangFunctor(fractFunc), typeFraction, []ExprFuncParam{
-		newFuncParam(paramValue),
-		newFuncParamFlagDef("denominator", pfOptional, 1),
-	})
-}
-
-func init() {
-	registerImport("base", ImportBuiltinsFuncs, "Base expression tools like isNil(), int(), etc.")
-}

func-fmt.go

@@ -1,36 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// func-fmt.go
-package expr
-
-import "fmt"
-
-func printFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	var n int
-	if n, err = fmt.Print(args...); err == nil {
-		result = int64(n)
-	}
-	return
-}
-
-func printLnFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	var n int
-	if n, err = fmt.Println(args...); err == nil {
-		result = int64(n)
-	}
-	return
-}
-
-func ImportFmtFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("print", newGolangFunctor(printFunc), typeInt, []ExprFuncParam{
-		newFuncParamFlag(paramItem, pfRepeat),
-	})
-	ctx.RegisterFunc("println", newGolangFunctor(printLnFunc), typeInt, []ExprFuncParam{
-		newFuncParamFlag(paramItem, pfRepeat),
-	})
-}
-
-func init() {
-	registerImport("fmt", ImportFmtFuncs, "String and console formatting functions")
-}

func-import.go

@@ -20,7 +20,7 @@ func importFunc(ctx ExprContext, name string, args []any) (result any, err error
 	return importGeneral(ctx, name, args)
 }
 
-func importAllFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func includeFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	enable(ctx, control_export_all)
 	return importGeneral(ctx, name, args)
 }
@@ -30,12 +30,12 @@ func importGeneral(ctx ExprContext, name string, args []any) (result any, err er
 
 	dirList = addEnvImportDirs(dirList)
 	dirList = addPresetImportDirs(ctx, dirList)
-	result, err = doImport(ctx, name, dirList, NewArrayIterator(args))
+	result, err = doImport(ctx, name, dirList, NewFlatArrayIterator(args))
 	return
 }
 
 func checkStringParamExpected(funcName string, paramValue any, paramPos int) (err error) {
-	if !(IsString(paramValue) /*|| isList(paramValue)*/) {
+	if !(isString(paramValue) /*|| isList(paramValue)*/) {
 		err = fmt.Errorf("%s(): param nr %d has wrong type %T, string expected", funcName, paramPos+1, paramValue)
 	}
 	return
@@ -137,14 +137,6 @@ func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (resu
 }
 
 func ImportImportFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("import", newGolangFunctor(importFunc), typeAny, []ExprFuncParam{
+	ctx.RegisterFunc("import", &simpleFunctor{f: importFunc}, 1, -1)
-		newFuncParamFlag(paramFilepath, pfRepeat),
+	ctx.RegisterFunc("include", &simpleFunctor{f: includeFunc}, 1, -1)
-	})
-	ctx.RegisterFunc("importAll", newGolangFunctor(importAllFunc), typeAny, []ExprFuncParam{
-		newFuncParamFlag(paramFilepath, pfRepeat),
-	})
-}
-
-func init() {
-	registerImport("import", ImportImportFuncs, "Functions import() and include()")
 }

func-math.go

@@ -9,65 +9,36 @@ import (
 	"io"
 )
 
-func checkNumberParamExpected(funcName string, paramValue any, paramPos, level, subPos int) (err error) {
+func checkNumberParamExpected(funcName string, paramValue any, paramPos int) (err error) {
-	if !(IsNumber(paramValue) || isFraction(paramValue)) /*|| isList(paramValue)*/ {
+	if !(isNumber(paramValue) || isList(paramValue)) {
-		err = fmt.Errorf("%s(): param nr %d (%d in %d) has wrong type %T, number expected",
+		err = fmt.Errorf("%s(): param nr %d has wrong type %T, number expected", funcName, paramPos+1, paramValue)
-			funcName, paramPos+1, subPos+1, level, paramValue)
 	}
 	return
 }
 
-func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result any, err error) {
+func doAdd(ctx ExprContext, name string, it Iterator) (result any, err error) {
-	var sumAsFloat, sumAsFract bool
+	var sumAsFloat = false
 	var floatSum float64 = 0.0
 	var intSum int64 = 0
-	var fractSum *FractionType
 	var v any
 
-	level++
-
 	for v, err = it.Next(); err == nil; v, err = it.Next() {
-		if list, ok := v.(*ListType); ok {
+		if err = checkNumberParamExpected(name, v, it.Index()); err != nil {
-			v = NewListIterator(list, nil)
-		}
-		if subIter, ok := v.(Iterator); ok {
-			if v, err = doAdd(ctx, name, subIter, count, level); err != nil {
-				break
-			}
-			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(cleanName) {
-				if _, err = extIter.CallOperation(cleanName, nil); err != nil {
-					return
-				}
-			}
-		} else if err = checkNumberParamExpected(name, v, count, level, it.Index()); err != nil {
 			break
 		}
-		count++
 
-		if !sumAsFloat {
+		if array, ok := v.([]any); ok {
-			if IsFloat(v) {
+			if v, err = doAdd(ctx, name, NewFlatArrayIterator(array)); err != nil {
-				sumAsFloat = true
+				break
-				if sumAsFract {
-					floatSum = fractSum.toFloat()
-				} else {
-					floatSum = float64(intSum)
-				}
-			} else if !sumAsFract && isFraction(v) {
-				fractSum = newFraction(intSum, 1)
-				sumAsFract = true
 			}
 		}
 
+		if !sumAsFloat && isFloat(v) {
+			sumAsFloat = true
+			floatSum = float64(intSum)
+		}
 		if sumAsFloat {
 			floatSum += numAsFloat(v)
-		} else if sumAsFract {
-			var item *FractionType
-			var ok bool
-			if item, ok = v.(*FractionType); !ok {
-				iv, _ := v.(int64)
-				item = newFraction(iv, 1)
-			}
-			fractSum = sumFract(fractSum, item)
 		} else {
 			iv, _ := v.(int64)
 			intSum += iv
@@ -77,8 +48,6 @@ func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result
 		err = nil
 		if sumAsFloat {
 			result = floatSum
-		} else if sumAsFract {
-			result = fractSum
 		} else {
 			result = intSum
 		}
@@ -87,62 +56,33 @@ func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result
 }
 
 func addFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	result, err = doAdd(ctx, name, NewArrayIterator(args), 0, -1)
+	result, err = doAdd(ctx, name, NewFlatArrayIterator(args))
 	return
 }
 
-func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result any, err error) {
+func doMul(ctx ExprContext, name string, it Iterator) (result any, err error) {
-	var mulAsFloat, mulAsFract bool
+	var mulAsFloat = false
 	var floatProd float64 = 1.0
 	var intProd int64 = 1
-	var fractProd *FractionType
 	var v any
 
-	level++
 	for v, err = it.Next(); err == nil; v, err = it.Next() {
-		if list, ok := v.(*ListType); ok {
+		if err = checkNumberParamExpected(name, v, it.Index()); err != nil {
-			v = NewListIterator(list, nil)
+			break
 		}
-		if subIter, ok := v.(Iterator); ok {
+
-			if v, err = doMul(ctx, name, subIter, count, level); err != nil {
+		if array, ok := v.([]any); ok {
-				break
+			if v, err = doAdd(ctx, name, NewFlatArrayIterator(array)); err != nil {
-			}
-			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(cleanName) {
-				if _, err = extIter.CallOperation(cleanName, nil); err != nil {
-					return
-				}
-			}
-		} else {
-			if err = checkNumberParamExpected(name, v, count, level, it.Index()); err != nil {
 				break
 			}
 		}
-		count++
 
-		if !mulAsFloat {
+		if !mulAsFloat && isFloat(v) {
-			if IsFloat(v) {
+			mulAsFloat = true
-				mulAsFloat = true
+			floatProd = float64(intProd)
-				if mulAsFract {
-					floatProd = fractProd.toFloat()
-				} else {
-					floatProd = float64(intProd)
-				}
-			} else if !mulAsFract && isFraction(v) {
-				fractProd = newFraction(intProd, 1)
-				mulAsFract = true
-			}
 		}
-
 		if mulAsFloat {
 			floatProd *= numAsFloat(v)
-		} else if mulAsFract {
-			var item *FractionType
-			var ok bool
-			if item, ok = v.(*FractionType); !ok {
-				iv, _ := v.(int64)
-				item = newFraction(iv, 1)
-			}
-			fractProd = mulFract(fractProd, item)
 		} else {
 			iv, _ := v.(int64)
 			intProd *= iv
@@ -152,8 +92,6 @@ func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result
 		err = nil
 		if mulAsFloat {
 			result = floatProd
-		} else if mulAsFract {
-			result = fractProd
 		} else {
 			result = intProd
 		}
@@ -162,20 +100,15 @@ func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result
 }
 
 func mulFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	result, err = doMul(ctx, name, NewArrayIterator(args), 0, -1)
+	result, err = doMul(ctx, name, NewFlatArrayIterator(args))
 	return
 }
 
 func ImportMathFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("add", &golangFunctor{f: addFunc}, typeNumber, []ExprFuncParam{
+	ctx.RegisterFunc("add", &simpleFunctor{f: addFunc}, 0, -1)
-		newFuncParamFlagDef(paramValue, pfOptional|pfRepeat, int64(0)),
+	ctx.RegisterFunc("mul", &simpleFunctor{f: mulFunc}, 0, -1)
-	})
-
-	ctx.RegisterFunc("mul", &golangFunctor{f: mulFunc}, typeNumber, []ExprFuncParam{
-		newFuncParamFlagDef(paramValue, pfOptional|pfRepeat, int64(1)),
-	})
 }
 
 func init() {
-	registerImport("math.arith", ImportMathFuncs, "Functions add() and mul()")
+	registerImport("math.arith", ImportMathFuncs)
 }

func-os.go

@@ -20,14 +20,6 @@ type osWriter struct {
 	writer *bufio.Writer
 }
 
-func (h *osWriter) TypeName() string {
-	return "osWriter"
-}
-
-func (h *osWriter) String() string {
-	return "writer"
-}
-
 func (h *osWriter) getFile() *os.File {
 	return h.fh
 }
@@ -37,73 +29,66 @@ type osReader struct {
 	reader *bufio.Reader
 }
 
-func (h *osReader) TypeName() string {
-	return "osReader"
-}
-
-func (h *osReader) String() string {
-	return "reader"
-}
-
 func (h *osReader) getFile() *os.File {
 	return h.fh
 }
 
-func errMissingFilePath(funcName string) error {
-	return fmt.Errorf("%s(): missing or invalid file path", funcName)
-}
-
-func errInvalidFileHandle(funcName string, v any) error {
-	if v != nil {
-		return fmt.Errorf("%s(): invalid file handle %v [%T]", funcName, v, v)
-	} else {
-		return fmt.Errorf("%s(): invalid file handle", funcName)
-	}
-}
-
 func createFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	if filePath, ok := args[0].(string); ok && len(filePath) > 0 {
+	var filePath string
+	if len(args) > 0 {
+		filePath, _ = args[0].(string)
+	}
+
+	if len(filePath) > 0 {
 		var fh *os.File
 		if fh, err = os.Create(filePath); err == nil {
 			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
 		}
 	} else {
-		err = errMissingFilePath("createFile")
+		err = fmt.Errorf("%s(): missing the file path", name)
 	}
 	return
 }
 
 func openFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	if filePath, ok := args[0].(string); ok && len(filePath) > 0 {
+	var filePath string
+	if len(args) > 0 {
+		filePath, _ = args[0].(string)
+	}
+
+	if len(filePath) > 0 {
 		var fh *os.File
 		if fh, err = os.Open(filePath); err == nil {
 			result = &osReader{fh: fh, reader: bufio.NewReader(fh)}
 		}
 	} else {
-		err = errMissingFilePath("openFile")
+		err = fmt.Errorf("%s(): missing the file path", name)
 	}
 	return
 }
 
 func appendFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	if filePath, ok := args[0].(string); ok && len(filePath) > 0 {
+	var filePath string
+	if len(args) > 0 {
+		filePath, _ = args[0].(string)
+	}
+
+	if len(filePath) > 0 {
 		var fh *os.File
 		if fh, err = os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0660); err == nil {
 			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
 		}
 	} else {
-		err = errMissingFilePath("openFile")
+		err = fmt.Errorf("%s(): missing the file path", name)
 	}
 	return
 }
 
 func closeFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	var handle osHandle
-	var invalidFileHandle any
-	var ok bool
 
-	if handle, ok = args[0].(osHandle); !ok {
+	if len(args) > 0 {
-		invalidFileHandle = args[0]
+		handle, _ = args[0].(osHandle)
 	}
 
 	if handle != nil {
@@ -111,14 +96,12 @@ func closeFileFunc(ctx ExprContext, name string, args []any) (result any, err er
 			if w, ok := handle.(*osWriter); ok {
 				err = w.writer.Flush()
 			}
-
 			if err == nil {
 				err = fh.Close()
 			}
 		}
-	}
+	} else {
-	if err == nil && (handle == nil || invalidFileHandle != nil) {
+		err = fmt.Errorf("%s(): invalid file handle", name)
-		err = errInvalidFileHandle("closeFileFunc", handle)
 	}
 	result = err == nil
 	return
@@ -126,89 +109,56 @@ func closeFileFunc(ctx ExprContext, name string, args []any) (result any, err er
 
 func writeFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	var handle osHandle
-	var invalidFileHandle any
-	var ok bool
 
-	if handle, ok = args[0].(osHandle); !ok {
+	if len(args) > 0 {
-		invalidFileHandle = args[0]
+		handle, _ = args[0].(osHandle)
 	}
 
 	if handle != nil {
-		if w, ok := handle.(*osWriter); ok {
+		if fh := handle.getFile(); fh != nil {
-			result, err = fmt.Fprint(w.writer, args[1:]...)
+			if w, ok := handle.(*osWriter); ok {
-		} else {
+				result, err = fmt.Fprint(w.writer, args[1:]...)
-			invalidFileHandle = handle
+			}
 		}
 	}
-
-	if err == nil && (handle == nil || invalidFileHandle != nil) {
-		err = errInvalidFileHandle("writeFileFunc", invalidFileHandle)
-	}
 	return
 }
 
 func readFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	var handle osHandle
-	var invalidFileHandle any
-	var ok bool
 
-	result = nil
+	if len(args) > 0 {
-	if handle, ok = args[0].(osHandle); !ok || args[0] == nil {
+		handle, _ = args[0].(osHandle)
-		invalidFileHandle = args[0]
 	}
 
 	if handle != nil {
-		if r, ok := handle.(*osReader); ok {
+		if fh := handle.getFile(); fh != nil {
-			var limit byte = '\n'
+			if r, ok := handle.(*osReader); ok {
-			var v string
+				var limit byte = '\n'
-			if s, ok := args[1].(string); ok && len(s) > 0 {
+				var v string
-				limit = s[0]
+				if len(args) > 1 {
-			}
+					if s, ok := args[1].(string); ok && len(s) > 0 {
-
+						limit = s[0]
-			if v, err = r.reader.ReadString(limit); err == nil {
+					}
-				if len(v) > 0 && v[len(v)-1] == limit {
+				}
-					result = v[0 : len(v)-1]
+				if v, err = r.reader.ReadString(limit); err == nil || err == io.EOF {
-				} else {
+					if len(v) > 0 && v[len(v)-1] == limit {
-					result = v
+						result = v[0 : len(v)-1]
+					} else {
+						result = v
+					}
 				}
 			}
-			if err == io.EOF {
-				err = nil
-			}
-		} else {
-			invalidFileHandle = handle
 		}
 	}
-
-	if err == nil && (handle == nil || invalidFileHandle != nil) {
-		err = errInvalidFileHandle("readFileFunc", invalidFileHandle)
-	}
 	return
 }
 
 func ImportOsFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("openFile", newGolangFunctor(openFileFunc), typeHandle, []ExprFuncParam{
+	ctx.RegisterFunc("openFile", &simpleFunctor{f: openFileFunc}, 1, 1)
-		newFuncParam(paramFilepath),
+	ctx.RegisterFunc("appendFile", &simpleFunctor{f: appendFileFunc}, 1, 1)
-	})
+	ctx.RegisterFunc("createFile", &simpleFunctor{f: createFileFunc}, 1, 1)
-	ctx.RegisterFunc("appendFile", newGolangFunctor(appendFileFunc), typeHandle, []ExprFuncParam{
+	ctx.RegisterFunc("writeFile", &simpleFunctor{f: writeFileFunc}, 1, -1)
-		newFuncParam(paramFilepath),
+	ctx.RegisterFunc("readFile", &simpleFunctor{f: readFileFunc}, 1, 2)
-	})
+	ctx.RegisterFunc("closeFile", &simpleFunctor{f: closeFileFunc}, 1, 1)
-	ctx.RegisterFunc("createFile", newGolangFunctor(createFileFunc), typeHandle, []ExprFuncParam{
-		newFuncParam(paramFilepath),
-	})
-	ctx.RegisterFunc("writeFile", newGolangFunctor(writeFileFunc), typeInt, []ExprFuncParam{
-		newFuncParam(typeHandle),
-		newFuncParamFlagDef(typeItem, pfOptional|pfRepeat, ""),
-	})
-	ctx.RegisterFunc("readFile", newGolangFunctor(readFileFunc), typeString, []ExprFuncParam{
-		newFuncParam(typeHandle),
-		newFuncParamFlagDef("limitCh", pfOptional, "\n"),
-	})
-	ctx.RegisterFunc("closeFile", newGolangFunctor(closeFileFunc), typeBoolean, []ExprFuncParam{
-		newFuncParam(typeHandle),
-	})
-}
-
-func init() {
-	registerImport("os.file", ImportOsFuncs, "Operating system file functions")
 }

func-string.go

@@ -1,223 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// func-string.go
-package expr
-
-import (
-	"fmt"
-	"io"
-	"strings"
-)
-
-// --- Start of function definitions
-func doJoinStr(funcName string, sep string, it Iterator) (result any, err error) {
-	var sb strings.Builder
-	var v any
-	for v, err = it.Next(); err == nil; v, err = it.Next() {
-		if it.Index() > 0 {
-			sb.WriteString(sep)
-		}
-		if s, ok := v.(string); ok {
-			sb.WriteString(s)
-		} else {
-			err = errExpectedGot(funcName, typeString, v)
-			return
-		}
-	}
-	if err == nil || err == io.EOF {
-		err = nil
-		result = sb.String()
-	}
-	return
-}
-
-func joinStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	//	if len(args) < 1 {
-	//		return nil, errMissingRequiredParameter(name, paramSeparator)
-	//	}
-	if sep, ok := args[0].(string); ok {
-		if len(args) == 1 {
-			result = ""
-		} else if len(args) == 2 {
-			if ls, ok := args[1].(*ListType); ok {
-				result, err = doJoinStr(name, sep, NewListIterator(ls, nil))
-			} else if it, ok := args[1].(Iterator); ok {
-				result, err = doJoinStr(name, sep, it)
-			} else {
-				err = errInvalidParameterValue(name, paramParts, args[1])
-			}
-		} else {
-			result, err = doJoinStr(name, sep, NewArrayIterator(args[1:]))
-		}
-	} else {
-		err = errWrongParamType(name, paramSeparator, typeString, args[0])
-	}
-	return
-}
-
-func subStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	var start = 0
-	var count = -1
-	var source string
-	var ok bool
-
-	if source, ok = args[0].(string); !ok {
-		return nil, errWrongParamType(name, paramSource, typeString, args[0])
-	}
-
-	if start, err = toInt(args[1], name+"()"); err != nil {
-		return
-	}
-
-	if count, err = toInt(args[2], name+"()"); err != nil {
-		return
-	}
-
-	if start < 0 {
-		start = len(source) + start
-	}
-
-	if count < 0 {
-		count = len(source) - start
-	}
-	end := min(start+count, len(source))
-	result = source[start:end]
-	return
-}
-
-func trimStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	var source string
-	var ok bool
-
-	if source, ok = args[0].(string); !ok {
-		return nil, errWrongParamType(name, paramSource, typeString, args[0])
-	}
-	result = strings.TrimSpace(source)
-	return
-}
-
-func startsWithStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	var source string
-	var ok bool
-
-	result = false
-
-	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, typeString, args[0])
-	}
-	for i, targetSpec := range args[1:] {
-		if target, ok := targetSpec.(string); ok {
-			if strings.HasPrefix(source, target) {
-				result = true
-				break
-			}
-		} else {
-			err = fmt.Errorf("target item nr %d is %T, expected string", i+1, targetSpec)
-			break
-		}
-	}
-	return
-}
-
-func endsWithStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	var source string
-	var ok bool
-
-	result = false
-
-	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, typeString, args[0])
-	}
-	for i, targetSpec := range args[1:] {
-		if target, ok := targetSpec.(string); ok {
-			if strings.HasSuffix(source, target) {
-				result = true
-				break
-			}
-		} else {
-			err = fmt.Errorf("target item nr %d is %T, expected string", i+1, targetSpec)
-			break
-		}
-	}
-	return
-}
-
-func splitStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	var source, sep string
-	var count int = -1
-	var parts []string
-	var ok bool
-
-	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, typeString, args[0])
-	}
-
-	if sep, ok = args[1].(string); !ok {
-		return nil, fmt.Errorf("separator param must be string, got %T (%v)", args[1], args[1])
-	}
-
-	if count64, ok := args[2].(int64); ok { // TODO replace type assertion with toInt()
-		count = int(count64)
-	} else {
-		return nil, fmt.Errorf("part count must be integer, got %T (%v)", args[2], args[2])
-	}
-
-	if count > 0 {
-		parts = strings.SplitN(source, sep, count)
-	} else if count < 0 {
-		parts = strings.Split(source, sep)
-	} else {
-		parts = []string{}
-	}
-	list := make(ListType, len(parts))
-	for i, part := range parts {
-		list[i] = part
-	}
-	result = &list
-	return
-}
-
-// --- End of function definitions
-
-// Import above functions in the context
-func ImportStringFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("joinStr", newGolangFunctor(joinStrFunc), typeString, []ExprFuncParam{
-		newFuncParam(paramSeparator),
-		newFuncParamFlag(paramItem, pfRepeat),
-	})
-
-	ctx.RegisterFunc("subStr", newGolangFunctor(subStrFunc), typeString, []ExprFuncParam{
-		newFuncParam(paramSource),
-		newFuncParamFlagDef(paramStart, pfOptional, int64(0)),
-		newFuncParamFlagDef(paramCount, pfOptional, int64(-1)),
-	})
-
-	ctx.RegisterFunc("splitStr", newGolangFunctor(splitStrFunc), "list of "+typeString, []ExprFuncParam{
-		newFuncParam(paramSource),
-		newFuncParamFlagDef(paramSeparator, pfOptional, ""),
-		newFuncParamFlagDef(paramCount, pfOptional, int64(-1)),
-	})
-
-	ctx.RegisterFunc("trimStr", newGolangFunctor(trimStrFunc), typeString, []ExprFuncParam{
-		newFuncParam(paramSource),
-	})
-
-	ctx.RegisterFunc("startsWithStr", newGolangFunctor(startsWithStrFunc), typeBoolean, []ExprFuncParam{
-		newFuncParam(paramSource),
-		newFuncParam(paramPrefix),
-		newFuncParamFlag("other "+paramPrefix, pfRepeat),
-	})
-
-	ctx.RegisterFunc("endsWithStr", newGolangFunctor(endsWithStrFunc), typeBoolean, []ExprFuncParam{
-		newFuncParam(paramSource),
-		newFuncParam(paramSuffix),
-		newFuncParamFlag("other "+paramSuffix, pfRepeat),
-	})
-}
-
-// Register the import function in the import-register.
-// That will allow to import all function of this module by the "builtin" operator."
-func init() {
-	registerImport("string", ImportStringFuncs, "string utilities")
-}

function-register.go

@@ -0,0 +1,47 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// function-register.go
+package expr
+
+import (
+	"path/filepath"
+)
+
+var functionRegister map[string]func(ExprContext)
+
+func registerImport(name string, importFunc func(ExprContext)) {
+	if functionRegister == nil {
+		functionRegister = make(map[string]func(ExprContext))
+	}
+	functionRegister[name] = importFunc
+}
+
+func ImportInContext(ctx ExprContext, name string) (exists bool) {
+	var importFunc func(ExprContext)
+	if importFunc, exists = functionRegister[name]; exists {
+		importFunc(ctx)
+	}
+	return
+}
+
+func ImportInContextByGlobPattern(ctx ExprContext, pattern string) (count int, err error) {
+	var matched bool
+	for name, importFunc := range functionRegister {
+		if matched, err = filepath.Match(pattern, name); err == nil {
+			if matched {
+				count++
+				importFunc(ctx)
+			}
+		} else {
+			break
+		}
+	}
+	return
+}
+
+func init() {
+	if functionRegister == nil {
+		functionRegister = make(map[string]func(ExprContext))
+	}
+}

function.go

@@ -1,249 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// function.go
-package expr
-
-import (
-	"fmt"
-	"strings"
-)
-
-// ---- Function template
-type FuncTemplate func(ctx ExprContext, name string, args []any) (result any, err error)
-
-// ---- Common functor definition
-type baseFunctor struct {
-	info ExprFunc
-}
-
-func (functor *baseFunctor) ToString(opt FmtOpt) (s string) {
-	if functor.info != nil {
-		s = functor.info.ToString(opt)
-	} else {
-		s = "func() {<body>}"
-	}
-	return s
-}
-
-func (functor *baseFunctor) GetParams() (params []ExprFuncParam) {
-	if functor.info != nil {
-		return functor.info.Params()
-	} else {
-		return []ExprFuncParam{}
-	}
-}
-
-func (functor *baseFunctor) SetFunc(info ExprFunc) {
-	functor.info = info
-}
-
-func (functor *baseFunctor) GetFunc() ExprFunc {
-	return functor.info
-}
-
-// ---- Linking with Go functions
-type golangFunctor struct {
-	baseFunctor
-	f FuncTemplate
-}
-
-func newGolangFunctor(f FuncTemplate) *golangFunctor {
-	return &golangFunctor{f: f}
-}
-
-func (functor *golangFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
-	return functor.f(ctx, name, args)
-}
-
-// ---- Linking with Expr functions
-type exprFunctor struct {
-	baseFunctor
-	params []ExprFuncParam
-	expr   Expr
-	defCtx ExprContext
-}
-
-// func newExprFunctor(e Expr, params []string, ctx ExprContext) *exprFunctor {
-// 	return &exprFunctor{expr: e, params: params, defCtx: ctx}
-// }
-
-func newExprFunctor(e Expr, params []ExprFuncParam, ctx ExprContext) *exprFunctor {
-	return &exprFunctor{expr: e, params: params, defCtx: ctx}
-}
-
-func (functor *exprFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
-	if functor.defCtx != nil {
-		ctx.Merge(functor.defCtx)
-	}
-
-	for i, p := range functor.params {
-		if i < len(args) {
-			arg := args[i]
-			if funcArg, ok := arg.(Functor); ok {
-				// ctx.RegisterFunc(p, functor, 0, -1)
-				paramSpecs := funcArg.GetParams()
-				ctx.RegisterFunc(p.Name(), funcArg, typeAny, paramSpecs)
-			} else {
-				ctx.UnsafeSetVar(p.Name(), arg)
-			}
-		} else {
-			ctx.UnsafeSetVar(p.Name(), nil)
-		}
-	}
-	result, err = functor.expr.eval(ctx, false)
-	return
-}
-
-// ---- Function Parameters
-type paramFlags uint16
-
-const (
-	pfOptional paramFlags = 1 << iota
-	pfRepeat
-)
-
-type funcParamInfo struct {
-	name         string
-	flags        paramFlags
-	defaultValue any
-}
-
-func newFuncParam(name string) ExprFuncParam {
-	return &funcParamInfo{name: name}
-}
-
-func newFuncParamFlag(name string, flags paramFlags) ExprFuncParam {
-	return &funcParamInfo{name: name, flags: flags}
-}
-
-func newFuncParamFlagDef(name string, flags paramFlags, defValue any) *funcParamInfo {
-	return &funcParamInfo{name: name, flags: flags, defaultValue: defValue}
-}
-
-func (param *funcParamInfo) Name() string {
-	return param.name
-}
-
-func (param *funcParamInfo) Type() string {
-	return "any"
-}
-
-func (param *funcParamInfo) IsOptional() bool {
-	return (param.flags & pfOptional) != 0
-}
-
-func (param *funcParamInfo) IsRepeat() bool {
-	return (param.flags & pfRepeat) != 0
-}
-
-func (param *funcParamInfo) DefaultValue() any {
-	return param.defaultValue
-}
-
-// --- Functions
-type funcInfo struct {
-	name       string
-	minArgs    int
-	maxArgs    int
-	functor    Functor
-	params     []ExprFuncParam
-	returnType string
-}
-
-func newFuncInfo(name string, functor Functor, returnType string, params []ExprFuncParam) (info *funcInfo, err error) {
-	var minArgs = 0
-	var maxArgs = 0
-	if params != nil {
-		for _, p := range params {
-			if maxArgs == -1 {
-				return nil, fmt.Errorf("no more params can be specified after the ellipsis symbol: %q", p.Name())
-			}
-			if p.IsOptional() {
-				maxArgs++
-			} else if maxArgs == minArgs {
-				minArgs++
-				maxArgs++
-			} else {
-				return nil, fmt.Errorf("can't specify non-optional param after optional ones: %q", p.Name())
-			}
-			if p.IsRepeat() {
-				minArgs--
-				maxArgs = -1
-			}
-		}
-	}
-	info = &funcInfo{
-		name: name, minArgs: minArgs, maxArgs: maxArgs, functor: functor, returnType: returnType, params: params,
-	}
-	functor.SetFunc(info)
-	return info, nil
-}
-
-func newUnnamedFuncInfo(functor Functor, returnType string, params []ExprFuncParam) (info *funcInfo, err error) {
-	return newFuncInfo("unnamed", functor, returnType, params)
-}
-
-func (info *funcInfo) Params() []ExprFuncParam {
-	return info.params
-}
-
-func (info *funcInfo) ReturnType() string {
-	return info.returnType
-}
-
-func (info *funcInfo) ToString(opt FmtOpt) string {
-	var sb strings.Builder
-	if len(info.Name()) == 0 {
-		sb.WriteString("func")
-	} else {
-		sb.WriteString(info.Name())
-	}
-	sb.WriteByte('(')
-	if info.params != nil {
-		for i, p := range info.params {
-			if i > 0 {
-				sb.WriteString(", ")
-			}
-			sb.WriteString(p.Name())
-
-			if p.IsOptional() {
-				sb.WriteByte('=')
-				if s, ok := p.DefaultValue().(string); ok {
-					sb.WriteByte('"')
-					sb.WriteString(s)
-					sb.WriteByte('"')
-				} else {
-					sb.WriteString(fmt.Sprintf("%v", p.DefaultValue()))
-				}
-			}
-		}
-	}
-	if info.maxArgs < 0 {
-		sb.WriteString(" ...")
-	}
-	sb.WriteString("):")
-	if len(info.returnType) > 0 {
-		sb.WriteString(info.returnType)
-	} else {
-		sb.WriteString(typeAny)
-	}
-	sb.WriteString(" {<body>}")
-	return sb.String()
-}
-
-func (info *funcInfo) Name() string {
-	return info.name
-}
-
-func (info *funcInfo) MinArgs() int {
-	return info.minArgs
-}
-
-func (info *funcInfo) MaxArgs() int {
-	return info.maxArgs
-}
-
-func (info *funcInfo) Functor() Functor {
-	return info.functor
-}

global-context.go

@@ -1,69 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// global-context.go
-package expr
-
-import "path/filepath"
-
-var globalCtx *SimpleStore
-
-func ImportInContext(name string) (exists bool) {
-	var mod *module
-	if mod, exists = moduleRegister[name]; exists {
-		mod.importFunc(globalCtx)
-		mod.imported = true
-	}
-	return
-}
-
-func ImportInContextByGlobPattern(pattern string) (count int, err error) {
-	var matched bool
-	for name, mod := range moduleRegister {
-		if matched, err = filepath.Match(pattern, name); err == nil {
-			if matched {
-				count++
-				mod.importFunc(globalCtx)
-				mod.imported = true
-			}
-		} else {
-			break
-		}
-	}
-	return
-}
-
-func GetVar(ctx ExprContext, name string) (value any, exists bool) {
-	if value, exists = ctx.GetVar(name); !exists {
-		value, exists = globalCtx.GetVar(name)
-	}
-	return
-}
-
-func GetLocalFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool) {
-	var v any
-	if len(name) > 0 {
-		if v, exists = ctx.GetVar(name); exists && isFunctor(v) {
-			f, _ := v.(Functor)
-			item = f.GetFunc()
-		} else {
-			item, exists = ctx.GetFuncInfo(name)
-		}
-	}
-	return
-}
-func GetFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool, ownerCtx ExprContext) {
-	if len(name) > 0 {
-		if item, exists = GetLocalFuncInfo(ctx, name); exists {
-			ownerCtx = ctx
-		} else if item, exists = globalCtx.GetFuncInfo(name); exists {
-			ownerCtx = globalCtx
-		}
-	}
-	return
-}
-
-func init() {
-	globalCtx = NewSimpleStore()
-	ImportBuiltinsFuncs(globalCtx)
-}

graph_test.go

@@ -1,7 +1,10 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// t_graph_test.go
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// graph_test.go
 package expr
 
 import (

helpers.go

@@ -6,8 +6,6 @@ package expr
 
 import (
 	"fmt"
-	"io"
-	"os"
 	"strings"
 )
 
@@ -34,15 +32,12 @@ func EvalStringA(source string, args ...Arg) (result any, err error) {
 }
 
 func EvalStringV(source string, args []Arg) (result any, err error) {
-	ctx := NewSimpleStore()
+	ctx := NewSimpleFuncStore()
 	for _, arg := range args {
 		if isFunc(arg.Value) {
 			if f, ok := arg.Value.(FuncTemplate); ok {
-				functor := newGolangFunctor(f)
+				functor := &simpleFunctor{f: f}
-				// ctx.RegisterFunc(arg.Name, functor, 0, -1)
+				ctx.RegisterFunc(arg.Name, functor, 0, -1)
-				ctx.RegisterFunc(arg.Name, functor, typeAny, []ExprFuncParam{
-					newFuncParamFlagDef(paramValue, pfOptional|pfRepeat, 0),
-				})
 			} else {
 				err = fmt.Errorf("invalid function specification: %q", arg.Name)
 			}
@@ -64,24 +59,3 @@ func EvalStringV(source string, args []Arg) (result any, err error) {
 	}
 	return
 }
-
-func EvalStream(ctx ExprContext, r io.Reader) (result any, err error) {
-	var tree *ast
-	scanner := NewScanner(r, DefaultTranslations())
-	parser := NewParser(ctx)
-
-	if tree, err = parser.Parse(scanner); err == nil {
-		result, err = tree.Eval(ctx)
-	}
-	return
-}
-
-func EvalFile(ctx ExprContext, filePath string) (result any, err error) {
-	var fh *os.File
-	if fh, err = os.Open(filePath); err != nil {
-		return nil, err
-	}
-	defer fh.Close()
-	result, err = EvalStream(ctx, fh)
-	return
-}

helpers_test.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// t_helpers_test.go
+// helpers_test.go
 package expr
 
 import (
@@ -52,7 +52,7 @@ func TestEvalStringA(t *testing.T) {
 
 func TestEvalString(t *testing.T) {
 
-	ctx := NewSimpleStore()
+	ctx := NewSimpleVarStore()
 	ctx.SetVar("a", uint8(1))
 	ctx.SetVar("b", int8(2))
 	ctx.SetVar("f", 2.0)

hook_test.txt

@@ -0,0 +1,3 @@
+First test
+next commit
+nr 3

int.list

@@ -1,4 +0,0 @@
-10
-20
-5
-12

iter-list.go

@@ -1,141 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// iter-list.go
-package expr
-
-import (
-	"fmt"
-	"io"
-)
-
-type ListIterator struct {
-	a     *ListType
-	count int
-	index int
-	start int
-	stop  int
-	step  int
-}
-
-func NewListIterator(list *ListType, args []any) (it *ListIterator) {
-	var argc int = 0
-	listLen := len(([]any)(*list))
-	if args != nil {
-		argc = len(args)
-	}
-	it = &ListIterator{a: list, count: 0, index: -1, start: 0, stop: listLen - 1, step: 1}
-	if argc >= 1 {
-		if i, err := toInt(args[0], "start index"); err == nil {
-			if i < 0 {
-				i = listLen + i
-			}
-			it.start = i
-		}
-		if argc >= 2 {
-			if i, err := toInt(args[1], "stop index"); err == nil {
-				if i < 0 {
-					i = listLen + i
-				}
-				it.stop = i
-			}
-			if argc >= 3 {
-				if i, err := toInt(args[2], "step"); err == nil {
-					if i < 0 {
-						i = -i
-					}
-					if it.start > it.stop {
-						it.step = -i
-					} else {
-						it.step = i
-					}
-				}
-			}
-		}
-	}
-	it.index = it.start - it.step
-	return
-}
-
-func NewArrayIterator(array []any) (it *ListIterator) {
-	it = &ListIterator{a: (*ListType)(&array), count: 0, index: -1, start: 0, stop: len(array) - 1, step: 1}
-	return
-}
-
-func NewAnyIterator(value any) (it *ListIterator) {
-	if value == nil {
-		it = NewArrayIterator([]any{})
-	} else if list, ok := value.(*ListType); ok {
-		it = NewListIterator(list, nil)
-	} else if array, ok := value.([]any); ok {
-		it = NewArrayIterator(array)
-	} else if it1, ok := value.(*ListIterator); ok {
-		it = it1
-	} else {
-		it = NewArrayIterator([]any{value})
-	}
-	return
-}
-
-func (it *ListIterator) String() string {
-	var l = 0
-	if it.a != nil {
-		l = len(*it.a)
-	}
-	return fmt.Sprintf("$(#%d)", l)
-}
-
-func (it *ListIterator) HasOperation(name string) bool {
-	yes := name == resetName || name == indexName || name == countName
-	return yes
-}
-
-func (it *ListIterator) CallOperation(name string, args []any) (v any, err error) {
-	switch name {
-	case resetName:
-		v, err = it.Reset()
-	case indexName:
-		v = int64(it.Index())
-	case countName:
-		v = it.count
-	default:
-		err = errNoOperation(name)
-	}
-	return
-}
-
-func (it *ListIterator) Current() (item any, err error) {
-	a := *(it.a)
-	if it.start <= it.stop {
-		if it.stop < len(a) && it.index >= it.start && it.index <= it.stop {
-			item = a[it.index]
-		} else {
-			err = io.EOF
-		}
-	} else {
-		if it.start < len(a) && it.index >= it.stop && it.index <= it.start {
-			item = a[it.index]
-		} else {
-			err = io.EOF
-		}
-
-	}
-	return
-}
-
-func (it *ListIterator) Next() (item any, err error) {
-	it.index += it.step
-	if item, err = it.Current(); err != io.EOF {
-		it.count++
-	}
-	return
-}
-
-func (it *ListIterator) Index() int {
-	return it.index
-}
-
-func (it *ListIterator) Reset() (bool, error) {
-	it.index = it.start
-	return true, nil
-}

iterator.expr

@@ -1,18 +0,0 @@
-ds={
-	"init":func(end){@end=end; @current=0; @prev=@current},
-	"current":func(){prev},
-	"next":func(){
-		(current <= end) ? [true] {@current=current+1; @prev=current} :: {nil}
-	},
-	"reset":func(){@current=0; @prev=@current}
-}
-
-// Example
-//;
-//it=$(ds,3);
-//it++;
-//it."reset"
-//it++;
-//it++;
-//add(it)
-

iterator.go

@@ -4,39 +4,37 @@
 // iterator.go
 package expr
 
-import (
+import "io"
-	"errors"
-	"fmt"
-)
-
-// Operator names
-
-const (
-	initName    = "init"
-	cleanName   = "clean"
-	resetName   = "reset"
-	nextName    = "next"
-	currentName = "current"
-	indexName   = "index"
-	countName   = "count"
-)
 
 type Iterator interface {
+	Reset()
 	Next() (item any, err error) // must return io.EOF after the last item
-	Current() (item any, err error)
 	Index() int
 }
 
-type ExtIterator interface {
+type FlatArrayIterator struct {
-	Iterator
+	a     []any
-	HasOperation(name string) bool
+	index int
-	CallOperation(name string, args []any) (value any, err error)
 }
 
-func errNoOperation(name string) error {
+func NewFlatArrayIterator(array []any) *FlatArrayIterator {
-	return fmt.Errorf("no %s() function defined in the data-source", name)
+	return &FlatArrayIterator{a: array, index: 0}
 }
 
-func errInvalidDataSource() error {
+func (it *FlatArrayIterator) Reset() {
-	return errors.New("invalid data-source")
+	it.index = 0
+}
+
+func (it *FlatArrayIterator) Next() (item any, err error) {
+	if it.index < len(it.a) {
+		item = it.a[it.index]
+		it.index++
+	} else {
+		err = io.EOF
+	}
+	return
+}
+
+func (it *FlatArrayIterator) Index() int {
+	return it.index - 1
 }

list-type.go

@@ -1,162 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// list-type.go
-package expr
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-)
-
-type ListType []any
-
-func newListA(listAny ...any) (list *ListType) {
-	if listAny == nil {
-		listAny = []any{}
-	}
-	return newList(listAny)
-}
-
-func newList(listAny []any) (list *ListType) {
-	if listAny != nil {
-		ls := make(ListType, len(listAny))
-		for i, item := range listAny {
-			ls[i] = item
-		}
-		list = &ls
-	}
-	return
-}
-
-func (ls *ListType) ToString(opt FmtOpt) (s string) {
-	var sb strings.Builder
-	sb.WriteByte('[')
-	if len(*ls) > 0 {
-		if opt&MultiLine != 0 {
-			sb.WriteString("\n  ")
-		}
-		for i, item := range []any(*ls) {
-			if i > 0 {
-				if opt&MultiLine != 0 {
-					sb.WriteString(",\n  ")
-				} else {
-					sb.WriteString(", ")
-				}
-			}
-			if s, ok := item.(string); ok {
-				sb.WriteByte('"')
-				sb.WriteString(s)
-				sb.WriteByte('"')
-			} else {
-				sb.WriteString(fmt.Sprintf("%v", item))
-			}
-		}
-		if opt&MultiLine != 0 {
-			sb.WriteByte('\n')
-		}
-	}
-	sb.WriteByte(']')
-	s = sb.String()
-	if opt&Truncate != 0 && len(s) > TruncateSize {
-		s = TruncateString(s)
-	}
-	return
-}
-
-func (ls *ListType) String() string {
-	return ls.ToString(0)
-}
-
-func (ls *ListType) TypeName() string {
-	return "list"
-}
-
-func (list *ListType) indexDeepCmp(target any) (index int) {
-	index = -1
-	for i, item := range *list {
-		if reflect.DeepEqual(item, target) {
-			index = i
-			break
-		}
-	}
-	return
-}
-
-func (ls *ListType) contains(t *ListType) (answer bool) {
-	if len(*ls) >= len(*t) {
-		answer = true
-		for _, item := range *t {
-			if answer = ls.indexDeepSameCmp(item) >= 0; !answer {
-				break
-			}
-		}
-	}
-	return
-}
-
-func (list *ListType) indexDeepSameCmp(target any) (index int) {
-	var eq bool
-	var err error
-	index = -1
-	for i, item := range *list {
-		if eq, err = deepSame(item, target, sameContent); err != nil {
-			break
-		} else if eq {
-			index = i
-			break
-		}
-	}
-	return
-}
-
-func sameContent(a, b any) (same bool, err error) {
-	la, _ := a.(*ListType)
-	lb, _ := b.(*ListType)
-	if len(*la) == len(*lb) {
-		same = true
-		for _, item := range *la {
-			if pos := lb.indexDeepSameCmp(item); pos < 0 {
-				same = false
-				break
-			}
-		}
-	}
-	return
-}
-
-func deepSame(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
-	if isNumOrFract(a) && isNumOrFract(b) {
-		if IsNumber(a) && IsNumber(b) {
-			if IsInteger(a) && IsInteger(b) {
-				li, _ := a.(int64)
-				ri, _ := b.(int64)
-				eq = li == ri
-			} else {
-				eq = numAsFloat(a) == numAsFloat(b)
-			}
-		} else {
-			var cmp int
-			if cmp, err = cmpAnyFract(a, b); err == nil {
-				eq = cmp == 0
-			}
-		}
-	} else if deepCmp != nil && IsList(a) && IsList(b) {
-		eq, err = deepCmp(a, b)
-	} else {
-		eq = reflect.DeepEqual(a, b)
-	}
-
-	return
-}
-
-func (list *ListType) setItem(index int64, value any) (err error) {
-	if index >= 0 && index < int64(len(*list)) {
-		(*list)[index] = value
-	} else {
-		err = fmt.Errorf("index %d out of bounds (0, %d)", index, len(*list)-1)
-	}
-	return
-}
-

module-register.go

@@ -1,48 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// module-register.go
-package expr
-
-import (
-	"fmt"
-)
-
-type module struct {
-	importFunc  func(ExprContext)
-	description string
-	imported    bool
-}
-
-func newModule(importFunc func(ExprContext), description string) *module {
-	return &module{importFunc, description, false}
-}
-
-var moduleRegister map[string]*module
-
-func registerImport(name string, importFunc func(ExprContext), description string) {
-	if moduleRegister == nil {
-		moduleRegister = make(map[string]*module)
-	}
-	if _, exists := moduleRegister[name]; exists {
-		panic(fmt.Errorf("module %q already registered", name))
-	}
-	moduleRegister[name] = newModule(importFunc, description)
-}
-
-func IterateModules(op func(name, description string, imported bool) bool) {
-	if op != nil {
-		for name, mod := range moduleRegister {
-			if !op(name, mod.description, mod.imported) {
-				break
-			}
-		}
-	}
-}
-
-// ----
-func init() {
-	if moduleRegister == nil {
-		moduleRegister = make(map[string]*module)
-	}
-}

operand-const.go

@@ -0,0 +1,73 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operand-const.go
+package expr
+
+// -------- bool const term
+func newBoolTerm(tk *Token) *term {
+	return &term{
+		tk: *tk,
+		// class:    classConst,
+		// kind:     kindBool,
+		parent:   nil,
+		children: nil,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalConst,
+	}
+}
+
+// -------- integer const term
+func newIntegerTerm(tk *Token) *term {
+	return &term{
+		tk:       *tk,
+		parent:   nil,
+		children: nil,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalConst,
+	}
+}
+
+// -------- float const term
+func newFloatTerm(tk *Token) *term {
+	return &term{
+		tk: *tk,
+		// class:    classConst,
+		// kind:     kindFloat,
+		parent:   nil,
+		children: nil,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalConst,
+	}
+}
+
+// -------- string const term
+func newStringTerm(tk *Token) *term {
+	return &term{
+		tk: *tk,
+		// class:    classConst,
+		// kind:     kindString,
+		parent:   nil,
+		children: nil,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalConst,
+	}
+}
+
+// -------- eval func
+func evalConst(ctx ExprContext, self *term) (v any, err error) {
+	v = self.tk.Value
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymString, newStringTerm)
+	registerTermConstructor(SymInteger, newIntegerTerm)
+	registerTermConstructor(SymFloat, newFloatTerm)
+	registerTermConstructor(SymBool, newBoolTerm)
+}

operand-dict.go

@@ -1,35 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operand-dict.go
-package expr
-
-
-// -------- dict term
-func newDictTerm(args map[any]*term) *term {
-	return &term{
-		tk:       *NewValueToken(0, 0, SymDict, "{}", args),
-		parent:   nil,
-		children: nil,
-		position: posLeaf,
-		priority: priValue,
-		evalFunc: evalDict,
-	}
-}
-
-// -------- dict func
-func evalDict(ctx ExprContext, self *term) (v any, err error) {
-	dict, _ := self.value().(map[any]*term)
-	items := make(DictType, len(dict))
-	for key, tree := range dict {
-		var param any
-		if param, err = tree.compute(ctx); err != nil {
-			break
-		}
-		items[key] = param
-	}
-	if err == nil {
-		v = &items
-	}
-	return
-}

operand-expr.go

@@ -7,8 +7,7 @@ package expr
 import "fmt"
 
 // -------- expr term
-func newExprTerm(root *term) *term {
+func newExprTerm(tk *Token) *term {
-	tk := NewValueToken(root.tk.row, root.tk.col, SymExpression, root.source(), root)
 	return &term{
 		tk:       *tk,
 		parent:   nil,
@@ -21,10 +20,15 @@ func newExprTerm(root *term) *term {
 
 // -------- eval expr
 func evalExpr(ctx ExprContext, self *term) (v any, err error) {
-	if expr, ok := self.value().(*term); ok {
+	if expr, ok := self.value().(Expr); ok {
-		v, err = expr.compute(ctx)
+		v, err = expr.eval(ctx, false)
 	} else {
 		err = fmt.Errorf("expression expected, got %T", self.value())
 	}
 	return
 }
+
+// init
+// func init() {
+// 	registerTermConstructor(SymExpression, newExprTerm)
+// }

operand-func.go

@@ -6,13 +6,14 @@ package expr
 
 import (
 	"errors"
-	"fmt"
 )
 
 // -------- function call term
 func newFuncCallTerm(tk *Token, args []*term) *term {
 	return &term{
-		tk:       *tk,
+		tk: *tk,
+		// class:    classVar,
+		// kind:     kindUnknown,
 		parent:   nil,
 		children: args,
 		position: posLeaf,
@@ -22,36 +23,10 @@ func newFuncCallTerm(tk *Token, args []*term) *term {
 }
 
 // -------- eval func call
-func checkFunctionCall(ctx ExprContext, name string, varParams *[]any) (err error) {
-	if info, exists, owner := GetFuncInfo(ctx, name); exists {
-		passedCount := len(*varParams)
-		if info.MinArgs() > passedCount {
-			err = errTooFewParams(name, info.MinArgs(), info.MaxArgs(), passedCount)
-		}
-		for i, p := range info.Params() {
-			if i >= passedCount {
-				if !p.IsOptional() {
-					break
-				}
-				*varParams = append(*varParams, p.DefaultValue())
-			}
-		}
-		if err == nil && info.MaxArgs() >= 0 && info.MaxArgs() < len(*varParams) {
-			err = errTooMuchParams(name, info.MaxArgs(), len(*varParams))
-		}
-		if err == nil && owner != ctx {
-			ctx.RegisterFuncInfo(info)
-		}
-	} else {
-		err = fmt.Errorf("unknown function %s()", name)
-	}
-	return
-}
-
 func evalFuncCall(parentCtx ExprContext, self *term) (v any, err error) {
-	ctx := cloneContext(parentCtx)
+	ctx := parentCtx.Clone()
 	name, _ := self.tk.Value.(string)
-	params := make([]any, len(self.children), len(self.children)+5)
+	params := make([]any, len(self.children))
 	for i, tree := range self.children {
 		var param any
 		if param, err = tree.compute(ctx); err != nil {
@@ -59,23 +34,45 @@ func evalFuncCall(parentCtx ExprContext, self *term) (v any, err error) {
 		}
 		params[i] = param
 	}
-
 	if err == nil {
-		if err = checkFunctionCall(ctx, name, &params); err == nil {
+		if v, err = ctx.Call(name, params); err == nil {
-			if v, err = ctx.Call(name, params); err == nil {
+			exportAll := isEnabled(ctx, control_export_all)
-				exportObjects(parentCtx, ctx)
+			// Export variables
+			for _, refName := range ctx.EnumVars(func(name string) bool { return exportAll || name[0] == '@' }) {
+				refValue, _ := ctx.GetVar(refName)
+				exportVar(parentCtx, refName, refValue)
+			}
+			// Export functions
+			for _, refName := range ctx.EnumFuncs(func(name string) bool { return exportAll || name[0] == '@' }) {
+				if info := ctx.GetFuncInfo(refName); info != nil {
+					exportFunc(parentCtx, refName, info)
+				}
 			}
 		}
 	}
 	return
 }
 
+func exportVar(ctx ExprContext, name string, value any) {
+	if name[0] == '@' {
+		name = name[1:]
+	}
+	ctx.setVar(name, value)
+}
+
+func exportFunc(ctx ExprContext, name string, info ExprFunc) {
+	if name[0] == '@' {
+		name = name[1:]
+	}
+	ctx.RegisterFunc(name, info.Functor(), info.MinArgs(), info.MaxArgs())
+}
+
 // -------- function definition term
 func newFuncDefTerm(tk *Token, args []*term) *term {
 	return &term{
-		tk:       *tk, // value is the expression body
+		tk:       *tk,
 		parent:   nil,
-		children: args, // function params
+		children: args, // arg[0]=formal-param-list, arg[1]=*ast
 		position: posLeaf,
 		priority: priValue,
 		evalFunc: evalFuncDef,
@@ -83,23 +80,46 @@ func newFuncDefTerm(tk *Token, args []*term) *term {
 }
 
 // -------- eval func def
+// TODO
+type funcDefFunctor struct {
+	params []string
+	expr   Expr
+}
+
+func (functor *funcDefFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
+	for i, p := range functor.params {
+		if i < len(args) {
+			arg := args[i]
+			if functor, ok := arg.(Functor); ok {
+				ctx.RegisterFunc(p, functor, 0, -1)
+			} else {
+				ctx.setVar(p, arg)
+			}
+		} else {
+			ctx.setVar(p, nil)
+		}
+	}
+	result, err = functor.expr.eval(ctx, false)
+	return
+}
+
 func evalFuncDef(ctx ExprContext, self *term) (v any, err error) {
 	bodySpec := self.value()
 	if expr, ok := bodySpec.(*ast); ok {
-		paramList := make([]ExprFuncParam, 0, len(self.children))
+		paramList := make([]string, 0, len(self.children))
 		for _, param := range self.children {
-			var defValue any
+			paramList = append(paramList, param.source())
-			flags := paramFlags(0)
+			// if paramName, ok := param.value().(string); ok {
-			if len(param.children) > 0 {
+			// 	paramList = append(paramList, paramName)
-				flags |= pfOptional
+			// } else {
-				if defValue, err = param.children[0].compute(ctx); err != nil {
+			// 	err = fmt.Errorf("invalid function definition: formal param nr %d must be an identifier", i+1)
-					return
+			// 	break
-				}
+			// }
-			}
+		}
-			info := newFuncParamFlagDef(param.source(), flags, defValue)
+		v = &funcDefFunctor{
-			paramList = append(paramList, info)
+			params: paramList,
+			expr:   expr,
 		}
-		v = newExprFunctor(expr, paramList, ctx)
 	} else {
 		err = errors.New("invalid function definition: the body specification must be an expression")
 	}

operand-iterator.go

@@ -1,169 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operand-iterator.go
-package expr
-
-import (
-	"fmt"
-	"slices"
-	"strings"
-)
-
-// -------- iterator term
-
-func newDsIteratorTerm(tk *Token, dsTerm *term, args []*term) *term {
-	tk.Sym = SymIterator
-
-	children := make([]*term, 0, 1+len(args))
-	children = append(children, dsTerm)
-	children = append(children, args...)
-	return &term{
-		tk:       *tk,
-		parent:   nil,
-		children: children,
-		position: posLeaf,
-		priority: priValue,
-		evalFunc: evalIterator,
-	}
-}
-
-func newIteratorTerm(tk *Token, args []*term) *term {
-	tk.Sym = SymIterator
-	return &term{
-		tk:       *tk,
-		parent:   nil,
-		children: args,
-		position: posLeaf,
-		priority: priValue,
-		evalFunc: evalIterator,
-	}
-}
-
-// -------- eval iterator
-
-func evalTermArray(ctx ExprContext, a []*term) (values []any, err error) {
-	values = make([]any, len(a))
-	for i, t := range a {
-		var value any
-		if value, err = t.compute(ctx); err == nil {
-			values[i] = value
-		} else {
-			break
-		}
-	}
-	return
-}
-
-func evalFirstChild(ctx ExprContext, self *term) (value any, err error) {
-	if len(self.children) < 1 || self.children[0] == nil {
-		err = self.Errorf("missing the data-source parameter")
-		return
-	}
-
-	value, err = self.children[0].compute(ctx)
-	return
-}
-
-func getDataSourceDict(ctx ExprContext, self *term, firstChildValue any) (ds map[string]Functor, err error) {
-	// if dictAny, ok := firstChildValue.(map[any]any); ok {
-	if dictAny, ok := firstChildValue.(*DictType); ok {
-		requiredFields := []string{currentName, nextName}
-		fieldsMask := 0b11
-		foundFields := 0
-		ds = make(map[string]Functor)
-		for keyAny, item := range *dictAny {
-			if key, ok := keyAny.(string); ok {
-				//if functor, ok := item.(*funcDefFunctor); ok {
-				if functor, ok := item.(Functor); ok {
-					ds[key] = functor
-					if index := slices.Index(requiredFields, key); index >= 0 {
-						foundFields |= 1 << index
-					}
-				}
-			}
-		}
-		// check required functions
-		if foundFields != fieldsMask {
-			missingFields := make([]string, 0, len(requiredFields))
-			for index, field := range requiredFields {
-				if (foundFields & (1 << index)) == 0 {
-					missingFields = append(missingFields, field)
-				}
-			}
-			err = fmt.Errorf("the data-source must provide a non-nil %q operator(s)", strings.Join(missingFields, ", "))
-		}
-	}
-	return
-}
-
-func evalIterator(ctx ExprContext, self *term) (v any, err error) {
-	var firstChildValue any
-	var ds map[string]Functor
-
-	if firstChildValue, err = evalFirstChild(ctx, self); err != nil {
-		return
-	}
-
-	if ds, err = getDataSourceDict(ctx, self, firstChildValue); err != nil {
-		return
-	}
-
-	if ds != nil {
-		dc := newDataCursor(ctx, ds)
-		if initFunc, exists := ds[initName]; exists && initFunc != nil {
-			var args []any
-			if len(self.children) > 1 {
-				if args, err = evalTermArray(ctx, self.children[1:]); err != nil {
-					return
-				}
-			} else {
-				args = []any{}
-			}
-
-			initCtx := dc.ctx.Clone()
-			if dc.resource, err = initFunc.Invoke(initCtx, initName, args); err != nil {
-				return
-			}
-			exportObjects(dc.ctx, initCtx)
-		}
-
-		dc.nextFunc, _ = ds[nextName]
-		dc.currentFunc, _ = ds[currentName]
-		dc.cleanFunc, _ = ds[cleanName]
-		dc.resetFunc, _ = ds[resetName]
-
-		v = dc
-	} else if list, ok := firstChildValue.(*ListType); ok {
-		var args []any
-		if args, err = evalSibling(ctx, self.children, nil); err == nil {
-			v = NewListIterator(list, args)
-		}
-	} else {
-		var list []any
-		if list, err = evalSibling(ctx, self.children, firstChildValue); err == nil {
-			v = NewArrayIterator(list)
-		}
-	}
-	return
-}
-
-func evalSibling(ctx ExprContext, terms []*term, firstChildValue any) (list []any, err error) {
-	items := make([]any, 0, len(terms))
-	for i, tree := range terms {
-		var param any
-		if i == 0 {
-			if firstChildValue == nil {
-				continue
-			}
-			param = firstChildValue
-		} else if param, err = tree.compute(ctx); err != nil {
-			break
-		}
-		items = append(items, param)
-	}
-	if err == nil {
-		list = items
-	}
-	return
-}

operand-list.go

@@ -6,12 +6,12 @@ package expr
 
 // -------- list term
 func newListTermA(args ...*term) *term {
-	return newListTerm(0, 0, args)
+	return newListTerm(args)
 }
 
-func newListTerm(row, col int, args []*term) *term {
+func newListTerm(args []*term) *term {
 	return &term{
-		tk:       *NewValueToken(row, col, SymList, "[]", args),
+		tk:       *NewValueToken(0, 0, SymList, "[]", args),
 		parent:   nil,
 		children: nil,
 		position: posLeaf,
@@ -23,7 +23,7 @@ func newListTerm(row, col int, args []*term) *term {
 // -------- list func
 func evalList(ctx ExprContext, self *term) (v any, err error) {
 	list, _ := self.value().([]*term)
-	items := make(ListType, len(list))
+	items := make([]any, len(list))
 	for i, tree := range list {
 		var param any
 		if param, err = tree.compute(ctx); err != nil {
@@ -32,7 +32,35 @@ func evalList(ctx ExprContext, self *term) (v any, err error) {
 		items[i] = param
 	}
 	if err == nil {
-		v = &items
+		v = items
 	}
 	return
 }
+
+// // -------- list term
+// func newListTerm(args []*term) *term {
+// 	return &term{
+// 		tk:       *NewToken(0, 0, SymList, "[]"),
+// 		parent:   nil,
+// 		children: args,
+// 		position: posLeaf,
+// 		priority: priValue,
+// 		evalFunc: evalList,
+// 	}
+// }
+
+// // -------- list func
+// func evalList(ctx ExprContext, self *term) (v any, err error) {
+// 	items := make([]any, len(self.children))
+// 	for i, tree := range self.children {
+// 		var param any
+// 		if param, err = tree.compute(ctx); err != nil {
+// 			break
+// 		}
+// 		items[i] = param
+// 	}
+// 	if err == nil {
+// 		v = items
+// 	}
+// 	return
+// }

operand-literal.go

@@ -1,33 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operand-literal.go
-package expr
-
-// -------- literal term
-func newLiteralTerm(tk *Token) *term {
-	return &term{
-		tk:       *tk,
-		parent:   nil,
-		children: nil,
-		position: posLeaf,
-		priority: priValue,
-		evalFunc: evalLiteral,
-	}
-}
-
-// -------- eval func
-func evalLiteral(ctx ExprContext, self *term) (v any, err error) {
-	v = self.tk.Value
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymString, newLiteralTerm)
-	registerTermConstructor(SymInteger, newLiteralTerm)
-	registerTermConstructor(SymFloat, newLiteralTerm)
-	registerTermConstructor(SymFraction, newLiteralTerm)
-	registerTermConstructor(SymBool, newLiteralTerm)
-	registerTermConstructor(SymKwNil, newLiteralTerm)
-}

operand-var.go

@@ -8,28 +8,23 @@ import "fmt"
 
 // -------- variable term
 func newVarTerm(tk *Token) *term {
-	t := &term{
+	return &term{
-		tk:       *tk,
+		tk: *tk,
+		// class:    classVar,
+		// kind:     kindUnknown,
 		parent:   nil,
 		children: nil,
 		position: posLeaf,
 		priority: priValue,
 		evalFunc: evalVar,
 	}
-	t.tk.Sym = SymVariable
-	return t
 }
 
 // -------- eval func
 func evalVar(ctx ExprContext, self *term) (v any, err error) {
 	var exists bool
-	name := self.source()
+	if v, exists = ctx.GetVar(self.tk.source); !exists {
-	if v, exists = GetVar(ctx, name); !exists {
+		err = fmt.Errorf("undefined variable %q", self.tk.source)
-		if info, exists, _ := GetFuncInfo(ctx, name); exists {
-			v = info.Functor()
-		} else {
-			err = fmt.Errorf("undefined variable or function %q", name)
-		}
 	}
 	return
 }

operator-assign.go

@@ -1,5 +1,5 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserightChilded.
+// All rights reserved.
 
 // operator-assign.go
 package expr
@@ -16,82 +16,24 @@ func newAssignTerm(tk *Token) (inst *term) {
 	}
 }
 
-func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, value any) (err error) {
-	var collectionValue, keyListValue, keyValue any
-	var keyList *ListType
-	var ok bool
-
-	if collectionValue, err = collectionTerm.compute(ctx); err != nil {
-		return
-	}
-
-	if keyListValue, err = keyListTerm.compute(ctx); err != nil {
-		return
-	} else if keyList, ok = keyListValue.(*ListType); !ok || len(*keyList) != 1 {
-		err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, typeName(keyListValue))
-		return
-	}
-	if keyValue = (*keyList)[0]; keyValue == nil {
-		err = keyListTerm.Errorf("index/key is nil")
-		return
-	}
-
-	switch collection := collectionValue.(type) {
-	case *ListType:
-		if index, ok := keyValue.(int64); ok {
-			err = collection.setItem(index, value)
-		} else {
-			err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, typeName(keyValue))
-		}
-	case *DictType:
-		err = collection.setItem(keyValue, value)
-	default:
-		err = collectionTerm.Errorf("collection expected")
-	}
-	return
-}
-
-func assignValue(ctx ExprContext, leftTerm *term, v any) (err error) {
-	if leftTerm.symbol() == SymIndex {
-		err = assignCollectionItem(ctx, leftTerm.children[0], leftTerm.children[1], v)
-	} else {
-		ctx.UnsafeSetVar(leftTerm.source(), v)
-	}
-	return
-}
-
 func evalAssign(ctx ExprContext, self *term) (v any, err error) {
 	if err = self.checkOperands(); err != nil {
 		return
 	}
 
 	leftTerm := self.children[0]
-	leftSym := leftTerm.symbol()
+	if leftTerm.tk.Sym != SymIdentifier {
-	if leftSym != SymVariable && leftSym != SymIndex {
+		err = leftTerm.tk.Errorf("left operand of %q must be a variable", self.tk.source)
-		err = leftTerm.tk.Errorf("left operand of %q must be a variable or a collection's item", self.tk.source)
 		return
 	}
 
-	rightChild := self.children[1]
+	if v, err = self.children[1].compute(ctx); err == nil {
-
-	if v, err = rightChild.compute(ctx); err == nil {
 		if functor, ok := v.(Functor); ok {
-			if info := functor.GetFunc(); info != nil {
+			ctx.RegisterFunc(leftTerm.source(), functor, 0, -1)
-				ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
-			} else if funcDef, ok := functor.(*exprFunctor); ok {
-				paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })
-
-				ctx.RegisterFunc(leftTerm.source(), functor, typeAny, paramSpecs)
-			} else {
-				err = self.Errorf("unknown function %s()", rightChild.source())
-			}
 		} else {
-			err = assignValue(ctx, leftTerm, v)
+			ctx.setVar(leftTerm.tk.source, v)
 		}
 	}
-	if err != nil {
-		v = nil
-	}
 	return
 }
 

operator-builtin.go

@@ -1,11 +1,9 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// operator-builtin.go
+// operator-length.go
 package expr
 
-import "io"
-
 //-------- builtin term
 
 func newBuiltinTerm(tk *Token) (inst *term) {
@@ -19,38 +17,36 @@ func newBuiltinTerm(tk *Token) (inst *term) {
 }
 
 func evalBuiltin(ctx ExprContext, self *term) (v any, err error) {
-	var childValue any
+	var rightValue any
 
-	if childValue, err = self.evalPrefix(ctx); err != nil {
+	if rightValue, err = self.evalPrefix(ctx); err != nil {
 		return
 	}
 
 	count := 0
-	if IsString(childValue) {
+	if isList(rightValue) {
-		module, _ := childValue.(string)
+		list, _ := rightValue.([]any)
-		count, err = ImportInContextByGlobPattern(module)
+		for i, moduleSpec := range list {
-	} else {
-		var moduleSpec any
-		it := NewAnyIterator(childValue)
-		for moduleSpec, err = it.Next(); err == nil; moduleSpec, err = it.Next() {
 			if module, ok := moduleSpec.(string); ok {
-				if ImportInContext(module) {
+				if ImportInContext(ctx, module) {
 					count++
 				} else {
 					err = self.Errorf("unknown module %q", module)
 					break
 				}
 			} else {
-				err = self.Errorf("expected string at item nr %d, got %T", it.Index()+1, moduleSpec)
+				err = self.Errorf("expected string at item nr %d, got %T", i+1, moduleSpec)
 				break
 			}
 		}
-		if err == io.EOF {
+	} else if isString(rightValue) {
-			err = nil
+		module, _ := rightValue.(string)
-		}
+		count, err = ImportInContextByGlobPattern(ctx, module)
+	} else {
+		err = self.errIncompatibleType(rightValue)
 	}
 	if err == nil {
-		v = int64(count)
+		v = count
 	}
 	return
 }

operator-coalesce.go

@@ -8,7 +8,9 @@ package expr
 
 func newNullCoalesceTerm(tk *Token) (inst *term) {
 	return &term{
-		tk:       *tk,
+		tk: *tk,
+		// class:    classOperator,
+		// kind:     kindUnknown,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priCoalesce,
@@ -24,7 +26,7 @@ func evalNullCoalesce(ctx ExprContext, self *term) (v any, err error) {
 	}
 
 	leftTerm := self.children[0]
-	if leftTerm.tk.Sym != SymVariable {
+	if leftTerm.tk.Sym != SymIdentifier {
 		err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
 		return
 	}
@@ -32,7 +34,11 @@ func evalNullCoalesce(ctx ExprContext, self *term) (v any, err error) {
 	if leftValue, exists := ctx.GetVar(leftTerm.source()); exists {
 		v = leftValue
 	} else if rightValue, err = self.children[1].compute(ctx); err == nil {
-		v = rightValue
+		if _, ok := rightValue.(Functor); ok {
+			err = errCoalesceNoFunc(self.children[1])
+		} else {
+			v = rightValue
+		}
 	}
 	return
 }
@@ -57,7 +63,7 @@ func evalAssignCoalesce(ctx ExprContext, self *term) (v any, err error) {
 	}
 
 	leftTerm := self.children[0]
-	if leftTerm.tk.Sym != SymVariable {
+	if leftTerm.tk.Sym != SymIdentifier {
 		err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
 		return
 	}
@@ -65,19 +71,21 @@ func evalAssignCoalesce(ctx ExprContext, self *term) (v any, err error) {
 	if leftValue, exists := ctx.GetVar(leftTerm.source()); exists {
 		v = leftValue
 	} else if rightValue, err = self.children[1].compute(ctx); err == nil {
-		if functor, ok := rightValue.(Functor); ok {
+		if _, ok := rightValue.(Functor); ok {
-			//ctx.RegisterFunc(leftTerm.source(), functor, 0, -1)
+			err = errCoalesceNoFunc(self.children[1])
-			ctx.RegisterFunc(leftTerm.source(), functor, typeAny, []ExprFuncParam{
-				newFuncParamFlag(paramValue, pfOptional|pfRepeat),
-			})
 		} else {
 			v = rightValue
-			ctx.UnsafeSetVar(leftTerm.source(), rightValue)
+			ctx.setVar(leftTerm.source(), rightValue)
 		}
 	}
 	return
 }
 
+// utils
+func errCoalesceNoFunc(t *term) error {
+	return t.Errorf("the right operand of a coalescing operation cannot be a function definition")
+}
+
 // init
 func init() {
 	registerTermConstructor(SymDoubleQuestion, newNullCoalesceTerm)

operator-context.go

@@ -1,57 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-context-value.go
-package expr
-
-//-------- context term
-
-func newContextTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 1),
-		position: posPrefix,
-		priority: priIncDec,
-		evalFunc: evalContextValue,
-	}
-}
-
-func evalContextValue(ctx ExprContext, self *term) (v any, err error) {
-	var childValue any
-
-	var sourceCtx ExprContext
-	if self.children == nil || len(self.children) == 0 {
-		sourceCtx = ctx
-	} else if self.children[0].symbol() == SymVariable && self.children[0].source() == "global" {
-		sourceCtx = globalCtx
-	} else if childValue, err = self.evalPrefix(ctx); err == nil {
-		if dc, ok := childValue.(*dataCursor); ok {
-			sourceCtx = dc.ctx
-		}
-	}
-
-	if sourceCtx != nil {
-		if formatter, ok := sourceCtx.(Formatter); ok {
-			v = formatter.ToString(0)
-		} else {
-			keys := sourceCtx.EnumVars(func(name string) bool { return name[0] != '_' })
-			d := make(map[string]any)
-			for _, key := range keys {
-				d[key], _ = sourceCtx.GetVar(key)
-			}
-			keys = sourceCtx.EnumFuncs(func(name string) bool { return true })
-			for _, key := range keys {
-				d[key], _ = sourceCtx.GetFuncInfo(key)
-			}
-			v = d
-		}
-	} else {
-		err = self.errIncompatibleType(childValue)
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymDoubleDollar, newContextTerm)
-}

operator-dot.go

@@ -18,32 +18,39 @@ func newDotTerm(tk *Token) (inst *term) {
 func evalDot(ctx ExprContext, self *term) (v any, err error) {
 	var leftValue, rightValue any
 
-	if err = self.checkOperands(); err != nil {
+	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-	if leftValue, err = self.children[0].compute(ctx); err != nil {
 		return
 	}
 
 	indexTerm := self.children[1]
+	if !isInteger(rightValue) {
+		err = indexTerm.Errorf("index expression must be integer, got %T", rightValue)
+		return
+	}
 
-	switch unboxedValue := leftValue.(type) {
+	index64, _ := rightValue.(int64)
-	case ExtIterator:
+	index := int(index64)
-		if indexTerm.symbol() == SymVariable /*|| indexTerm.symbol() == SymString */ {
+
-			opName := indexTerm.source()
+	if isList(leftValue) {
-			if unboxedValue.HasOperation(opName) {
+		list, _ := leftValue.([]any)
-				v, err = unboxedValue.CallOperation(opName, []any{})
+		if index >= 0 && index < len(list) {
-			} else {
+			v = list[index]
-				err = indexTerm.Errorf("this iterator do not support the %q command", opName)
+		} else if index >= -len(list) {
-				v = false
+			v = list[len(list)+index]
-			}
 		} else {
-			err = indexTerm.tk.ErrorExpectedGot("identifier")
+			err = indexTerm.Errorf("index %v out of bounds", index)
 		}
-	default:
+	} else if isString(leftValue) {
-		if rightValue, err = self.children[1].compute(ctx); err == nil {
+		s, _ := leftValue.(string)
-			err = self.errIncompatibleTypes(leftValue, rightValue)
+		if index >= 0 && index < len(s) {
+			v = string(s[index])
+		} else if index >= -len(s) {
+			v = string(s[len(s)+index])
+		} else {
+			err = indexTerm.Errorf("index %v out of bounds", index)
 		}
+	} else {
+		err = self.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }

operator-fact.go

@@ -25,7 +25,7 @@ func evalFact(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if IsInteger(leftValue) {
+	if isInteger(leftValue) {
 		if i, _ := leftValue.(int64); i >= 0 {
 			f := int64(1)
 			for k := int64(1); k <= i; k++ {

operator-fraction.go

@@ -1,66 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operand-fraction.go
-package expr
-
-//https://www.youmath.it/lezioni/algebra-elementare/lezioni-di-algebra-e-aritmetica-per-scuole-medie/553-dalle-frazioni-a-numeri-decimali.html
-
-import (
-	"errors"
-	"fmt"
-)
-
-// -------- fraction term
-func newFractionTerm(tk *Token) *term {
-	return &term{
-		tk:       *tk,
-		parent:   nil,
-		children: make([]*term, 0, 2),
-		position: posInfix,
-		priority: priFraction,
-		evalFunc: evalFraction,
-	}
-}
-
-// -------- eval func
-func evalFraction(ctx ExprContext, self *term) (v any, err error) {
-	var numValue, denValue any
-	var num, den int64
-	var ok bool
-
-	if numValue, denValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-	if num, ok = numValue.(int64); !ok {
-		err = fmt.Errorf("numerator must be integer, got %T (%v)", numValue, numValue)
-		return
-	}
-	if den, ok = denValue.(int64); !ok {
-		err = fmt.Errorf("denominator must be integer, got %T (%v)", denValue, denValue)
-		return
-	}
-	if den == 0 {
-		err = errors.New("division by zero")
-		return
-	}
-
-	if den < 0 {
-		den = -den
-		num = -num
-	}
-	g := gcd(num, den)
-	num = num / g
-	den = den / g
-	if den == 1 {
-		v = num
-	} else {
-		v = &FractionType{num, den}
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymVertBar, newFractionTerm)
-}

operator-in.go

@@ -1,46 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-in.go
-package expr
-
-//-------- in term
-
-func newInTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 2),
-		position: posInfix,
-		priority: priRelational,
-		evalFunc: evalIn,
-	}
-}
-
-// func hasKey(d map[any]any, target any) (ok bool) {
-// 	_, ok = d[target]
-// 	return
-// }
-
-func evalIn(ctx ExprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-
-	if IsList(rightValue) {
-		list, _ := rightValue.(*ListType)
-		v = list.indexDeepSameCmp(leftValue) >= 0
-	} else if IsDict(rightValue) {
-		dict, _ := rightValue.(*DictType)
-		v = dict.hasKey(leftValue)
-	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymKwIn, newInTerm)
-}

operator-include.go

@@ -1,57 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-include.go
-package expr
-
-//-------- include term
-
-func newIncludeTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 1),
-		position: posPrefix,
-		priority: priSign,
-		evalFunc: evalInclude,
-	}
-}
-
-func evalInclude(ctx ExprContext, self *term) (v any, err error) {
-	var childValue any
-
-	if childValue, err = self.evalPrefix(ctx); err != nil {
-		return
-	}
-
-	count := 0
-	if IsList(childValue) {
-		list, _ := childValue.([]any)
-		for i, filePathSpec := range list {
-			if filePath, ok := filePathSpec.(string); ok {
-				if v, err = EvalFile(ctx, filePath); err == nil {
-					count++
-				} else {
-					err = self.Errorf("can't load file %q", filePath)
-					break
-				}
-			} else {
-				err = self.Errorf("expected string at item nr %d, got %T", i+1, filePathSpec)
-				break
-			}
-		}
-	} else if IsString(childValue) {
-		filePath, _ := childValue.(string)
-		v, err = EvalFile(ctx, filePath)
-	} else {
-		err = self.errIncompatibleType(childValue)
-	}
-	if err == nil {
-		v = count
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymKwInclude, newIncludeTerm)
-}

operator-index.go

@@ -1,123 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-index.go
-package expr
-
-// -------- index term
-func newIndexTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 2),
-		position: posInfix,
-		priority: priDot,
-		evalFunc: evalIndex,
-	}
-}
-
-func verifyKey(indexTerm *term, indexList *ListType) (index any, err error) {
-	index = (*indexList)[0]
-	return
-}
-
-func verifyIndex(indexTerm *term, indexList *ListType, maxValue int) (index int, err error) {
-	var v int
-
-	if v, err = toInt((*indexList)[0], "index expression"); err == nil {
-		if v < 0 && v >= -maxValue {
-			v = maxValue + v
-		}
-		if v >= 0 && v < maxValue {
-			index = v
-		} else {
-			err = indexTerm.Errorf("index %d out of bounds", v)
-		}
-	}
-	return
-}
-
-func verifyRange(indexTerm *term, indexList *ListType, maxValue int) (startIndex, endIndex int, err error) {
-	v, _ := ((*indexList)[0]).(*intPair)
-	startIndex = v.a
-	endIndex = v.b
-	if startIndex < 0 && startIndex >= -maxValue {
-		startIndex = maxValue + startIndex
-	}
-	if endIndex < 0 && endIndex >= -maxValue {
-		endIndex = maxValue + endIndex + 1
-	}
-	if startIndex < 0 || startIndex > maxValue {
-		err = indexTerm.Errorf("range start-index %d is out of bounds", startIndex)
-	} else if endIndex < 0 || endIndex > maxValue {
-		err = indexTerm.Errorf("range end-index %d is out of bounds", endIndex)
-	} else if startIndex > endIndex {
-		err = indexTerm.Errorf("range start-index %d must not be greater than end-index %d", startIndex, endIndex)
-	}
-	return
-}
-
-func evalIndex(ctx ExprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
-	var indexList *ListType
-	var ok bool
-
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-
-	indexTerm := self.children[1]
-	if indexList, ok = rightValue.(*ListType); !ok {
-		err = self.Errorf("invalid index expression")
-		return
-	} else if len(*indexList) != 1 {
-		err = indexTerm.Errorf("one index only is allowed")
-		return
-	}
-
-	if IsInteger((*indexList)[0]) {
-		switch unboxedValue := leftValue.(type) {
-		case *ListType:
-			var index int
-			if index, err = verifyIndex(indexTerm, indexList, len(*unboxedValue)); err == nil {
-				v = (*unboxedValue)[index]
-			}
-		case string:
-			var index int
-			if index, err = verifyIndex(indexTerm, indexList, len(unboxedValue)); err == nil {
-				v = string(unboxedValue[index])
-			}
-		case *DictType:
-			var ok bool
-			var indexValue any
-			if indexValue, err = verifyKey(indexTerm, indexList); err == nil {
-				if v, ok = (*unboxedValue)[indexValue]; !ok {
-					err = indexTerm.Errorf("key %v does not belong to the dictionary", rightValue)
-				}
-			}
-		default:
-			err = self.errIncompatibleTypes(leftValue, rightValue)
-		}
-	} else if isIntPair((*indexList)[0]) {
-		switch unboxedValue := leftValue.(type) {
-		case *ListType:
-			var start, end int
-			if start, end, err = verifyRange(indexTerm, indexList, len(*unboxedValue)); err == nil {
-				sublist := ListType((*unboxedValue)[start:end])
-				v = &sublist
-			}
-		case string:
-			var start, end int
-			if start, end, err = verifyRange(indexTerm, indexList, len(unboxedValue)); err == nil {
-				v = unboxedValue[start:end]
-			}
-		default:
-			err = self.errIncompatibleTypes(leftValue, rightValue)
-		}
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymIndex, newIndexTerm)
-}

operator-insert.go

@@ -33,13 +33,9 @@ func evalInsert(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if IsList(rightValue) {
+	if isList(rightValue) {
-		list, _ := rightValue.(*ListType)
+		list, _ := rightValue.([]any)
-		newList := append(ListType{leftValue}, *list...)
+		v = append([]any{leftValue}, list...)
-		v = &newList
-		if self.children[1].symbol() == SymVariable {
-			ctx.UnsafeSetVar(self.children[1].source(), v)
-		}
 	} else {
 		err = self.errIncompatibleTypes(leftValue, rightValue)
 	}
@@ -53,37 +49,15 @@ func evalAppend(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if IsList(leftValue) {
+	if isList(leftValue) {
-		list, _ := leftValue.(*ListType)
+		list, _ := leftValue.([]any)
-		newList := append(*list, rightValue)
+		v = append(list, rightValue)
-		v = &newList
-		if self.children[0].symbol() == SymVariable {
-			ctx.UnsafeSetVar(self.children[0].source(), v)
-		}
 	} else {
 		err = self.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
 
-// func evalAssignAppend(ctx ExprContext, self *term) (v any, err error) {
-// 	var leftValue, rightValue any
-
-// 	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-// 		return
-// 	}
-
-// 	if IsList(leftValue) {
-// 		list, _ := leftValue.(*ListType)
-// 		newList := append(*list, rightValue)
-// 		v = &newList
-// 		if
-// 	} else {
-// 		err = self.errIncompatibleTypes(leftValue, rightValue)
-// 	}
-// 	return
-// }
-
 // init
 func init() {
 	registerTermConstructor(SymInsert, newInsertTerm)

operator-iter-value.go

@@ -1,37 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-iter-value.go
-package expr
-
-//-------- iter value term
-
-func newIterValueTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 1),
-		position: posPrefix,
-		priority: priIterValue,
-		evalFunc: evalIterValue,
-	}
-}
-
-func evalIterValue(ctx ExprContext, self *term) (v any, err error) {
-	var childValue any
-
-	if childValue, err = self.evalPrefix(ctx); err != nil {
-		return
-	}
-
-	if it, ok := childValue.(Iterator); ok {
-		v, err = it.Current()
-	} else {
-		err = self.errIncompatibleType(childValue)
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymOpenClosedRound, newIterValueTerm)
-}

operator-length.go

@@ -17,31 +17,23 @@ func newLengthTerm(tk *Token) (inst *term) {
 }
 
 func evalLength(ctx ExprContext, self *term) (v any, err error) {
-	var childValue any
+	var rightValue any
 
-	if childValue, err = self.evalPrefix(ctx); err != nil {
+	if rightValue, err = self.evalPrefix(ctx); err != nil {
 		return
 	}
 
-	if IsList(childValue) {
+	if isList(rightValue) {
-		ls, _ := childValue.(*ListType)
+		list, _ := rightValue.([]any)
-		v = int64(len(*ls))
+		v = len(list)
-	} else if IsString(childValue) {
+	} else if isString(rightValue) {
-		s, _ := childValue.(string)
+		s, _ := rightValue.(string)
-		v = int64(len(s))
+		v = len(s)
-	} else if IsDict(childValue) {
+		// } else {
-		// m, _ := childValue.(map[any]any)
+		// 	v = 1
-		m, _ := childValue.(*DictType)
+		// }
-		v = int64(len(*m))
-	} else if it, ok := childValue.(Iterator); ok {
-		if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(countName) {
-			count, _ := extIt.CallOperation(countName, nil)
-			v, _ = toInt(count, "")
-		} else {
-			v = int64(it.Index() + 1)
-		}
 	} else {
-		err = self.errIncompatibleType(childValue)
+		err = self.errIncompatibleType(rightValue)
 	}
 	return
 }

operator-post-inc.go

@@ -1,41 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-post-inc.go
-package expr
-
-// -------- post increment term
-
-func newPostIncTerm(tk *Token) *term {
-	return &term{
-		tk:       *tk,
-		parent:   nil,
-		children: make([]*term, 0, 1),
-		position: posPostfix,
-		priority: priIncDec,
-		evalFunc: evalPostInc,
-	}
-}
-
-func evalPostInc(ctx ExprContext, self *term) (v any, err error) {
-	var childValue any
-	if childValue, err = self.evalPrefix(ctx); err != nil {
-		return
-	}
-
-	if it, ok := childValue.(Iterator); ok {
-		v, err = it.Next()
-	} else if IsInteger(childValue) && self.children[0].symbol() == SymVariable {
-		v = childValue
-		i, _ := childValue.(int64)
-		ctx.SetVar(self.children[0].source(), i+1)
-	} else {
-		err = self.errIncompatibleType(childValue)
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymDoublePlus, newPostIncTerm)
-}

operator-prod.go

@@ -30,15 +30,13 @@ func evalMultiply(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if IsString(leftValue) && IsInteger(rightValue) {
+	if isString(leftValue) && isInteger(rightValue) {
 		s, _ := leftValue.(string)
 		n, _ := rightValue.(int64)
 		v = strings.Repeat(s, int(n))
-	} else if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+	} else if isNumber(leftValue) && isNumber(rightValue) {
-		if IsFloat(leftValue) || IsFloat(rightValue) {
+		if isFloat(leftValue) || isFloat(rightValue) {
 			v = numAsFloat(leftValue) * numAsFloat(rightValue)
-		} else if isFraction(leftValue) || isFraction(rightValue) {
-			v, err = mulAnyFract(leftValue, rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			rightInt, _ := rightValue.(int64)
@@ -71,16 +69,14 @@ func evalDivide(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+	if isNumber(leftValue) && isNumber(rightValue) {
-		if IsFloat(leftValue) || IsFloat(rightValue) {
+		if isFloat(leftValue) || isFloat(rightValue) {
 			d := numAsFloat(rightValue)
 			if d == 0.0 {
 				err = errors.New("division by zero")
 			} else {
 				v = numAsFloat(leftValue) / d
 			}
-		} else if isFraction(leftValue) || isFraction(rightValue) {
-			v, err = divAnyFract(leftValue, rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			if rightInt, _ := rightValue.(int64); rightInt == 0 {
@@ -114,7 +110,7 @@ func evalDivideAsFloat(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+	if isNumber(leftValue) && isNumber(rightValue) {
 		d := numAsFloat(rightValue)
 		if d == 0.0 {
 			err = errors.New("division by zero")
@@ -148,7 +144,7 @@ func evalReminder(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if IsInteger(leftValue) && IsInteger(rightValue) {
+	if isInteger(leftValue) && isInteger(rightValue) {
 		rightInt, _ := rightValue.(int64)
 		if rightInt == 0 {
 			err = errors.New("division by zero")

operator-range.go

@@ -1,69 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-range.go
-package expr
-
-import "fmt"
-
-// -------- range term
-type intPair struct {
-	a, b int
-}
-
-func (p *intPair) TypeName() string {
-	return typePair
-}
-
-func (p *intPair) ToString(opt FmtOpt) string {
-	return fmt.Sprintf("(%d, %d)", p.a, p.b)
-}
-
-func isIntPair(v any) bool {
-	_, ok := v.(*intPair)
-	return ok
-}
-
-func newRangeTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 2),
-		position: posInfix,
-		priority: priDot,
-		evalFunc: evalRange,
-	}
-}
-
-func evalRange(ctx ExprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
-
-	// if err = self.checkOperands(); err != nil {
-	// 	return
-	// }
-	if len(self.children) == 0 {
-		leftValue = int64(0)
-		rightValue = int64(-1)
-	} else if len(self.children) == 1 {
-		if leftValue, err = self.children[0].compute(ctx); err != nil {
-			return
-		}
-		rightValue = int64(-1)
-	} else if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-	if !(IsInteger(leftValue) && IsInteger(rightValue)) {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
-		return
-	}
-
-	startIndex, _ := leftValue.(int64)
-	endIndex, _ := rightValue.(int64)
-
-	v = &intPair{int(startIndex), int(endIndex)}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymColon, newRangeTerm)
-}

operator-rel.go

@@ -4,13 +4,13 @@
 // operator-rel.go
 package expr
 
-import "reflect"
-
 //-------- equal term
 
 func newEqualTerm(tk *Token) (inst *term) {
 	return &term{
-		tk:       *tk,
+		tk: *tk,
+		// class:    classOperator,
+		// kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priRelational,
@@ -18,33 +18,6 @@ func newEqualTerm(tk *Token) (inst *term) {
 	}
 }
 
-type deepFuncTemplate func(a, b any) (eq bool, err error)
-
-func equals(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
-	if isNumOrFract(a) && isNumOrFract(b) {
-		if IsNumber(a) && IsNumber(b) {
-			if IsInteger(a) && IsInteger(b) {
-				li, _ := a.(int64)
-				ri, _ := b.(int64)
-				eq = li == ri
-			} else {
-				eq = numAsFloat(a) == numAsFloat(b)
-			}
-		} else {
-			var cmp int
-			if cmp, err = cmpAnyFract(a, b); err == nil {
-				eq = cmp == 0
-			}
-		}
-	} else if deepCmp != nil && IsList(a) && IsList(b) {
-		eq, err = deepCmp(a, b)
-	} else {
-		eq = reflect.DeepEqual(a, b)
-	}
-
-	return
-}
-
 func evalEqual(ctx ExprContext, self *term) (v any, err error) {
 	var leftValue, rightValue any
 
@@ -52,7 +25,21 @@ func evalEqual(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	v, err = equals(leftValue, rightValue, nil)
+	if isNumber(leftValue) && isNumber(rightValue) {
+		if isInteger(leftValue) && isInteger(rightValue) {
+			li, _ := leftValue.(int64)
+			ri, _ := rightValue.(int64)
+			v = li == ri
+		} else {
+			v = numAsFloat(leftValue) == numAsFloat(rightValue)
+		}
+	} else if isString(leftValue) && isString(rightValue) {
+		ls, _ := leftValue.(string)
+		rs, _ := rightValue.(string)
+		v = ls == rs
+	} else {
+		err = self.errIncompatibleTypes(leftValue, rightValue)
+	}
 	return
 }
 
@@ -60,7 +47,9 @@ func evalEqual(ctx ExprContext, self *term) (v any, err error) {
 
 func newNotEqualTerm(tk *Token) (inst *term) {
 	return &term{
-		tk:       *tk,
+		tk: *tk,
+		// class:    classOperator,
+		// kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priRelational,
@@ -76,11 +65,38 @@ func evalNotEqual(ctx ExprContext, self *term) (v any, err error) {
 	return
 }
 
+// func evalNotEqual(ctx exprContext, self *term) (v any, err error) {
+// 	var leftValue, rightValue any
+
+// 	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+// 		return
+// 	}
+
+// 	if isNumber(leftValue) && isNumber(rightValue) {
+// 		if isInteger(leftValue) && isInteger(rightValue) {
+// 			li, _ := leftValue.(int64)
+// 			ri, _ := rightValue.(int64)
+// 			v = li != ri
+// 		} else {
+// 			v = numAsFloat(leftValue) != numAsFloat(rightValue)
+// 		}
+// 	} else if isString(leftValue) && isString(rightValue) {
+// 		ls, _ := leftValue.(string)
+// 		rs, _ := rightValue.(string)
+// 		v = ls != rs
+// 	} else {
+// 		err = self.errIncompatibleTypes(leftValue, rightValue)
+// 	}
+// 	return
+// }
+
 //-------- less term
 
 func newLessTerm(tk *Token) (inst *term) {
 	return &term{
-		tk:       *tk,
+		tk: *tk,
+		// class:    classOperator,
+		// kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priRelational,
@@ -88,44 +104,28 @@ func newLessTerm(tk *Token) (inst *term) {
 	}
 }
 
-func lessThan(self *term, a, b any) (isLess bool, err error) {
-	if isNumOrFract(a) && isNumOrFract(b) {
-		if IsNumber(a) && IsNumber(b) {
-			if IsInteger(a) && IsInteger(b) {
-				li, _ := a.(int64)
-				ri, _ := b.(int64)
-				isLess = li < ri
-			} else {
-				isLess = numAsFloat(a) < numAsFloat(b)
-			}
-		} else {
-			var cmp int
-			if cmp, err = cmpAnyFract(a, b); err == nil {
-				isLess = cmp < 0
-			}
-		}
-	} else if IsString(a) && IsString(b) {
-		ls, _ := a.(string)
-		rs, _ := b.(string)
-		isLess = ls < rs
-		// Inclusion test
-	} else if IsList(a) && IsList(b) {
-		aList, _ := a.(*ListType)
-		bList, _ := b.(*ListType)
-		isLess = len(*aList) < len(*bList) && bList.contains(aList)
-	} else {
-		err = self.errIncompatibleTypes(a, b)
-	}
-	return
-}
-
 func evalLess(ctx ExprContext, self *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
 		return
 	}
-	v, err = lessThan(self, leftValue, rightValue)
+
+	if isNumber(leftValue) && isNumber(rightValue) {
+		if isInteger(leftValue) && isInteger(rightValue) {
+			li, _ := leftValue.(int64)
+			ri, _ := rightValue.(int64)
+			v = li < ri
+		} else {
+			v = numAsFloat(leftValue) < numAsFloat(rightValue)
+		}
+	} else if isString(leftValue) && isString(rightValue) {
+		ls, _ := leftValue.(string)
+		rs, _ := rightValue.(string)
+		v = ls < rs
+	} else {
+		err = self.errIncompatibleTypes(leftValue, rightValue)
+	}
 	return
 }
 
@@ -141,19 +141,6 @@ func newLessEqualTerm(tk *Token) (inst *term) {
 	}
 }
 
-func lessThanOrEqual(self *term, a, b any) (isLessEq bool, err error) {
-	if isLessEq, err = lessThan(self, a, b); err == nil {
-		if !isLessEq {
-			if IsList(a) && IsList(b) {
-				isLessEq, err = sameContent(a, b)
-			} else {
-				isLessEq, err = equals(a, b, nil)
-			}
-		}
-	}
-	return
-}
-
 func evalLessEqual(ctx ExprContext, self *term) (v any, err error) {
 	var leftValue, rightValue any
 
@@ -161,8 +148,21 @@ func evalLessEqual(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	v, err = lessThanOrEqual(self, leftValue, rightValue)
+	if isNumber(leftValue) && isNumber(rightValue) {
-
+		if isInteger(leftValue) && isInteger(rightValue) {
+			li, _ := leftValue.(int64)
+			ri, _ := rightValue.(int64)
+			v = li <= ri
+		} else {
+			v = numAsFloat(leftValue) <= numAsFloat(rightValue)
+		}
+	} else if isString(leftValue) && isString(rightValue) {
+		ls, _ := leftValue.(string)
+		rs, _ := rightValue.(string)
+		v = ls <= rs
+	} else {
+		err = self.errIncompatibleTypes(leftValue, rightValue)
+	}
 	return
 }
 
@@ -170,7 +170,9 @@ func evalLessEqual(ctx ExprContext, self *term) (v any, err error) {
 
 func newGreaterTerm(tk *Token) (inst *term) {
 	return &term{
-		tk:       *tk,
+		tk: *tk,
+		// class:    classOperator,
+		// kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priRelational,
@@ -179,13 +181,10 @@ func newGreaterTerm(tk *Token) (inst *term) {
 }
 
 func evalGreater(ctx ExprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
+	if v, err = evalLessEqual(ctx, self); err == nil {
-
+		b, _ := toBool(v)
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+		v = !b
-		return
 	}
-
-	v, err = lessThan(self, rightValue, leftValue)
 	return
 }
 
@@ -193,7 +192,9 @@ func evalGreater(ctx ExprContext, self *term) (v any, err error) {
 
 func newGreaterEqualTerm(tk *Token) (inst *term) {
 	return &term{
-		tk:       *tk,
+		tk: *tk,
+		// class:    classOperator,
+		// kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priRelational,
@@ -202,13 +203,10 @@ func newGreaterEqualTerm(tk *Token) (inst *term) {
 }
 
 func evalGreaterEqual(ctx ExprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
+	if v, err = evalLess(ctx, self); err == nil {
-
+		b, _ := toBool(v)
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+		v = !b
-		return
 	}
-
-	v, err = lessThanOrEqual(self, rightValue, leftValue)
 	return
 }
 

operator-selector.go

@@ -4,7 +4,65 @@
 // operator-selector.go
 package expr
 
-//-------- selector term
+// //-------- export all term
+
+// func newSelectorTerm(tk *Token) (inst *term) {
+// 	return &term{
+// 		tk:       *tk,
+// 		children: make([]*term, 0, 3),
+// 		position: posMultifix,
+// 		priority: priSelector,
+// 		evalFunc: evalSelector,
+// 	}
+// }
+
+// func isSelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (selectedValue any, err error) {
+// 	caseData, _ := caseSel.(*selectorCase)
+// 	if caseData.filterList == nil {
+// 		selectedValue, err = caseData.caseExpr.eval(ctx, false)
+// 	} else {
+// 		filterList := caseData.filterList.children
+// 		if len(filterList) == 0 && exprValue == int64(caseIndex) {
+// 			selectedValue, err = caseData.caseExpr.eval(ctx, false)
+// 		} 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)
+// 					break
+// 				}
+// 			}
+// 		}
+// 	}
+// 	return
+// }
+
+// func evalSelector(ctx ExprContext, self *term) (v any, err error) {
+// 	var exprValue any
+// 	// var caseList []*term
+
+// 	if err = self.checkOperands(); err != nil {
+// 		return
+// 	}
+// 	exprTerm := self.children[0]
+// 	if exprValue, err = exprTerm.compute(ctx); err != nil {
+// 		return
+// 	}
+
+// 	caseList := self.children[1:]
+// 	for i, caseTerm := range caseList {
+// 		caseSel := caseTerm.value()
+// 		if v, err = isSelectorCase(ctx, exprValue, caseSel, i); err != nil || v != nil {
+// 			break
+// 		}
+// 	}
+// 	if err == nil && v == nil {
+// 		err = exprTerm.tk.Errorf("no case catches the value (%v) of the selection expression", exprValue)
+// 	}
+// 	return
+// }
+
+//-------- export all term
 
 func newSelectorTerm(tk *Token) (inst *term) {
 	return &term{
@@ -16,21 +74,18 @@ func newSelectorTerm(tk *Token) (inst *term) {
 	}
 }
 
-func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (match bool, selectedValue any, err error) {
+func isSelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (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
 				}
 			}
@@ -41,7 +96,7 @@ func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (ma
 
 func evalSelector(ctx ExprContext, self *term) (v any, err error) {
 	var exprValue any
-	var match bool
+	// var caseList []*term
 
 	if err = self.checkOperands(); err != nil {
 		return
@@ -55,11 +110,11 @@ func evalSelector(ctx ExprContext, self *term) (v any, err error) {
 	caseList, _ := caseListTerm.value().([]*term)
 	for i, caseTerm := range caseList {
 		caseSel := caseTerm.value()
-		if match, v, err = trySelectorCase(ctx, exprValue, caseSel, i); err != nil || match {
+		if v, err = isSelectorCase(ctx, exprValue, caseSel, i); err != nil || v != nil {
 			break
 		}
 	}
-	if err == nil && !match {
+	if err == nil && v == nil {
 		err = exprTerm.tk.Errorf("no case catches the value (%v) of the selection expression", exprValue)
 	}
 	return

operator-sign.go

@@ -35,14 +35,14 @@ func evalSign(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if IsFloat(rightValue) {
+	if isFloat(rightValue) {
 		if self.tk.Sym == SymChangeSign {
 			f, _ := rightValue.(float64)
 			v = -f
 		} else {
 			v = rightValue
 		}
-	} else if IsInteger(rightValue) {
+	} else if isInteger(rightValue) {
 		if self.tk.Sym == SymChangeSign {
 			i, _ := rightValue.(int64)
 			v = -i

operator-sum.go

@@ -28,41 +28,33 @@ func evalPlus(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if (IsString(leftValue) && isNumberString(rightValue)) || (IsString(rightValue) && isNumberString(leftValue)) {
+	if (isString(leftValue) && isNumberString(rightValue)) || (isString(rightValue) && isNumberString(leftValue)) {
 		v = fmt.Sprintf("%v%v", leftValue, rightValue)
-	} else if IsNumber(leftValue) && IsNumber(rightValue) {
+	} else if isNumber(leftValue) && isNumber(rightValue) {
-		if IsFloat(leftValue) || IsFloat(rightValue) {
+		if isFloat(leftValue) || isFloat(rightValue) {
 			v = numAsFloat(leftValue) + numAsFloat(rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			rightInt, _ := rightValue.(int64)
 			v = leftInt + rightInt
 		}
-	} else if IsList(leftValue) && IsList(rightValue) {
+	} else if isList(leftValue) || isList(rightValue) {
-		var leftList, rightList *ListType
+		var leftList, rightList []any
-		leftList, _ = leftValue.(*ListType)
+		var ok bool
-		rightList, _ = rightValue.(*ListType)
+		if leftList, ok = leftValue.([]any); !ok {
-
+			leftList = []any{leftValue}
-		sumList := make(ListType, 0, len(*leftList)+len(*rightList))
+		}
-		for _, item := range *leftList {
+		if rightList, ok = rightValue.([]any); !ok {
+			rightList = []any{rightValue}
+		}
+		sumList := make([]any, 0, len(leftList)+len(rightList))
+		for _, item := range leftList {
 			sumList = append(sumList, item)
 		}
-		for _, item := range *rightList {
+		for _, item := range rightList {
 			sumList = append(sumList, item)
 		}
-		v = &sumList
+		v = sumList
-	} else if (isFraction(leftValue) && IsNumber(rightValue)) || (isFraction(rightValue) && IsNumber(leftValue)) {
-		if IsFloat(leftValue) || IsFloat(rightValue) {
-			v = numAsFloat(leftValue) + numAsFloat(rightValue)
-		} else {
-			v, err = sumAnyFract(leftValue, rightValue)
-		}
-	} else if IsDict(leftValue) && IsDict(rightValue) {
-		leftDict, _ := leftValue.(*DictType)
-		rightDict, _ := rightValue.(*DictType)
-		c := leftDict.clone()
-		c.merge(rightDict)
-		v = c
 	} else {
 		err = self.errIncompatibleTypes(leftValue, rightValue)
 	}
@@ -88,26 +80,24 @@ func evalMinus(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+	if isNumber(leftValue) && isNumber(rightValue) {
-		if IsFloat(leftValue) || IsFloat(rightValue) {
+		if isFloat(leftValue) || isFloat(rightValue) {
 			v = numAsFloat(leftValue) - numAsFloat(rightValue)
-		} else if isFraction(leftValue) || isFraction(rightValue) {
-			v, err = subAnyFract(leftValue, rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			rightInt, _ := rightValue.(int64)
 			v = leftInt - rightInt
 		}
-	} else if IsList(leftValue) && IsList(rightValue) {
+	} else if isList(leftValue) && isList(rightValue) {
-		leftList, _ := leftValue.(*ListType)
+		leftList, _ := leftValue.([]any)
-		rightList, _ := rightValue.(*ListType)
+		rightList, _ := rightValue.([]any)
-		diffList := make(ListType, 0, len(*leftList)-len(*rightList))
+		diffList := make([]any, 0, len(leftList)-len(rightList))
-		for _, item := range *leftList {
+		for _, item := range leftList {
-			if slices.Index(*rightList, item) < 0 {
+			if slices.Index(rightList, item) < 0 {
 				diffList = append(diffList, item)
 			}
 		}
-		v = &diffList
+		v = diffList
 	} else {
 		err = self.errIncompatibleTypes(leftValue, rightValue)
 	}

parser.go

@@ -6,6 +6,7 @@ package expr
 
 import (
 	"errors"
+	"fmt"
 )
 
 //-------- parser
@@ -22,28 +23,34 @@ func NewParser(ctx ExprContext) (p *parser) {
 }
 
 func (self *parser) parseFuncCall(scanner *scanner, allowVarRef bool, tk *Token) (tree *term, err error) {
+	// name, _ := tk.Value.(string)
+	// funcObj := self.ctx.GetFuncInfo(name)
+	// if funcObj == nil {
+	// 	err = fmt.Errorf("unknown function %s()", name)
+	// 	return
+	// }
+	// maxArgs := funcObj.MaxArgs()
+	// if maxArgs < 0 {
+	// 	maxArgs = funcObj.MinArgs() + 10
+	// }
+	// args := make([]*term, 0, maxArgs)
 	args := make([]*term, 0, 10)
-	itemExpected := false
 	lastSym := SymUnknown
 	for lastSym != SymClosedRound && lastSym != SymEos {
 		var subTree *ast
-		if subTree, err = self.parseItem(scanner, allowVarRef, SymComma, SymClosedRound); err != nil {
+		if subTree, err = self.parseItem(scanner, allowVarRef, SymComma, SymClosedRound); err == nil {
+			if subTree.root != nil {
+				args = append(args, subTree.root)
+			}
+		} else {
 			break
 		}
-		prev := scanner.Previous()
-		if subTree.root != nil {
-			args = append(args, subTree.root)
-		} else if itemExpected {
-			err = prev.ErrorExpectedGot("function-param-value")
-			break
-		}
-
-		itemExpected = prev.Sym == SymComma
 		lastSym = scanner.Previous().Sym
 	}
 	if err == nil {
+		// TODO Check arguments
 		if lastSym != SymClosedRound {
-			err = errors.New("unterminated arguments list")
+			err = errors.New("unterminate arguments list")
 		} else {
 			tree = newFuncCallTerm(tk, args)
 		}
@@ -55,50 +62,30 @@ func (self *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 	// Example: "add = func(x,y) {x+y}
 	var body *ast
 	args := make([]*term, 0)
-	lastSym := SymUnknown
+	tk := scanner.Next()
-	defaultParamsStarted := false
+	for tk.Sym != SymClosedRound && tk.Sym != SymEos {
-	itemExpected := false
+		if tk.Sym == SymIdentifier {
-	tk := scanner.Previous()
+			t := newTerm(tk, nil)
-	for lastSym != SymClosedRound && lastSym != SymEos {
+			args = append(args, t)
-		tk = scanner.Next()
+		} else {
-		if tk.IsSymbol(SymIdentifier) {
+			err = tk.Errorf("invalid param %q, variable identifier expected", tk.source)
-			param := newTerm(tk)
-			args = append(args, param)
-			tk = scanner.Next()
-			if tk.Sym == SymEqual {
-				var paramExpr *ast
-				defaultParamsStarted = true
-				if paramExpr, err = self.parseItem(scanner, false, SymComma, SymClosedRound); err != nil {
-					break
-				}
-				param.forceChild(paramExpr.root)
-			} else if defaultParamsStarted {
-				err = tk.Errorf("can't mix default and non-default parameters")
-				break
-			}
-		} else if itemExpected {
-			prev := scanner.Previous()
-			err = prev.ErrorExpectedGot("function-param-spec")
 			break
 		}
-		lastSym = scanner.Previous().Sym
+		tk = scanner.Next()
-		itemExpected = lastSym == SymComma
 	}
-
+	if err == nil && tk.Sym != SymClosedRound {
-	if err == nil && lastSym != SymClosedRound {
+		err = tk.Errorf("unterminate function params list")
-		err = tk.ErrorExpectedGot(")")
 	}
 	if err == nil {
 		tk = scanner.Next()
-		if tk.IsSymbol(SymOpenBrace) {
+		if tk.Sym == SymOpenBrace {
 			body, err = self.parseGeneral(scanner, true, true, SymClosedBrace)
-		} else {
-			err = tk.ErrorExpectedGot("{")
 		}
 	}
 	if err == nil {
+		// TODO Check arguments
 		if scanner.Previous().Sym != SymClosedBrace {
-			err = scanner.Previous().ErrorExpectedGot("}")
+			err = scanner.Previous().Errorf("not properly terminated function body")
 		} else {
 			tk = scanner.makeValueToken(SymExpression, "", body)
 			tree = newFuncDefTerm(tk, args)
@@ -107,145 +94,26 @@ func (self *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 	return
 }
 
-func (self *parser) parseList(scanner *scanner, parsingIndeces bool, allowVarRef bool) (subtree *term, err error) {
+func (self *parser) parseList(scanner *scanner, allowVarRef bool) (subtree *term, err error) {
-	r, c := scanner.lastPos()
 	args := make([]*term, 0)
 	lastSym := SymUnknown
-	itemExpected := false
 	for lastSym != SymClosedSquare && lastSym != SymEos {
 		var subTree *ast
-		zeroRequired := scanner.current.Sym == SymColon
 		if subTree, err = self.parseItem(scanner, allowVarRef, SymComma, SymClosedSquare); err == nil {
-			root := subTree.root
-			if root != nil {
-				if !parsingIndeces && root.symbol() == SymColon {
-					err = root.Errorf("unexpected range expression")
-					break
-				}
-				args = append(args, root)
-				if parsingIndeces && root.symbol() == SymColon && zeroRequired { //len(root.children) == 0 {
-					if len(root.children) == 1 {
-						root.children = append(root.children, root.children[0])
-					} else if len(root.children) > 1 {
-						err = root.Errorf("invalid range specification")
-						break
-					}
-					zeroTk := NewValueToken(root.tk.row, root.tk.col, SymInteger, "0", int64(0))
-					zeroTerm := newTerm(zeroTk)
-					zeroTerm.setParent(root)
-					root.children[0] = zeroTerm
-				}
-			} else if itemExpected {
-				prev := scanner.Previous()
-				err = prev.ErrorExpectedGot("list-item")
-				break
-			}
-		} else {
-			break
-		}
-		lastSym = scanner.Previous().Sym
-		itemExpected = lastSym == SymComma
-	}
-	if err == nil {
-		if lastSym != SymClosedSquare {
-			err = scanner.Previous().ErrorExpectedGot("]")
-		} else {
-			subtree = newListTerm(r, c, args)
-		}
-	}
-	return
-}
-
-func (self *parser) parseIterDef(scanner *scanner, allowVarRef bool) (subtree *term, err error) {
-	tk := scanner.Previous()
-	args := make([]*term, 0)
-	lastSym := SymUnknown
-	itemExpected := false
-	for lastSym != SymClosedRound && lastSym != SymEos {
-		var subTree *ast
-		if subTree, err = self.parseItem(scanner, allowVarRef, SymComma, SymClosedRound); err == nil {
 			if subTree.root != nil {
 				args = append(args, subTree.root)
-			} else if itemExpected {
-				prev := scanner.Previous()
-				err = prev.ErrorExpectedGot("iterator-param")
-				break
 			}
 		} else {
 			break
 		}
 		lastSym = scanner.Previous().Sym
-		itemExpected = lastSym == SymComma
 	}
 	if err == nil {
-		if lastSym != SymClosedRound {
+		// TODO Check arguments
-			err = scanner.Previous().ErrorExpectedGot(")")
+		if lastSym != SymClosedSquare {
+			err = scanner.Previous().Errorf("unterminate items list")
 		} else {
-			subtree = newIteratorTerm(tk, args)
+			subtree = newListTerm(args)
-		}
-	}
-	return
-}
-
-func (self *parser) parseDictKey(scanner *scanner, allowVarRef bool) (key any, err error) {
-	tk := scanner.Next()
-	if tk.Sym == SymError {
-		err = tk.Error()
-		return
-	}
-	if tk.Sym == SymClosedBrace || tk.Sym == SymEos {
-		return
-	}
-	if tk.Sym == SymInteger || tk.Sym == SymString {
-		tkSep := scanner.Next()
-		if tkSep.Sym != SymColon {
-			err = tkSep.ErrorExpectedGot(":")
-		} else {
-			key = tk.Value
-		}
-	} else {
-		err = tk.ErrorExpectedGot("dictionary-key or }")
-	}
-	return
-}
-
-func (self *parser) parseDictionary(scanner *scanner, allowVarRef bool) (subtree *term, err error) {
-	args := make(map[any]*term, 0)
-	lastSym := SymUnknown
-	itemExpected := false
-	for lastSym != SymClosedBrace && lastSym != SymEos {
-		var subTree *ast
-		var key any
-		if key, err = self.parseDictKey(scanner, allowVarRef); err != nil {
-			break
-		} else if key == nil {
-			tk := scanner.Previous()
-			lastSym = tk.Sym
-			if itemExpected {
-				err = tk.ErrorExpectedGot("dictionary-key")
-			}
-			break
-		}
-		if subTree, err = self.parseItem(scanner, allowVarRef, SymComma, SymClosedBrace); err == nil {
-			if subTree.root != nil {
-				args[key] = subTree.root
-			} else if key != nil {
-				prev := scanner.Previous()
-				err = prev.ErrorExpectedGot("dictionary-value")
-				break
-			}
-		} else {
-			break
-		}
-		lastSym = scanner.Previous().Sym
-		itemExpected = lastSym == SymComma
-	}
-	if err == nil {
-		if lastSym != SymClosedBrace {
-			err = scanner.Previous().ErrorExpectedGot("}")
-		} else {
-			subtree = newDictTerm(args)
-			// subtree = newMapTerm(args)
 		}
 	}
 	return
@@ -262,14 +130,14 @@ func (self *parser) parseSelectorCase(scanner *scanner, allowVarRef bool, defaul
 			err = tk.Errorf("case list in default clause")
 			return
 		}
-		if filterList, err = self.parseList(scanner, false, allowVarRef); err != nil {
+		if filterList, err = self.parseList(scanner, allowVarRef); err != nil {
 			return
 		}
 		tk = scanner.Next()
 		startRow = tk.row
 		startCol = tk.col
 	} else if !defaultCase {
-		filterList = newListTerm(startRow, startCol, make([]*term, 0))
+		filterList = newListTerm(make([]*term, 0))
 	}
 
 	if tk.Sym == SymOpenBrace {
@@ -277,7 +145,7 @@ func (self *parser) parseSelectorCase(scanner *scanner, allowVarRef bool, defaul
 			return
 		}
 	} else {
-		err = tk.ErrorExpectedGot("{")
+		err = tk.Errorf("selector-case expected, got %q", tk.source)
 	}
 
 	if err == nil {
@@ -320,21 +188,13 @@ func (self *parser) Parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, e
 	return self.parseGeneral(scanner, true, false, termSymbols...)
 }
 
-func couldBeACollection(t *term) bool {
-	var sym = SymUnknown
-	if t != nil {
-		sym = t.symbol()
-	}
-	return sym == SymList || sym == SymString || sym == SymDict || sym == SymExpression || sym == SymVariable
-}
-
 func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef bool, termSymbols ...Symbol) (tree *ast, err error) {
 	var selectorTerm *term = nil
 	var currentTerm *term = nil
 	var tk *Token
 	tree = NewAst()
 	firstToken := true
-	// lastSym := SymUnknown
+	lastSym := SymUnknown
 	for tk = scanner.Next(); err == nil && tk != nil && !tk.IsTerm(termSymbols); tk = scanner.Next() {
 		if tk.Sym == SymComment {
 			continue
@@ -344,8 +204,6 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 			if allowForest {
 				tree.ToForest()
 				firstToken = true
-				currentTerm = nil
-				selectorTerm = nil
 				continue
 			} else {
 				err = tk.Errorf(`unexpected token %q, expected ",", "]", or ")"`, tk.source)
@@ -368,7 +226,7 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 			var subTree *ast
 			if subTree, err = self.parseGeneral(scanner, false, allowVarRef, SymClosedRound); err == nil {
 				subTree.root.priority = priValue
-				err = tree.addTerm(newExprTerm(subTree.root))
+				err = tree.addTerm(subTree.root)
 				currentTerm = subTree.root
 			}
 		case SymFuncCall:
@@ -379,45 +237,20 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 			}
 		case SymOpenSquare:
 			var listTerm *term
-			parsingIndeces := couldBeACollection(currentTerm)
+			if listTerm, err = self.parseList(scanner, allowVarRef); err == nil {
-			if listTerm, err = self.parseList(scanner, parsingIndeces, allowVarRef); err == nil {
+				err = tree.addTerm(listTerm)
-				if parsingIndeces {
-					indexTk := NewToken(listTerm.tk.row, listTerm.tk.col, SymIndex, listTerm.source())
-					indexTerm := newTerm(indexTk)
-					if err = tree.addTerm(indexTerm); err == nil {
-						err = tree.addTerm(listTerm)
-					}
-				} else {
-					err = tree.addTerm(listTerm)
-				}
 				currentTerm = listTerm
 			}
-		case SymOpenBrace:
-			if currentTerm != nil && currentTerm.symbol() == SymColon {
-				err = currentTerm.Errorf(`selector-case outside of a selector context`)
-			} else {
-				var mapTerm *term
-				if mapTerm, err = self.parseDictionary(scanner, allowVarRef); err == nil {
-					err = tree.addTerm(mapTerm)
-					currentTerm = mapTerm
-				}
-			}
 		case SymEqual:
-			// if err = checkPrevSymbol(lastSym, SymIdentifier, tk); err == nil {
+			if err = checkPrevSymbol(lastSym, SymIdentifier, tk); err == nil {
-			currentTerm, err = tree.addToken2(tk)
+				currentTerm, err = tree.addToken2(tk)
-			// }
+			}
 		case SymFuncDef:
 			var funcDefTerm *term
 			if funcDefTerm, err = self.parseFuncDef(scanner); err == nil {
 				err = tree.addTerm(funcDefTerm)
 				currentTerm = funcDefTerm
 			}
-		case SymDollarRound:
-			var iterDefTerm *term
-			if iterDefTerm, err = self.parseIterDef(scanner, allowVarRef); err == nil {
-				err = tree.addTerm(iterDefTerm)
-				currentTerm = iterDefTerm
-			}
 		case SymIdentifier:
 			if tk.source[0] == '@' && !allowVarRef {
 				err = tk.Errorf("variable references are not allowed in top level expressions: %q", tk.source)
@@ -430,16 +263,14 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 			}
 		case SymColon, SymDoubleColon:
 			var caseTerm *term
-			if selectorTerm != nil {
+			if selectorTerm == nil {
-				if caseTerm, err = self.parseSelectorCase(scanner, allowVarRef, tk.Sym == SymDoubleColon); err == nil {
+				err = tk.Errorf("selector-case outside of a selector context")
-					addSelectorCase(selectorTerm, caseTerm)
+			} else if caseTerm, err = self.parseSelectorCase(scanner, allowVarRef, tk.Sym == SymDoubleColon); err == nil {
-					currentTerm = caseTerm
+				addSelectorCase(selectorTerm, caseTerm)
-					if tk.Sym == SymDoubleColon {
+				currentTerm = caseTerm
-						selectorTerm = nil
+				if tk.Sym == SymDoubleColon {
-					}
+					selectorTerm = nil
 				}
-			} else {
-				currentTerm, err = tree.addToken2(tk)
 			}
 		default:
 			currentTerm, err = tree.addToken2(tk)
@@ -449,7 +280,7 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 			selectorTerm = nil
 
 		}
-		// lastSym = tk.Sym
+		lastSym = tk.Sym
 	}
 	if err == nil {
 		err = tk.Error()
@@ -457,9 +288,9 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 	return
 }
 
-// func checkPrevSymbol(lastSym, wantedSym Symbol, tk *Token) (err error) {
+func checkPrevSymbol(lastSym, wantedSym Symbol, tk *Token) (err error) {
-// 	if lastSym != wantedSym {
+	if lastSym != wantedSym {
-// 		err = fmt.Errorf(`assign operator (%q) must be preceded by a variable`, tk.source)
+		err = fmt.Errorf(`assign operator (%q) must be preceded by a variable`, tk.source)
-// 	}
+	}
-// 	return
+	return
-// }
+}

parser_test.go

@@ -0,0 +1,317 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// parser_test.go
+package expr
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestParser(t *testing.T) {
+	type inputType struct {
+		source     string
+		wantResult any
+		wantErr    error
+	}
+
+	inputs := []inputType{
+		/*   1 */ {`1+/*5*/2`, int64(3), nil},
+		/*   2 */ {`3 == 4`, false, nil},
+		/*   3 */ {`3 != 4`, true, nil},
+		/*   4 */ {`4 == (3-1)*(10/5)`, true, nil},
+		/*   5 */ {`3 <= 4`, true, nil},
+		/*   6 */ {`3 < 4`, true, nil},
+		/*   7 */ {`4 < 3`, false, nil},
+		/*   8 */ {`1+5 < 4`, false, nil},
+		/*   9 */ {`3 > 4`, false, nil},
+		/*  10 */ {`4 >= 4`, true, nil},
+		/*  11 */ {`4 > 3`, true, nil},
+		/*  12 */ {`1+5 > 4`, true, nil},
+		/*  13 */ {`true`, true, nil},
+		/*  14 */ {`not true`, false, nil},
+		/*  15 */ {`true and false`, false, nil},
+		/*  16 */ {`true or false`, true, nil},
+		/*  17 */ {`"uno" + "due"`, `unodue`, nil},
+		/*  18 */ {`"uno" + 2`, `uno2`, nil},
+		/*  19 */ {`"uno" + (2+1)`, `uno3`, nil},
+		/*  20 */ {`"uno" * (2+1)`, `unounouno`, nil},
+		/*  21 */ {"1", int64(1), nil},
+		/*  22 */ {"1.5", float64(1.5), nil},
+		/*  23 */ {"1.5*2", float64(3.0), nil},
+		/*  24 */ {"+1", int64(1), nil},
+		/*  25 */ {"-1", int64(-1), nil},
+		/*  26 */ {"435 + 105 * 2 - 1", int64(644), nil},
+		/*  27 */ {"200 / 2 - 1", int64(99), nil},
+		/*  28 */ {"(1+1)", int64(2), nil},
+		/*  29 */ {"-(1+1)", int64(-2), nil},
+		/*  30 */ {"-(-2+1)", int64(1), nil},
+		/*  31 */ {"(1+1)*5", int64(10), nil},
+		/*  32 */ {"200 / (1+1) - 1", int64(99), nil},
+		/*  33 */ {`add(1,2,3)`, int64(6), nil},
+		/*  34 */ {`mulX(1,2,3)`, nil, errors.New(`unknown function mulX()`)},
+		/*  35 */ {`add(1+4,3+2,5*(3-2))`, int64(15), nil},
+		/*  36 */ {`add(add(1+4),3+2,5*(3-2))`, int64(15), nil},
+		/*  37 */ {`add(add(1,4),/*3+2,*/5*(3-2))`, int64(10), nil},
+		/*  38 */ {`1+(1+(1+(1)+1)+1)+1`, int64(7), nil},
+		/*  39 */ {`(((1)))`, int64(1), nil},
+		/*  40 */ {`"uno_" + var2`, `uno_abc`, nil},
+		/*  41 */ {`0 || 0.0 && "hello"`, false, nil},
+		/*  42 */ {`"s" + true`, nil, errors.New(`[1:6] left operand 's' [string] and right operand 'true' [bool] are not compatible with operator "+"`)},
+		/*  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 not nil operands, got 1`)},
+		/*  46 */ {"", nil, errors.New(`empty expression`)},
+		/*  47 */ {"4!", int64(24), nil},
+		/*  48 */ {"(-4)!", nil, errors.New(`factorial of a negative integer (-4) is not allowed`)},
+		/*  49 */ {"-4!", int64(-24), nil},
+		/*  50 */ {"1.5 < 7", true, nil},
+		/*  51 */ {"1.5 > 7", false, nil},
+		/*  52 */ {"1.5 <= 7", true, nil},
+		/*  53 */ {"1.5 >= 7", false, nil},
+		/*  54 */ {"1.5 != 7", true, nil},
+		/*  55 */ {"1.5 == 7", false, nil},
+		/*  56 */ {`"1.5" < "7"`, true, nil},
+		/*  57 */ {`"1.5" > "7"`, false, nil},
+		/*  58 */ {`"1.5" == "7"`, false, nil},
+		/*  59 */ {`"1.5" != "7"`, true, nil},
+		/*  60 */ {"1.5 < ", nil, errors.New(`[1:6] infix operator "<" requires two not nil operands, got 1`)},
+		/*  61 */ {"1.5 > ", nil, errors.New(`[1:6] infix operator ">" requires two not nil operands, got 1`)},
+		/*  62 */ {"1.5 <= ", nil, errors.New(`[1:6] infix operator "<=" requires two not nil operands, got 1`)},
+		/*  63 */ {"1.5 >= ", nil, errors.New(`[1:6] infix operator ">=" requires two not nil operands, got 1`)},
+		/*  64 */ {"1.5 != ", nil, errors.New(`[1:6] infix operator "!=" requires two not nil operands, got 1`)},
+		/*  65 */ {"1.5 == ", nil, errors.New(`[1:6] infix operator "==" requires two not nil operands, got 1`)},
+		/*  66 */ {`"1.5" < `, nil, errors.New(`[1:8] infix operator "<" requires two not nil operands, got 1`)},
+		/*  67 */ {`"1.5" > `, nil, errors.New(`[1:8] infix operator ">" requires two not nil operands, got 1`)},
+		/*  68 */ {`"1.5" == `, nil, errors.New(`[1:8] infix operator "==" requires two not nil operands, got 1`)},
+		/*  69 */ {`"1.5" != `, nil, errors.New(`[1:8] infix operator "!=" requires two not nil operands, got 1`)},
+		/*  70 */ {"+1.5", float64(1.5), nil},
+		/*  71 */ {"+", nil, errors.New(`[1:2] prefix operator "+" requires one not nil operand`)},
+		/*  72 */ {"4 / 0", nil, errors.New(`division by zero`)},
+		/*  73 */ {"4.0 / 0", nil, errors.New(`division by zero`)},
+		/*  74 */ {"4.0 / \n2", float64(2.0), nil},
+		/*  75 */ {`123`, int64(123), nil},
+		/*  76 */ {`1.`, float64(1.0), nil},
+		/*  77 */ {`1.E-2`, float64(0.01), nil},
+		/*  78 */ {`1E2`, float64(100), nil},
+		/*  79 */ {`1 / 2`, int64(0), nil},
+		/*  80 */ {`1.0 / 2`, float64(0.5), nil},
+		/*  81 */ {`1 ./ 2`, float64(0.5), nil},
+		/*  82 */ {`5 % 2`, int64(1), nil},
+		/*  83 */ {`5 % (-2)`, int64(1), nil},
+		/*  84 */ {`-5 % 2`, int64(-1), nil},
+		/*  85 */ {`5 % 2.0`, nil, errors.New(`[1:4] left operand '5' [int64] and right operand '2' [float64] are not compatible with operator "%"`)},
+		/*  86 */ {`"a" < "b" AND NOT (2 < 1)`, true, nil},
+		/*  87 */ {`"a" < "b" AND NOT (2 == 1)`, true, nil},
+		/*  88 */ {`"a" < "b" AND ~ 2 == 1`, true, nil},
+		/*  89 */ {`~ 2 > 1`, false, nil},
+		/*  90 */ {`~ true && true`, false, nil},
+		/*  91 */ {`~ false || true`, true, nil},
+		/*  92 */ {`false but true`, true, nil},
+		/*  93 */ {`2+3 but 5*2`, int64(10), nil},
+		/*  94 */ {`add(1,2) but var2`, "abc", nil},
+		/*  95 */ {`x=2`, int64(2), nil},
+		/*  96 */ {`x=2 but x*10`, int64(20), nil},
+		/*  97 */ {`false and true`, false, nil},
+		/*  98 */ {`false and (x==2)`, false, nil},
+		/*  99 */ {`false and (x=2 but x==2) or x==2`, nil, errors.New(`undefined variable "x"`)},
+		/* 100 */ {`false or true`, true, nil},
+		/* 101 */ {`false or (x==2)`, nil, errors.New(`undefined variable "x"`)},
+		/* 102 */ {`a=5; a`, int64(5), nil},
+		/* 103 */ {`a=5; b=2; add(a, b*3)`, int64(11), nil},
+		/* 104 */ {`2=5`, nil, errors.New(`assign operator ("=") must be preceded by a variable`)},
+		/* 105 */ {`2+a=5`, nil, errors.New(`[1:3] left operand of "=" must be a variable`)},
+		/* 106 */ {`2+(a=5)`, int64(7), nil},
+		/* 107 */ {`two=func(){2}; two()`, int64(2), nil},
+		/* 108 */ {`double=func(x) {2*x}; (double(3))`, int64(6), nil},
+		/* 109 */ {`double=func(x){2*x}; double(3)`, int64(6), nil},
+		/* 110 */ {`double=func(x){2*x}; a=5; double(3+a) + 1`, int64(17), nil},
+		/* 111 */ {`double=func(x){2*x}; a=5; two=func() {2}; (double(3+a) + 1) * two()`, int64(34), nil},
+		/* 112 */ {`import("./test-funcs.expr"); (double(3+a) + 1) * two()`, int64(34), nil},
+		/* 113 */ {`import("test-funcs.expr"); (double(3+a) + 1) * two()`, int64(34), nil},
+		/* 114 */ {`x ?? "default"`, "default", nil},
+		/* 115 */ {`x="hello"; x ?? "default"`, "hello", nil},
+		/* 116 */ {`x ?? func(){}"`, nil, errors.New(`[1:15] the right operand of a coalescing operation cannot be a function definition`)},
+		/* 117 */ {`x ?= "default"; x`, "default", nil},
+		/* 118 */ {`x="hello"; x ?= "default"; x`, "hello", nil},
+		/* 119 */ {`@x="hello"; @x`, nil, errors.New(`[1:3] variable references are not allowed in top level expressions: "@x"`)},
+		/* 120 */ {`f=func(){@x="hello"}; f(); x`, "hello", nil},
+		/* 121 */ {`f=func(@y){@y=@y+1}; f(2); y`, int64(3), nil},
+		/* 122 */ {`f=func(@y){g=func(){@x=5}; @y=@y+g()}; f(2); y+x`, nil, errors.New(`undefined variable "x"`)},
+		/* 123 */ {`f=func(@y){g=func(){@x=5}; @z=g(); @y=@y+@z}; f(2); y+z`, int64(12), nil},
+		/* 124 */ {`f=func(@y){g=func(){@x=5}; g(); @z=x; @y=@y+@z}; f(2); y+z`, int64(12), nil},
+		/* 125 */ {`f=func(@y){g=func(){@x=5}; g(); @z=x; @x=@y+@z}; f(2); y+x`, int64(9), nil},
+		/* 126 */ {`include("./test-funcs.expr"); six()`, int64(6), nil},
+		/* 127 */ {`import("./sample-export-all.expr"); six()`, int64(6), nil},
+		/* 128 */ {`1 ? {"a"} : {"b"}`, "b", nil},
+		/* 129 */ {`10 ? {"a"} : {"b"} :: {"c"}`, "c", nil},
+		/* 130 */ {`10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}`, "b", nil},
+		/* 131 */ {`10 ? {"a"} :[true, 2+8] {"b"} ::[10] {"c"}`, nil, errors.New(`[1:34] case list in default clause`)},
+		/* 132 */ {`10 ? {"a"} :[10] {x="b" but x} :: {"c"}`, "b", nil},
+		/* 133 */ {`10 ? {"a"} :[10] {x="b"; x} :: {"c"}`, "b", nil},
+		/* 134 */ {`10 ? {"a"} : {"b"}`, nil, errors.New(`[1:3] no case catches the value (10) of the selection expression`)},
+		/* 135 */ {`10 ? {"a"} :: {"b"} : {"c"}`, nil, errors.New(`[1:22] selector-case outside of a selector context`)},
+		/* 136 */ {`1 ? {"a"} : {"b"} ? ["a"] {"A"} :["b"] {"B"}`, "B", nil},
+		/* 137 */ {`2 + 1 ? {"a"} : {"b"} * 3`, "2bbb", nil},
+	}
+	check_env_expr_path := 113
+
+	succeeded := 0
+	failed := 0
+
+	// inputs1 := []inputType{
+	// 	{`10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}`, "b", nil},
+	// }
+
+	for i, input := range inputs {
+		var expr Expr
+		var gotResult any
+		var gotErr error
+
+		ctx := NewSimpleFuncStore()
+		ctx.SetVar("var1", int64(123))
+		ctx.SetVar("var2", "abc")
+		ImportMathFuncs(ctx)
+		ImportImportFuncs(ctx)
+		parser := NewParser(ctx)
+
+		logTest(t, i+1, input.source, input.wantResult, input.wantErr)
+
+		r := strings.NewReader(input.source)
+		scanner := NewScanner(r, DefaultTranslations())
+
+		good := true
+		if expr, gotErr = parser.Parse(scanner); gotErr == nil {
+			gotResult, gotErr = expr.Eval(ctx)
+		}
+
+		if gotResult != input.wantResult {
+			t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
+			good = false
+		}
+
+		if gotErr != input.wantErr {
+			if input.wantErr == nil || gotErr == nil || (gotErr.Error() != input.wantErr.Error()) {
+				t.Errorf("%d: %q -> err = <%v>, want <%v>", i+1, input.source, gotErr, input.wantErr)
+				good = false
+			}
+		}
+
+		if good {
+			succeeded++
+		} else {
+			failed++
+			if i+1 == check_env_expr_path {
+				t.Logf(`NOTICE: Test nr %d requires EXPR_PATH="."`, check_env_expr_path)
+			}
+		}
+	}
+	t.Log(fmt.Sprintf("test count: %d, succeeded count: %d, failed count: %d", len(inputs), succeeded, failed))
+}
+
+func TestListParser(t *testing.T) {
+	type inputType struct {
+		source     string
+		wantResult any
+		wantErr    error
+	}
+
+	// inputs1 := []inputType{
+	// 	{`add(1,2,3)`, int64(6), nil},
+	// }
+
+	inputs := []inputType{
+		/*  1 */ {`[]`, []any{}, nil},
+		/*  2 */ {`[1,2,3]`, []any{int64(1), int64(2), int64(3)}, nil},
+		/*  3 */ {`[1,2,"hello"]`, []any{int64(1), int64(2), "hello"}, nil},
+		/*  4 */ {`[1+2, not true, "hello"]`, []any{int64(3), false, "hello"}, nil},
+		/*  5 */ {`[1,2]+[3]`, []any{int64(1), int64(2), int64(3)}, nil},
+		/*  6 */ {`[1,4,3,2]-[3]`, []any{int64(1), int64(4), int64(2)}, nil},
+		/*  7 */ {`add([1,4,3,2])`, int64(10), nil},
+		/*  8 */ {`add([1,[2,2],3,2])`, int64(10), nil},
+		/*  9 */ {`mul([1,4,3.0,2])`, float64(24.0), nil},
+		/* 10 */ {`add([1,"hello"])`, nil, errors.New(`add(): param nr 2 has wrong type string, number expected`)},
+		/* 11 */ {`[a=1,b=2,c=3] but a+b+c`, int64(6), nil},
+		// /*  8 */ {`[int(x)|x=csv("test.csv",1,all(),1)]`, []any{int64(10), int64(40), int64(20)}, nil},
+		// /*  9 */ {`sum(@[int(x)|x=csv("test.csv",1,all(),1)])`, []any{int64(10), int64(40), int64(20)}, nil},
+	}
+
+	succeeded := 0
+	failed := 0
+
+	for i, input := range inputs {
+		var expr *ast
+		var gotResult any
+		var gotErr error
+
+		ctx := NewSimpleFuncStore()
+		ctx.SetVar("var1", int64(123))
+		ctx.SetVar("var2", "abc")
+		ImportMathFuncs(ctx)
+		parser := NewParser(ctx)
+
+		logTest(t, i+1, input.source, input.wantResult, input.wantErr)
+
+		r := strings.NewReader(input.source)
+		scanner := NewScanner(r, DefaultTranslations())
+
+		good := true
+		if expr, gotErr = parser.Parse(scanner); gotErr == nil {
+			gotResult, gotErr = expr.Eval(ctx)
+		}
+
+		if (gotResult == nil && input.wantResult != nil) || (gotResult != nil && input.wantResult == nil) {
+			t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
+			good = false
+		}
+
+		if gotList, okGot := gotResult.([]any); okGot {
+			if wantList, okWant := input.wantResult.([]any); okWant {
+				if (gotList == nil && wantList != nil) || (gotList != nil && wantList == nil) {
+					t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
+					good = false
+				} else {
+					equal := len(gotList) == len(wantList)
+					if equal {
+						for i, gotItem := range gotList {
+							wantItem := wantList[i]
+							equal = gotItem == wantItem
+							if !equal {
+								break
+							}
+						}
+					}
+					if !equal {
+						t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
+						good = false
+					}
+				}
+			}
+		}
+
+		if gotErr != input.wantErr {
+			if input.wantErr == nil || gotErr == nil || (gotErr.Error() != input.wantErr.Error()) {
+				t.Errorf("%d: %q  -> err = <%v>, want <%v>", i+1, input.source, gotErr, input.wantErr)
+				good = false
+			}
+		}
+
+		if good {
+			succeeded++
+		} else {
+			failed++
+		}
+	}
+	t.Log(fmt.Sprintf("test count: %d, succeeded count: %d, failed count: %d", len(inputs), succeeded, failed))
+}
+
+func logTest(t *testing.T, n int, source string, wantResult any, wantErr error) {
+	if wantErr == nil {
+		t.Log(fmt.Sprintf("[+]Test nr %3d -- %q  --> %v", n, source, wantResult))
+	} else {
+		t.Log(fmt.Sprintf("[-]Test nr %3d -- %q  --> %v", n, source, wantErr))
+	}
+}

scanner.go

@@ -74,14 +74,6 @@ func (self *scanner) unreadChar() (err error) {
 	return
 }
 
-func (self *scanner) lastPos() (r, c int) {
-	if self.prev != nil {
-		r = self.prev.row
-		c = self.prev.col
-	}
-	return
-}
-
 func (self *scanner) Previous() *Token {
 	return self.prev
 }
@@ -94,14 +86,13 @@ func (self *scanner) Next() (tk *Token) {
 }
 
 func (self *scanner) fetchNextToken() (tk *Token) {
-	var ch byte
 	if err := self.skipBlanks(); err != nil {
 		return self.makeErrorToken(err)
 	}
 
 	escape := false
 	for {
-		ch, _ = self.readChar()
+		ch, _ := self.readChar()
 		switch ch {
 		case '+':
 			if next, _ := self.peek(); next == '+' {
@@ -152,8 +143,6 @@ func (self *scanner) fetchNextToken() (tk *Token) {
 			}
 		case ',':
 			tk = self.makeToken(SymComma, ch)
-		case '^':
-			tk = self.makeToken(SymCaret, ch)
 		case ':':
 			if next, _ := self.peek(); next == ':' {
 				tk = self.moveOn(SymDoubleColon, ch, next)
@@ -168,12 +157,6 @@ func (self *scanner) fetchNextToken() (tk *Token) {
 			//} else if next == '/' {
 			if next, _ := self.peek(); next == '/' {
 				tk = self.moveOn(SymDotSlash, ch, next)
-			} else if next == '.' {
-				if next1, _ := self.peek(); next1 == '.' {
-					tk = self.moveOn(SymTripleDot, ch, next, next1)
-				} else {
-					tk = self.moveOn(SymDoubleDot, ch, next)
-				}
 			} else {
 				tk = self.makeToken(SymDot, ch)
 			}
@@ -253,20 +236,9 @@ func (self *scanner) fetchNextToken() (tk *Token) {
 				tk = self.makeToken(SymGreater, ch)
 			}
 		case '$':
-			if next, _ := self.peek(); next == '(' {
+			tk = self.makeToken(SymDollar, ch)
-				tk = self.moveOn(SymDollarRound, ch, next)
-				tk.source += ")"
-			} else if next == '$' {
-				tk = self.moveOn(SymDoubleDollar, ch, next)
-			} else {
-				tk = self.makeToken(SymDollar, ch)
-			}
 		case '(':
-			if next, _ := self.peek(); next == ')' {
+			tk = self.makeToken(SymOpenRound, ch)
-				tk = self.moveOn(SymOpenClosedRound, ch, next)
-			} else {
-				tk = self.makeToken(SymOpenRound, ch)
-			}
 		case ')':
 			tk = self.makeToken(SymClosedRound, ch)
 		case '[':
@@ -299,9 +271,6 @@ func (self *scanner) fetchNextToken() (tk *Token) {
 			break
 		}
 	}
-	if tk == nil {
-		tk = NewErrorToken(self.row, self.column, fmt.Errorf("unknown symbol '%c'", ch))
-	}
 	return
 }
 
@@ -393,37 +362,20 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
 				}
 			}
 		}
-		if err == nil {
+		if err == nil && (ch == 'e' || ch == 'E') {
-			if ch == 'e' || ch == 'E' {
+			sym = SymFloat
-				sym = SymFloat
+			sb.WriteByte(ch)
-				sb.WriteByte(ch)
+			if ch, err = self.readChar(); err == nil {
-				if ch, err = self.readChar(); err == nil {
+				if ch == '+' || ch == '-' {
-					if ch == '+' || ch == '-' {
-						sb.WriteByte(ch)
-						ch, err = self.readChar()
-					}
-					if ch >= '0' && ch <= '9' {
-						for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = self.readChar() {
-							sb.WriteByte(ch)
-						}
-					} else {
-						err = fmt.Errorf("[%d:%d] expected integer exponent, got %c", self.row, self.column, ch)
-					}
-				}
-			} else if ch == '(' {
-				sym = SymFraction
-				sb.WriteByte(ch)
-				ch, err = self.readChar()
-				for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = self.readChar() {
 					sb.WriteByte(ch)
+					ch, err = self.readChar()
 				}
-				if err == nil {
+				if ch >= '0' && ch <= '9' {
-					if ch != ')' {
+					for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = self.readChar() {
-						err = fmt.Errorf("[%d:%d] expected ')', got '%c'", self.row, self.column, ch)
-					} else {
 						sb.WriteByte(ch)
-						_, err = self.readChar()
 					}
+				} else {
+					err = errors.New("expected integer exponent")
 				}
 			}
 		}
@@ -437,8 +389,6 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
 		txt := sb.String()
 		if sym == SymFloat {
 			value, err = strconv.ParseFloat(txt, 64)
-		} else if sym == SymFraction {
-			value, err = makeGeneratingFraction(txt)
 		} else {
 			value, err = strconv.ParseInt(txt, numBase, 64)
 		}

scanner_test.go

@@ -1,13 +1,12 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// t_scanner_test.go
+// scanner_test.go
 package expr
 
 import (
 	"errors"
 	"fmt"
-	"reflect"
 	"strings"
 	"testing"
 )
@@ -37,7 +36,7 @@ func TestScanner(t *testing.T) {
 		/* 14 */ {`:`, SymColon, nil, nil},
 		/* 15 */ {`;`, SymSemiColon, nil, nil},
 		/* 16 */ {`.`, SymDot, nil, nil},
-		/* 17 */ {`0.5`, SymFloat, float64(0.5), nil},
+		/* 17 */ {`.5`, SymFloat, float64(0.5), nil},
 		/* 18 */ {`\\`, SymBackSlash, nil, nil},
 		/* 19 */ {"`", SymBackTick, nil, nil},
 		/* 20 */ {"?", SymQuestion, nil, nil},
@@ -56,18 +55,15 @@ func TestScanner(t *testing.T) {
 		/* 33 */ {`(`, SymOpenRound, nil, nil},
 		/* 34 */ {`)`, SymClosedRound, nil, nil},
 		/* 35 */ {`1E+2`, SymFloat, float64(100), nil},
-		/* 36 */ {`1E+x`, SymError, errors.New("[1:5] expected integer exponent, got x"), nil},
+		/* 36 */ {`1E+x`, SymError, errors.New("expected integer exponent"), nil},
 		/* 37 */ {`$`, SymDollar, nil, nil},
 		/* 38 */ {`\`, SymError, errors.New("incomplete escape sequence"), nil},
 		/* 39 */ {`"string"`, SymString, "string", nil},
-		/* 40 */ {`identifier`, SymIdentifier, "identifier", nil},
+		/* 39 */ {`identifier`, SymIdentifier, "identifier", nil},
-		/* 41 */ {`1.2(3)`, SymFraction, newFraction(37, 30), nil},
 	}
 
 	for i, input := range inputs {
-		// if i != 40 {
+
-		// 	continue
-		// }
 		if input.wantErr == nil {
 			t.Log(fmt.Sprintf("[+]Test nr %2d -- %q", i+1, input.source))
 		} else {
@@ -78,9 +74,8 @@ func TestScanner(t *testing.T) {
 		scanner := NewScanner(r, nil)
 
 		if tk := scanner.Next(); tk == nil {
-			t.Errorf("%d: %q -> got = (nil), want %v (value %v [%T])", i+1, input.source, input.wantSym, input.wantValue, input.wantValue)
+			t.Errorf("%d: %q -> got = (nil), want %v (value %v [%T)", i+1, input.source, input.wantSym, input.wantValue, input.wantValue)
-			// } else if tk.Sym != input.wantSym || tk.Value != input.wantValue {
+		} else if tk.Sym != input.wantSym || tk.Value != input.wantValue {
-		} else if tk.Sym != input.wantSym || !reflect.DeepEqual(tk.Value, input.wantValue) {
 			if tk.Sym == SymError && input.wantSym == tk.Sym {
 				if tkErr, tkOk := tk.Value.(error); tkOk {
 					if inputErr, inputOk := input.wantValue.(error); inputOk {
@@ -91,7 +86,7 @@ func TestScanner(t *testing.T) {
 					}
 				}
 			} else {
-				t.Errorf("%d: %q -> got = %v (value=%v [%T]), want %v (value=%v [%T])", i+1,
+				t.Errorf("%d: %q -> got = %v (value=%v [%T), want %v (value=%v [%T)", i+1,
 					input.source, tk.Sym, tk.Value, tk.Value, input.wantSym, input.wantValue, input.wantValue)
 			}
 		}

simple-func-store.go

@@ -0,0 +1,82 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// simple-func-store.go
+package expr
+
+import "fmt"
+
+type SimpleFuncStore struct {
+	SimpleVarStore
+	funcStore map[string]*funcInfo
+}
+
+type funcInfo struct {
+	name    string
+	minArgs int
+	maxArgs int
+	functor Functor
+}
+
+func (info *funcInfo) Name() string {
+	return info.name
+}
+
+func (info *funcInfo) MinArgs() int {
+	return info.minArgs
+}
+
+func (info *funcInfo) MaxArgs() int {
+	return info.maxArgs
+}
+
+func (info *funcInfo) Functor() Functor {
+	return info.functor
+}
+
+func NewSimpleFuncStore() *SimpleFuncStore {
+	return &SimpleFuncStore{
+		SimpleVarStore: SimpleVarStore{varStore: make(map[string]any)},
+		funcStore:      make(map[string]*funcInfo),
+	}
+}
+
+func (ctx *SimpleFuncStore) Clone() ExprContext {
+	return &SimpleFuncStore{
+		SimpleVarStore: SimpleVarStore{varStore: CloneMap(ctx.varStore)},
+		funcStore:      CloneMap(ctx.funcStore),
+	}
+}
+
+func (ctx *SimpleFuncStore) GetFuncInfo(name string) (info ExprFunc) {
+	info, _ = ctx.funcStore[name]
+	return
+}
+
+func (ctx *SimpleFuncStore) RegisterFunc(name string, functor Functor, minArgs, maxArgs int) {
+	ctx.funcStore[name] = &funcInfo{name: name, minArgs: minArgs, maxArgs: maxArgs, functor: functor}
+}
+
+func (ctx *SimpleFuncStore) EnumFuncs(acceptor func(name string) (accept bool)) (funcNames []string) {
+	funcNames = make([]string, 0)
+	for name := range ctx.funcStore {
+		if acceptor != nil {
+			if acceptor(name) {
+				funcNames = append(funcNames, name)
+			}
+		} else {
+			funcNames = append(funcNames, name)
+		}
+	}
+	return
+}
+
+func (ctx *SimpleFuncStore) Call(name string, args []any) (result any, err error) {
+	if info, exists := ctx.funcStore[name]; exists {
+		functor := info.functor
+		result, err = functor.Invoke(ctx, name, args)
+	} else {
+		err = fmt.Errorf("unknown function %s()", name)
+	}
+	return
+}

simple-store.go

@@ -1,182 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// simple-store.go
-package expr
-
-import (
-	"fmt"
-	"slices"
-	"strings"
-)
-
-type SimpleStore struct {
-	varStore  map[string]any
-	funcStore map[string]ExprFunc
-}
-
-func NewSimpleStore() *SimpleStore {
-	ctx := &SimpleStore{
-		varStore:  make(map[string]any),
-		funcStore: make(map[string]ExprFunc),
-	}
-	return ctx
-}
-
-func filterRefName(name string) bool  { return name[0] != '@' }
-func filterPrivName(name string) bool { return name[0] != '_' }
-
-func (ctx *SimpleStore) Clone() ExprContext {
-	return &SimpleStore{
-		varStore:  CloneFilteredMap(ctx.varStore, filterRefName),
-		funcStore: CloneFilteredMap(ctx.funcStore, filterRefName),
-	}
-}
-
-func (ctx *SimpleStore) Merge(src ExprContext) {
-	for _, name := range src.EnumVars(filterRefName) {
-		ctx.varStore[name], _ = src.GetVar(name)
-	}
-	for _, name := range src.EnumFuncs(filterRefName) {
-		ctx.funcStore[name], _ = src.GetFuncInfo(name)
-	}
-}
-
-func varsCtxToBuilder(sb *strings.Builder, ctx ExprContext, indent int) {
-	sb.WriteString("vars: {\n")
-	first := true
-	for _, name := range ctx.EnumVars(filterPrivName) {
-		if first {
-			first = false
-		} else {
-			sb.WriteByte(',')
-			sb.WriteByte('\n')
-		}
-
-		value, _ := ctx.GetVar(name)
-		sb.WriteString(strings.Repeat("\t", indent+1))
-		sb.WriteString(name)
-		sb.WriteString(": ")
-		if f, ok := value.(Formatter); ok {
-			sb.WriteString(f.ToString(0))
-		} else if _, ok = value.(Functor); ok {
-			sb.WriteString("func(){}")
-			// } else if _, ok = value.(map[any]any); ok {
-			// 	sb.WriteString("dict{}")
-		} else {
-			sb.WriteString(fmt.Sprintf("%v", value))
-		}
-	}
-	sb.WriteString(strings.Repeat("\t", indent))
-	sb.WriteString("\n}\n")
-}
-
-func varsCtxToString(ctx ExprContext, indent int) string {
-	var sb strings.Builder
-	varsCtxToBuilder(&sb, ctx, indent)
-	return sb.String()
-}
-
-func funcsCtxToBuilder(sb *strings.Builder, ctx ExprContext, indent int) {
-	sb.WriteString("funcs: {\n")
-	first := true
-	names := ctx.EnumFuncs(func(name string) bool { return true })
-	slices.Sort(names)
-	for _, name := range names {
-		if first {
-			first = false
-		} else {
-			sb.WriteByte(',')
-			sb.WriteByte('\n')
-		}
-		value, _ := ctx.GetFuncInfo(name)
-		sb.WriteString(strings.Repeat("\t", indent+1))
-		if formatter, ok := value.(Formatter); ok {
-			sb.WriteString(formatter.ToString(0))
-		} else {
-			sb.WriteString(fmt.Sprintf("%v", value))
-		}
-	}
-	sb.WriteString("\n}\n")
-}
-
-func (ctx *SimpleStore) ToString(opt FmtOpt) string {
-	var sb strings.Builder
-	varsCtxToBuilder(&sb, ctx, 0)
-	funcsCtxToBuilder(&sb, ctx, 0)
-	return sb.String()
-}
-
-func (ctx *SimpleStore) GetVar(varName string) (v any, exists bool) {
-	v, exists = ctx.varStore[varName]
-	return
-}
-
-func (ctx *SimpleStore) UnsafeSetVar(varName string, value any) {
-	// fmt.Printf("[%p] setVar(%v, %v)\n", ctx, varName, value)
-	ctx.varStore[varName] = value
-}
-
-func (ctx *SimpleStore) SetVar(varName string, value any) {
-	// fmt.Printf("[%p] SetVar(%v, %v)\n", ctx, varName, value)
-	if allowedValue, ok := fromGenericAny(value); ok {
-		ctx.varStore[varName] = allowedValue
-	} else {
-		panic(fmt.Errorf("unsupported type %T of value %v", value, value))
-	}
-}
-
-func (ctx *SimpleStore) EnumVars(acceptor func(name string) (accept bool)) (varNames []string) {
-	varNames = make([]string, 0)
-	for name := range ctx.varStore {
-		if acceptor != nil {
-			if acceptor(name) {
-				varNames = append(varNames, name)
-			}
-		} else {
-			varNames = append(varNames, name)
-		}
-	}
-	return
-}
-
-func (ctx *SimpleStore) GetFuncInfo(name string) (info ExprFunc, exists bool) {
-	info, exists = ctx.funcStore[name]
-	return
-}
-
-func (ctx *SimpleStore) RegisterFuncInfo(info ExprFunc) {
-	ctx.funcStore[info.Name()], _ = info.(*funcInfo)
-}
-
-func (ctx *SimpleStore) RegisterFunc(name string, functor Functor, returnType string, params []ExprFuncParam) (err error) {
-	var info *funcInfo
-	if info, err = newFuncInfo(name, functor, returnType, params); err == nil {
-		ctx.funcStore[name] = info
-	}
-	return
-}
-
-func (ctx *SimpleStore) EnumFuncs(acceptor func(name string) (accept bool)) (funcNames []string) {
-	funcNames = make([]string, 0)
-	for name := range ctx.funcStore {
-		if acceptor != nil {
-			if acceptor(name) {
-				funcNames = append(funcNames, name)
-			}
-		} else {
-			funcNames = append(funcNames, name)
-		}
-	}
-	return
-}
-
-func (ctx *SimpleStore) Call(name string, args []any) (result any, err error) {
-	if info, exists := GetLocalFuncInfo(ctx, name); exists {
-		functor := info.Functor()
-		result, err = functor.Invoke(ctx, name, args)
-	} else {
-		err = fmt.Errorf("unknown function %s()", name)
-	}
-	return
-}

simple-var-store.go

@@ -0,0 +1,70 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// simple-var-store.go
+package expr
+
+import "fmt"
+
+type SimpleVarStore struct {
+	varStore map[string]any
+}
+
+func NewSimpleVarStore() *SimpleVarStore {
+	return &SimpleVarStore{
+		varStore: make(map[string]any),
+	}
+}
+
+func (ctx *SimpleVarStore) Clone() (clone ExprContext) {
+	clone = &SimpleVarStore{
+		varStore: CloneMap(ctx.varStore),
+	}
+	return clone
+}
+
+func (ctx *SimpleVarStore) GetVar(varName string) (v any, exists bool) {
+	v, exists = ctx.varStore[varName]
+	return
+}
+
+func (ctx *SimpleVarStore) setVar(varName string, value any) {
+	ctx.varStore[varName] = value
+}
+
+func (ctx *SimpleVarStore) SetVar(varName string, value any) {
+	if allowedValue, ok := fromGenericAny(value); ok {
+		ctx.varStore[varName] = allowedValue
+	} else {
+		panic(fmt.Errorf("unsupported type %T of value %v", value, value))
+	}
+}
+
+func (ctx *SimpleVarStore) EnumVars(acceptor func(name string) (accept bool)) (varNames []string) {
+	varNames = make([]string, 0)
+	for name := range ctx.varStore {
+		if acceptor != nil {
+			if acceptor(name) {
+				varNames = append(varNames, name)
+			}
+		} else {
+			varNames = append(varNames, name)
+		}
+	}
+	return
+}
+
+func (ctx *SimpleVarStore) GetFuncInfo(name string) (f ExprFunc) {
+	return
+}
+
+func (ctx *SimpleVarStore) Call(name string, args []any) (result any, err error) {
+	return
+}
+
+func (ctx *SimpleVarStore) RegisterFunc(name string, functor Functor, minArgs, maxArgs int) {
+}
+
+func (ctx *SimpleVarStore) EnumFuncs(acceptor func(name string) (accept bool)) (funcNames []string) {
+	return
+}

symbol.go

@@ -33,7 +33,7 @@ const (
 	SymBackTick                          //  22: '`'
 	SymExclamation                       //  23: '!'
 	SymQuestion                          //  24: '?'
-	SymAmpersand                         //  25: '&'
+	SymAmpersand                         //  25: '&&'
 	SymDoubleAmpersand                   //  26: '&&'
 	SymPercent                           //  27: '%'
 	SymAt                                //  28: '@'
@@ -61,22 +61,13 @@ const (
 	SymDoubleColon                       //  50: '::'
 	SymInsert                            //  51: '>>'
 	SymAppend                            //  52: '<<'
-	SymCaret                             //  53: '^'
-	SymDollarRound                       //  54: '$('
-	SymOpenClosedRound                   //  55: '()'
-	SymDoubleDollar                      //  56: '$$'
-	SymDoubleDot                         //  57: '..'
-	SymTripleDot                         //  58: '...'
 	SymChangeSign
 	SymUnchangeSign
 	SymIdentifier
 	SymBool
 	SymInteger
-	SymVariable
 	SymFloat
-	SymFraction
 	SymString
-	SymIterator
 	SymOr
 	SymAnd
 	SymNot
@@ -84,8 +75,6 @@ const (
 	SymFuncCall
 	SymFuncDef
 	SymList
-	SymDict
-	SymIndex
 	SymExpression
 	SymSelector     // <selector> ::= <expr> "?" <selector-case> {":" <selector-case>} ["::" <default-selector-case>]
 	SymSelectorCase // <selector-case> ::= [<list>] "{" <multi-expr> "}"
@@ -101,9 +90,6 @@ const (
 	SymKwBut
 	SymKwFunc
 	SymKwBuiltin
-	SymKwIn
-	SymKwInclude
-	SymKwNil
 )
 
 var keywords map[string]Symbol
@@ -115,10 +101,7 @@ func init() {
 		"BUILTIN": SymKwBuiltin,
 		"BUT":     SymKwBut,
 		"FUNC":    SymKwFunc,
-		"IN":      SymKwIn,
-		"INCLUDE": SymKwInclude,
 		"NOT":     SymKwNot,
 		"OR":      SymKwOr,
-		"NIL":     SymKwNil,
 	}
 }

t_dict_test.go

@@ -1,153 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_dict_test.go
-package expr
-
-import (
-	"errors"
-
-	"strings"
-	"testing"
-)
-
-func TestDictParser(t *testing.T) {
-	section := "Dict"
-
-	type inputType struct {
-		source     string
-		wantResult any
-		wantErr    error
-	}
-
-	inputs := []inputType{
-		/*  1 */ {`{}`, map[any]any{}, nil},
-		/*  2 */ {`{123}`, nil, errors.New(`[1:6] expected ":", got "}"`)},
-		/*  3 */ {`{1:"one",2:"two",3:"three"}`, map[int64]any{int64(1): "one", int64(2): "two", int64(3): "three"}, nil},
-		/*  4 */ {`{1:"one",2:"two",3:"three"}[3]`, "three", nil},
-		/*  5 */ {`#{1:"one",2:"two",3:"three"}`, int64(3), nil},
-		/*  6 */ {`{1:"one"} + {2:"two"}`, map[any]any{1: "one", 2: "two"}, nil},
-		/*  7 */ {`2 in {1:"one", 2:"two"}`, true, nil},
-		/*  8 */ {`D={"a":1, "b":2}; D["a"]=9; D`, map[any]any{"a": 9, "b": 2}, nil},
-		/*  9 */ {`D={"a":1, "b":2}; D["z"]=9; D`, map[any]any{"z": 9, "a": 1, "b": 2}, nil},
-		/* 10 */ {`D={"a":1, "b":2}; D[nil]=9`, nil, errors.New(`[1:21] index/key is nil`)},
-	}
-
-	succeeded := 0
-	failed := 0
-
-	// inputs1 := []inputType{
-	// 	/*  7 */ {`add([1,4,3,2])`, int64(10), nil},
-	// }
-
-	for i, input := range inputs {
-		var expr *ast
-		var gotResult any
-		var gotErr error
-
-		ctx := NewSimpleStore()
-		ctx.SetVar("var1", int64(123))
-		ctx.SetVar("var2", "abc")
-		ImportMathFuncs(ctx)
-		parser := NewParser(ctx)
-
-		logTest(t, i+1, "Dict", input.source, input.wantResult, input.wantErr)
-
-		r := strings.NewReader(input.source)
-		scanner := NewScanner(r, DefaultTranslations())
-
-		good := true
-		if expr, gotErr = parser.Parse(scanner); gotErr == nil {
-			gotResult, gotErr = expr.Eval(ctx)
-		}
-
-		if (gotResult == nil && input.wantResult != nil) || (gotResult != nil && input.wantResult == nil) {
-			t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-			good = false
-		}
-
-		if gotList, okGot := gotResult.([]any); okGot {
-			if wantList, okWant := input.wantResult.([]any); okWant {
-				if (gotList == nil && wantList != nil) || (gotList != nil && wantList == nil) {
-					t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-					good = false
-				} else {
-					equal := len(gotList) == len(wantList)
-					if equal {
-						for i, gotItem := range gotList {
-							wantItem := wantList[i]
-							equal = gotItem == wantItem
-							if !equal {
-								break
-							}
-						}
-					}
-					if !equal {
-						t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-						good = false
-					}
-				}
-			}
-		}
-
-		if gotErr != input.wantErr {
-			if input.wantErr == nil || gotErr == nil || (gotErr.Error() != input.wantErr.Error()) {
-				t.Errorf("%d: %q  -> err = <%v>, want <%v>", i+1, input.source, gotErr, input.wantErr)
-				good = false
-			}
-		}
-
-		if good {
-			succeeded++
-		} else {
-			failed++
-		}
-	}
-	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
-}
-
-func TestDictToStringMultiLine(t *testing.T) {
-	var good bool
-	section := "dict-ToString-ML"
-	want := `{
-	"first": 1
-}`
-	args := map[any]*term{
-		"first": newLiteralTerm(NewValueToken(0, 0, SymInteger, "1", 1)),
-	}
-	dict := newDict(args)
-	got := dict.ToString(MultiLine)
-	// fmt.Printf("got=%q\n", got)
-
-	if good = got == want; !good {
-		t.Errorf("ToString(MultiLine): got = %q, want %q", got, want)
-	}
-
-	if good {
-		t.Logf("%s -- succeeded", section)
-	} else {
-		t.Logf("%s -- failed", section)
-	}
-}
-
-func TestDictToString(t *testing.T) {
-	var good bool
-	section := "dict-ToString-SL"
-	want := `{"first": 1}`
-	args := map[any]*term{
-		"first": newLiteralTerm(NewValueToken(0, 0, SymInteger, "1", 1)),
-	}
-	dict := newDict(args)
-	got := dict.ToString(0)
-	// fmt.Printf("got=%q\n", got)
-
-	if good = got == want; !good {
-		t.Errorf("ToString(0): got = %q, want %q", got, want)
-	}
-
-	if good {
-		t.Logf("%s -- succeeded", section)
-	} else {
-		t.Logf("%s -- failed", section)
-	}
-}

t_expr_test.go

@@ -1,37 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_expr_test.go
-package expr
-
-import (
-	"testing"
-)
-
-func TestExpr(t *testing.T) {
-	section := "Expr"
-
-	inputs := []inputType{
-		/*   1 */ {`0?{}`, nil, nil},
-		/*   2 */ {`fact=func(n){(n)?{1}::{n*fact(n-1)}}; fact(5)`, int64(120), nil},
-		/*   3 */ {`builtin "os.file"; f=openFile("test-file.txt"); line=readFile(f); closeFile(f); line`, "uno", nil},
-		/*   4 */ {`mynot=func(v){int(v)?{true}::{false}}; mynot(0)`, true, nil},
-		/*   5 */ {`1 ? {1} : [1+0] {3*(1+1)}`, int64(6), nil},
-		/*   6 */ {`
-		ds={
-			"init":func(end){@end=end; @current=0 but true},
-			"current":func(){current},
-			"next":func(){
-				((next=current+1) <= end) ? [true] {@current=next but current} :: {nil}
-			}
-		};
-		it=$(ds,3);
-		it++;
-		it++
-`, int64(1), nil},
-	}
-	// t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 3)
-	parserTest(t, section, inputs)
-}

t_fractions_test.go

@@ -1,66 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_fractions_test.go
-package expr
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestFractionsParser(t *testing.T) {
-	section := "Fraction"
-	inputs := []inputType{
-		/*   1 */ {`1|2`, newFraction(1, 2), nil},
-		/*   2 */ {`1|2 + 1`, newFraction(3, 2), nil},
-		/*   3 */ {`1|2 - 1`, newFraction(-1, 2), nil},
-		/*   4 */ {`1|2 * 1`, newFraction(1, 2), nil},
-		/*   5 */ {`1|2 * 2|3`, newFraction(2, 6), nil},
-		/*   6 */ {`1|2 / 2|3`, newFraction(3, 4), nil},
-		/*   7 */ {`1|"5"`, nil, errors.New(`denominator must be integer, got string (5)`)},
-		/*   8 */ {`"1"|5`, nil, errors.New(`numerator must be integer, got string (1)`)},
-		/*   9 */ {`1|+5`, nil, errors.New(`[1:3] infix operator "|" requires two non-nil operands, got 1`)},
-		/*  10 */ {`1|(-2)`, newFraction(-1, 2), nil},
-		/*  11 */ {`builtin "math.arith"; add(1|2, 2|3)`, newFraction(7, 6), nil},
-		/*  12 */ {`builtin "math.arith"; add(1|2, 1.0, 2)`, float64(3.5), nil},
-		/*  13 */ {`builtin "math.arith"; mul(1|2, 2|3)`, newFraction(2, 6), nil},
-		/*  14 */ {`builtin "math.arith"; mul(1|2, 1.0, 2)`, float64(1.0), nil},
-		/*  15 */ {`1|0`, nil, errors.New(`division by zero`)},
-		/*  16 */ {`fract(-0.5)`, newFraction(-1, 2), nil},
-		/*  17 */ {`fract("")`, (*FractionType)(nil), errors.New(`bad syntax`)},
-		/*  18 */ {`fract("-1")`, newFraction(-1, 1), nil},
-		/*  19 */ {`fract("+1")`, newFraction(1, 1), nil},
-		/*  20 */ {`fract("1a")`, (*FractionType)(nil), errors.New(`strconv.ParseInt: parsing "1a": invalid syntax`)},
-		/*  21 */ {`fract(1,0)`, nil, errors.New(`fract(): division by zero`)},
-	}
-	parserTest(t, section, inputs)
-}
-
-func TestFractionToStringSimple(t *testing.T) {
-	source := newFraction(1, 2)
-	want := "1|2"
-	got := source.ToString(0)
-	if got != want {
-		t.Errorf(`(1,2) -> result = %v [%T], want = %v [%T]`, got, got, want, want)
-	}
-}
-
-func TestFractionToStringMultiline(t *testing.T) {
-	source := newFraction(1, 2)
-	want := "1\n-\n2"
-	got := source.ToString(MultiLine)
-	if got != want {
-		t.Errorf(`(1,2) -> result = %v [%T], want = %v [%T]`, got, got, want, want)
-	}
-}
-
-// TODO Check this test: the output string ends with a space
-func _TestToStringMultilineTty(t *testing.T) {
-	source := newFraction(-1, 2)
-	want := "\x1b[4m-1\x1b[0m\n2"
-	got := source.ToString(MultiLine | TTY)
-	if got != want {
-		t.Errorf(`(1,2) -> result = %#v [%T], want = %#v [%T]`, got, got, want, want)
-	}
-}

t_func-base_test.go

@@ -1,67 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_func-base_test.go
-package expr
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestFuncBase(t *testing.T) {
-	section := "Func-Base"
-
-	inputs := []inputType{
-		/*   1 */ {`isNil(nil)`, true, nil},
-		/*   2 */ {`v=nil; isNil(v)`, true, nil},
-		/*   3 */ {`v=5; isNil(v)`, false, nil},
-		/*   4 */ {`int(true)`, int64(1), nil},
-		/*   5 */ {`int(false)`, int64(0), nil},
-		/*   6 */ {`int(3.1)`, int64(3), nil},
-		/*   7 */ {`int(3.9)`, int64(3), nil},
-		/*   8 */ {`int("432")`, int64(432), nil},
-		/*   9 */ {`int("1.5")`, nil, errors.New(`strconv.Atoi: parsing "1.5": invalid syntax`)},
-		/*  10 */ {`int("432", 4)`, nil, errors.New(`int(): too much params -- expected 1, got 2`)},
-		/*  11 */ {`int(nil)`, nil, errors.New(`int(): can't convert nil to int`)},
-		/*  12 */ {`isInt(2+1)`, true, nil},
-		/*  13 */ {`isInt(3.1)`, false, nil},
-		/*  14 */ {`isFloat(3.1)`, true, nil},
-		/*  15 */ {`isString("3.1")`, true, nil},
-		/*  16 */ {`isString("3" + 1)`, true, nil},
-		/*  17 */ {`isList(["3",  1])`, true, nil},
-		/*  18 */ {`isDict({"a":"3",  "b":1})`, true, nil},
-		/*  19 */ {`isFract(1|3)`, true, nil},
-		/*  20 */ {`isFract(3|1)`, false, nil},
-		/*  21 */ {`isRational(3|1)`, true, nil},
-		/*  22 */ {`fract("2.2(3)")`, newFraction(67, 30), nil},
-		/*  23 */ {`fract("1.21(3)")`, newFraction(91, 75), nil},
-		/*  24 */ {`fract(1.21(3))`, newFraction(91, 75), nil},
-		/*  25 */ {`fract(1.21)`, newFraction(121, 100), nil},
-		/*  26 */ {`dec(2)`, float64(2), nil},
-		/*  27 */ {`dec(2.0)`, float64(2), nil},
-		/*  28 */ {`dec("2.0")`, float64(2), nil},
-		/*  29 */ {`dec(true)`, float64(1), nil},
-		/*  30 */ {`dec(true")`, nil, errors.New("[1:11] missing string termination \"")},
-		/*  31 */ {`dec()`, nil, errors.New(`dec(): too few params -- expected 1, got 0`)},
-		/*  32 */ {`dec(1,2,3)`, nil, errors.New(`dec(): too much params -- expected 1, got 3`)},
-		/*  33 */ {`isBool(false)`, true, nil},
-		/*  34 */ {`fract(1|2)`, newFraction(1, 2), nil},
-		/*  35 */ {`fract(12,2)`, newFraction(6, 1), nil},
-		/*  36 */ {`bool(2)`, true, nil},
-		/*  37 */ {`bool(1|2)`, true, nil},
-		/*  38 */ {`bool(1.0)`, true, nil},
-		/*  39 */ {`bool("1")`, true, nil},
-		/*  40 */ {`bool(false)`, false, nil},
-		/*  41 */ {`bool([1])`, nil, errors.New(`bool(): can't convert list to bool`)},
-		/*  42 */ {`dec(false)`, float64(0), nil},
-		/*  43 */ {`dec(1|2)`, float64(0.5), nil},
-		/*  44 */ {`dec([1])`, nil, errors.New(`dec(): can't convert list to float`)},
-		// /*  45 */ {`string([1])`, nil, errors.New(`string(): can't convert list to string`)},
-	}
-
-	t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 2)
-	parserTest(t, section, inputs)
-}

t_func-import_test.go

@@ -1,24 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_func-import_test.go
-package expr
-
-import (
-	"testing"
-)
-
-func TestFuncImport(t *testing.T) {
-	section := "Func-Import"
-	inputs := []inputType{
-		/*   1 */ {`builtin "import"; import("./test-funcs.expr"); (double(3+a) + 1) * two()`, int64(34), nil},
-		/*   2 */ {`builtin "import"; import("test-funcs.expr"); (double(3+a) + 1) * two()`, int64(34), nil},
-		/*   3 */ {`builtin "import"; importAll("./test-funcs.expr"); six()`, int64(6), nil},
-		/*   4 */ {`builtin "import"; import("./sample-export-all.expr"); six()`, int64(6), nil},
-	}
-
-	t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 69)
-	parserTest(t, section, inputs)
-}

t_func-math-arith_test.go

@@ -1,29 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_func-math-arith_test.go
-package expr
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestFuncMathArith(t *testing.T) {
-	section := "Func-Math-Arith"
-	inputs := []inputType{
-		/*   1 */ {`builtin "math.arith"; add(1,2)`, int64(3), nil},
-		/*   2 */ {`builtin "math.arith"; add(1,2,3)`, int64(6), nil},
-		/*   3 */ {`builtin "math.arith"; mulX(1,2,3)`, nil, errors.New(`unknown function mulX()`)},
-		/*   4 */ {`builtin "math.arith"; add(1+4,3+2,5*(3-2))`, int64(15), nil},
-		/*   5 */ {`builtin "math.arith"; add(add(1+4),3+2,5*(3-2))`, int64(15), nil},
-		/*   6 */ {`builtin "math.arith"; add(add(1,4),/*3+2,*/5*(3-2))`, int64(10), nil},
-		/*   7 */ {`builtin "math.arith"; a=5; b=2; add(a, b*3)`, int64(11), nil},
-		/*   8 */ {`builtin "math.arith"; var2="abc"; add(1,2) but var2`, "abc", nil},
-	}
-
-	// t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 69)
-	parserTest(t, section, inputs)
-}

t_func-os_test.go

@@ -1,29 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_func-os_test.go
-package expr
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestFuncOs(t *testing.T) {
-	section := "Func-OS"
-	inputs := []inputType{
-		/*   1 */ {`builtin "os.file"`, int64(1), nil},
-		/*   2 */ {`builtin "os.file"; handle=openFile("/etc/hosts"); closeFile(handle)`, true, nil},
-		/*   3 */ {`builtin "os.file"; handle=openFile("/etc/hostsX")`, nil, errors.New(`open /etc/hostsX: no such file or directory`)},
-		/*   4 */ {`builtin "os.file"; handle=createFile("/tmp/dummy"); closeFile(handle)`, true, nil},
-		/*   5 */ {`builtin "os.file"; handle=appendFile("/tmp/dummy"); writeFile(handle, "bye-bye"); closeFile(handle)`, true, nil},
-		/*   6 */ {`builtin "os.file"; handle=openFile("/tmp/dummy"); word=readFile(handle, "-"); closeFile(handle);word`, "bye", nil},
-		/*   7 */ {`builtin "os.file"; word=readFile(nil, "-")`, nil, errors.New(`readFileFunc(): invalid file handle`)},
-		/*   7 */ {`builtin "os.file"; writeFile(nil, "bye")`, nil, errors.New(`writeFileFunc(): invalid file handle`)},
-	}
-
-	// t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 69)
-	parserTest(t, section, inputs)
-}

t_func-string_test.go

@@ -1,69 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_func-string_test.go
-package expr
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestFuncString(t *testing.T) {
-	section := "Func-String"
-
-	inputs := []inputType{
-		/*   1 */ {`builtin "string"; joinStr("-", "one", "two", "three")`, "one-two-three", nil},
-		/*   2 */ {`builtin "string"; joinStr("-", ["one", "two", "three"])`, "one-two-three", nil},
-		/*   3 */ {`builtin "string"; ls= ["one", "two", "three"]; joinStr("-", ls)`, "one-two-three", nil},
-		/*   4 */ {`builtin "string"; ls= ["one", "two", "three"]; joinStr(1, ls)`, nil, errors.New(`joinStr() the "separator" parameter must be a string, got a integer (1)`)},
-		/*   5 */ {`builtin "string"; ls= ["one", 2, "three"]; joinStr("-", ls)`, nil, errors.New(`joinStr() expected string, got integer (2)`)},
-		/*   6 */ {`builtin "string"; "<"+trimStr("  bye bye  ")+">"`, "<bye bye>", nil},
-		/*   7 */ {`builtin "string"; subStr("0123456789", 1,2)`, "12", nil},
-		/*   8 */ {`builtin "string"; subStr("0123456789", -3,2)`, "78", nil},
-		/*   9 */ {`builtin "string"; subStr("0123456789", -3)`, "789", nil},
-		/*  10 */ {`builtin "string"; subStr("0123456789")`, "0123456789", nil},
-		/*  11 */ {`builtin "string"; startsWithStr("0123456789", "xyz", "012")`, true, nil},
-		/*  12 */ {`builtin "string"; startsWithStr("0123456789", "xyz", "0125")`, false, nil},
-		/*  13 */ {`builtin "string"; startsWithStr("0123456789")`, nil, errors.New(`startsWithStr(): too few params -- expected 2 or more, got 1`)},
-		/*  14 */ {`builtin "string"; endsWithStr("0123456789", "xyz", "789")`, true, nil},
-		/*  15 */ {`builtin "string"; endsWithStr("0123456789", "xyz", "0125")`, false, nil},
-		/*  16 */ {`builtin "string"; endsWithStr("0123456789")`, nil, errors.New(`endsWithStr(): too few params -- expected 2 or more, got 1`)},
-		/*  17 */ {`builtin "string"; splitStr("one-two-three", "-")`, newListA("one", "two", "three"), nil},
-		/*  18 */ {`builtin "string"; joinStr("-", [1, "two", "three"])`, nil, errors.New(`joinStr() expected string, got integer (1)`)},
-		/*  19 */ {`builtin "string"; joinStr()`, nil, errors.New(`joinStr(): too few params -- expected 1 or more, got 0`)},
-
-		/*  69 */ /*{`builtin "string"; $$global`, `vars: {
-		}
-		funcs: {
-		    	add(any=0 ...) -> number,
-		    	dec(any) -> decimal,
-		    	endsWithStr(source, suffix) -> boolean,
-		    	fract(any, denominator=1) -> fraction,
-		    	import( ...) -> any,
-		    	importAll( ...) -> any,
-		    	int(any) -> integer,
-		    	isBool(any) -> boolean,
-		    	isDec(any) -> boolean,
-		    	isDict(any) -> boolean,
-		    	isFloat(any) -> boolean,
-		    	isFract(any) -> boolean,
-		    	isInt(any) -> boolean,
-		    	isList(any) -> boolean,
-		    	isNil(any) -> boolean,
-		    	isString(any) -> boolean,
-		    	joinStr(separator, item="" ...) -> string,
-		    	mul(any=1 ...) -> number,
-		    	splitStr(source, separator="", count=-1) -> list of string,
-		    	startsWithStr(source, prefix) -> boolean,
-		    	subStr(source, start=0, count=-1) -> string,
-		    	trimStr(source) -> string
-		}
-		`, nil},*/
-	}
-
-	//t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 19)
-	parserTest(t, section, inputs)
-}

t_funcs_test.go

@@ -1,61 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_funcs_test.go
-package expr
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestFuncs(t *testing.T) {
-	section := "Funcs"
-	inputs := []inputType{
-		/*   1 */ {`two=func(){2}; two()`, int64(2), nil},
-		/*   2 */ {`double=func(x) {2*x}; (double(3))`, int64(6), nil},
-		/*   3 */ {`double=func(x){2*x}; double(3)`, int64(6), nil},
-		/*   4 */ {`double=func(x){2*x}; a=5; double(3+a) + 1`, int64(17), nil},
-		/*   5 */ {`double=func(x){2*x}; a=5; two=func() {2}; (double(3+a) + 1) * two()`, int64(34), nil},
-		/*   6 */ {`@x="hello"; @x`, nil, errors.New(`[1:3] variable references are not allowed in top level expressions: "@x"`)},
-		/*   7 */ {`f=func(){@x="hello"}; f(); x`, "hello", nil},
-		/*   8 */ {`f=func(@y){@y=@y+1}; f(2); y`, int64(3), nil},
-		/*   9 */ {`f=func(@y){g=func(){@x=5}; @y=@y+g()}; f(2); y+x`, nil, errors.New(`undefined variable or function "x"`)},
-		/*  10 */ {`f=func(@y){g=func(){@x=5}; @z=g(); @y=@y+@z}; f(2); y+z`, int64(12), nil},
-		/*  11 */ {`f=func(@y){g=func(){@x=5}; g(); @z=x; @y=@y+@z}; f(2); y+z`, int64(12), nil},
-		/*  12 */ {`f=func(@y){g=func(){@x=5}; g(); @z=x; @x=@y+@z}; f(2); y+x`, int64(9), nil},
-		/*  13 */ {`two=func(){2}; four=func(f){f()+f()}; four(two)`, int64(4), nil},
-		/*  14 */ {`two=func(){2}; two(123)`, nil, errors.New(`two(): too much params -- expected 0, got 1`)},
-		/*  15 */ {`f=func(x,n=2){x+n}; f(3)`, int64(5), nil},
-		/*  16 */ {`f=func(x,n=2,y){x+n}`, nil, errors.New(`[1:16] can't mix default and non-default parameters`)},
-		/*  17 */ {`f=func(x,n){1}; f(3,4,)`, nil, errors.New(`[1:24] expected "function-param-value", got ")"`)},
-		// /*  18 */ {`f=func(a){a*2}`, nil, errors.New(`[1:24] expected "function-param-value", got ")"`)},
-	}
-
-	// t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 17)
-	parserTest(t, section, inputs)
-}
-
-func dummy(ctx ExprContext, name string, args []any) (result any, err error) {
-	return
-}
-
-func TestFunctionToStringSimple(t *testing.T) {
-	source := newGolangFunctor(dummy)
-	want := "func() {<body>}"
-	got := source.ToString(0)
-	if got != want {
-		t.Errorf(`(func() -> result = %v [%T], want = %v [%T]`, got, got, want, want)
-	}
-}
-
-func TestFunctionGetFunc(t *testing.T) {
-	source := newGolangFunctor(dummy)
-	want := ExprFunc(nil)
-	got := source.GetFunc()
-	if got != want {
-		t.Errorf(`(func() -> result = %v [%T], want = %v [%T]`, got, got, want, want)
-	}
-}

t_index_test.go

@@ -1,27 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_index_test.go
-package expr
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestCollections(t *testing.T) {
-	section := "Collection"
-	inputs := []inputType{
-		/*   1 */ {`"abcdef"[1:3]`, "bc", nil},
-		/*   2 */ {`"abcdef"[:3]`, "abc", nil},
-		/*   3 */ {`"abcdef"[1:]`, "bcdef", nil},
-		/*   4 */ {`"abcdef"[:]`, "abcdef", nil},
-		// /*   5 */ {`[0,1,2,3,4][:]`, ListType{int64(0), int64(1), int64(2), int64(3), int64(4)}, nil},
-		/*   5 */ {`"abcdef"[1:2:3]`, nil, errors.New(`[1:14] left operand '(1, 2)' [pair] and right operand '3' [integer] are not compatible with operator ":"`)},
-	}
-
-	t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 5)
-	parserTest(t, section, inputs)
-}

t_iterator_test.go

@@ -1,26 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_iterator_test.go
-package expr
-
-import "testing"
-
-func TestIteratorParser(t *testing.T) {
-	inputs := []inputType{
-		/*   1 */ {`include "iterator.expr"; it=$(ds,3); ()it`, int64(0), nil},
-		/*   2 */ {`include "iterator.expr"; it=$(ds,3); it++; it++`, int64(1), nil},
-		/*   3 */ {`include "iterator.expr"; it=$(ds,3); it++; it++; #it`, int64(2), nil},
-		/*   4 */ {`include "iterator.expr"; it=$(ds,3); it++; it++; it.reset; ()it`, int64(0), nil},
-		/*   5 */ {`builtin "math.arith"; include "iterator.expr"; it=$(ds,3); add(it)`, int64(6), nil},
-		/*   6 */ {`builtin "math.arith"; include "iterator.expr"; it=$(ds,3); mul(it)`, int64(0), nil},
-		/*   7 */ {`builtin "math.arith"; include "file-reader.expr"; it=$(ds,"int.list"); mul(it)`, int64(12000), nil},
-		/*   8 */ {`include "file-reader.expr"; it=$(ds,"int.list"); it++; it.index`, int64(0), nil},
-		/*  10 */ {`include "file-reader.expr"; it=$(ds,"int.list"); it.clean`, true, nil},
-		/*  11 */ {`it=$(1,2,3); it++`, int64(1), nil},
-	}
-	// inputs1 := []inputType{
-	// 	/*   1 */ {`0?{}`, nil, nil},
-	// }
-	parserTest(t, "Iterator", inputs)
-}

t_list_test.go

@@ -1,137 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_list_test.go
-package expr
-
-import (
-	"errors"
-	"strings"
-	"testing"
-)
-
-func TestListParser(t *testing.T) {
-	section := "List"
-
-	/*	type inputType struct {
-			source     string
-			wantResult any
-			wantErr    error
-		}
-	*/
-	inputs := []inputType{
-		/*   1 */ {`[]`, newListA(), nil},
-		/*   2 */ {`[1,2,3]`, newListA(int64(1), int64(2), int64(3)), nil},
-		/*   3 */ {`[1,2,"hello"]`, newListA(int64(1), int64(2), "hello"), nil},
-		/*   4 */ {`[1+2, not true, "hello"]`, newListA(int64(3), false, "hello"), nil},
-		/*   5 */ {`[1,2]+[3]`, newListA(int64(1), int64(2), int64(3)), nil},
-		/*   6 */ {`[1,4,3,2]-[3]`, newListA(int64(1), int64(4), int64(2)), nil},
-		/*   7 */ {`add([1,4,3,2])`, int64(10), nil},
-		/*   8 */ {`add([1,[2,2],3,2])`, int64(10), nil},
-		/*   9 */ {`mul([1,4,3.0,2])`, float64(24.0), nil},
-		/*  10 */ {`add([1,"hello"])`, nil, errors.New(`add(): param nr 2 (2 in 1) has wrong type string, number expected`)},
-		/*  11 */ {`[a=1,b=2,c=3] but a+b+c`, int64(6), nil},
-		/*  12 */ {`[1,2,3] << 2+2`, newListA(int64(1), int64(2), int64(3), int64(4)), nil},
-		/*  13 */ {`2-1 >> [2,3]`, newListA(int64(1), int64(2), int64(3)), nil},
-		/*  14 */ {`[1,2,3][1]`, int64(2), nil},
-		/*  15 */ {`ls=[1,2,3] but ls[1]`, int64(2), nil},
-		/*  16 */ {`ls=[1,2,3] but ls[-1]`, int64(3), nil},
-		/*  17 */ {`list=["one","two","three"]; list[10]`, nil, errors.New(`[1:34] index 10 out of bounds`)},
-		/*  18 */ {`["a", "b", "c"]`, newListA("a", "b", "c"), nil},
-		/*  19 */ {`["a", "b", "c"]`, newList([]any{"a", "b", "c"}), nil},
-		/*  20 */ {`#["a", "b", "c"]`, int64(3), nil},
-		/*  21 */ {`"b" in ["a", "b", "c"]`, true, nil},
-		/*  22 */ {`a=[1,2]; (a)<<3`, newListA(int64(1), int64(2), int64(3)), nil},
-		/*  23 */ {`a=[1,2]; (a)<<3; a`, newListA(int64(1), int64(2)), nil},
-		/*  24 */ {`["a","b","c","d"][1]`, "b", nil},
-		/*  25 */ {`["a","b","c","d"][1,1]`, nil, errors.New(`[1:19] one index only is allowed`)},
-		/*  26 */ {`[0,1,2,3,4][:]`, newListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil},
-		/*  27 */ {`["a", "b", "c"] << ;`, nil, errors.New(`[1:18] infix operator "<<" requires two non-nil operands, got 1`)},
-		/*  28 */ {`2 << 3;`, nil, errors.New(`[1:4] left operand '2' [integer] and right operand '3' [integer] are not compatible with operator "<<"`)},
-		/*  29 */ {`but >> ["a", "b", "c"]`, nil, errors.New(`[1:6] infix operator ">>" requires two non-nil operands, got 0`)},
-		/*  30 */ {`2 >> 3;`, nil, errors.New(`[1:4] left operand '2' [integer] and right operand '3' [integer] are not compatible with operator ">>"`)},
-		/*  31 */ {`a=[1,2]; a<<3`, newListA(int64(1), int64(2), int64(3)), nil},
-		/*  33 */ {`a=[1,2]; 5>>a`, newListA(int64(5), int64(1), int64(2)), nil},
-		/*  34 */ {`L=[1,2]; L[0]=9; L`, newListA(int64(9), int64(2)), nil},
-		/*  35 */ {`L=[1,2]; L[5]=9; L`, nil, errors.New(`index 5 out of bounds (0, 1)`)},
-		/*  36 */ {`L=[1,2]; L[]=9; L`, nil, errors.New(`[1:12] index/key specification expected, got [] [list]`)},
-		/*  37 */ {`L=[1,2]; L[nil]=9;`, nil, errors.New(`[1:12] index/key is nil`)},
-		// /*  8 */ {`[int(x)|x=csv("test.csv",1,all(),1)]`, []any{int64(10), int64(40), int64(20)}, nil},
-		// /*  9 */ {`sum(@[int(x)|x=csv("test.csv",1,all(),1)])`, []any{int64(10), int64(40), int64(20)}, nil},
-	}
-
-	// t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 17)
-	parserTest(t, section, inputs)
-	return
-	succeeded := 0
-	failed := 0
-
-	// inputs1 := []inputType{
-	// 	/*  7 */ {`add([1,4,3,2])`, int64(10), nil},
-	// }
-
-	for i, input := range inputs {
-		var expr *ast
-		var gotResult any
-		var gotErr error
-
-		ctx := NewSimpleStore()
-		ImportMathFuncs(ctx)
-		parser := NewParser(ctx)
-
-		logTest(t, i+1, "List", input.source, input.wantResult, input.wantErr)
-
-		r := strings.NewReader(input.source)
-		scanner := NewScanner(r, DefaultTranslations())
-
-		good := true
-		if expr, gotErr = parser.Parse(scanner); gotErr == nil {
-			gotResult, gotErr = expr.Eval(ctx)
-		}
-
-		if (gotResult == nil && input.wantResult != nil) || (gotResult != nil && input.wantResult == nil) {
-			t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-			good = false
-		}
-
-		if gotList, okGot := gotResult.([]any); okGot {
-			if wantList, okWant := input.wantResult.([]any); okWant {
-				if (gotList == nil && wantList != nil) || (gotList != nil && wantList == nil) {
-					t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-					good = false
-				} else {
-					equal := len(gotList) == len(wantList)
-					if equal {
-						for i, gotItem := range gotList {
-							wantItem := wantList[i]
-							equal = gotItem == wantItem
-							if !equal {
-								break
-							}
-						}
-					}
-					if !equal {
-						t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-						good = false
-					}
-				}
-			}
-		}
-
-		if gotErr != input.wantErr {
-			if input.wantErr == nil || gotErr == nil || (gotErr.Error() != input.wantErr.Error()) {
-				t.Errorf("%d: %q  -> err = <%v>, want <%v>", i+1, input.source, gotErr, input.wantErr)
-				good = false
-			}
-		}
-
-		if good {
-			succeeded++
-		} else {
-			failed++
-		}
-	}
-	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
-}

t_module-register_test.go

@@ -1,31 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_module-register_test.go
-package expr
-
-import (
-	"testing"
-)
-
-func TestIterateModules(t *testing.T) {
-	section := "Module-Register"
-
-	mods := make([]string, 0, 100)
-	IterateModules(func(name, description string, imported bool) bool {
-		mods = append(mods, name)
-		return true
-	})
-
-	t.Logf("%s -- IterateModules(): %v", section, mods)
-	if len(mods) == 0 {
-		t.Errorf("Module-List: got-length zero, expected-length greater than zero")
-	}
-
-	// IterateModules(func(name, description string, imported bool) bool {
-	// 	return false
-	// })
-	// if len(mods) > 0 {
-	// 	t.Errorf("Module-List: got-length greater than zero, expected-length zero")
-	// }
-}

t_parser_test.go

@@ -1,225 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_parser_test.go
-package expr
-
-import (
-	"errors"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-type inputType struct {
-	source     string
-	wantResult any
-	wantErr    error
-}
-
-func TestGeneralParser(t *testing.T) {
-	section := "Parser"
-
-	inputs := []inputType{
-		/*   1 */ {`1+/*5*/2`, int64(3), nil},
-		/*   2 */ {`3 == 4`, false, nil},
-		/*   3 */ {`3 != 4`, true, nil},
-		/*   4 */ {`4 == (3-1)*(10/5)`, true, nil},
-		/*   5 */ {`3 <= 4`, true, nil},
-		/*   6 */ {`3 < 4`, true, nil},
-		/*   7 */ {`4 < 3`, false, nil},
-		/*   8 */ {`1+5 < 4`, false, nil},
-		/*   9 */ {`3 > 4`, false, nil},
-		/*  10 */ {`4 >= 4`, true, nil},
-		/*  11 */ {`4 > 3`, true, nil},
-		/*  12 */ {`1+5 > 4`, true, nil},
-		/*  13 */ {`true`, true, nil},
-		/*  14 */ {`not true`, false, nil},
-		/*  15 */ {`true and false`, false, nil},
-		/*  16 */ {`true or false`, true, nil},
-		/*  *17 */ {`"uno" + "due"`, `unodue`, nil},
-		/*  *18 */ {`"uno" + 2`, `uno2`, nil},
-		/*  *19 */ {`"uno" + (2+1)`, `uno3`, nil},
-		/*  *20 */ {`"uno" * (2+1)`, `unounouno`, nil},
-		/*  21 */ {"1", int64(1), nil},
-		/*  22 */ {"1.5", float64(1.5), nil},
-		/*  23 */ {"1.5*2", float64(3.0), nil},
-		/*  24 */ {"+1", int64(1), nil},
-		/*  25 */ {"-1", int64(-1), nil},
-		/*  26 */ {"435 + 105 * 2 - 1", int64(644), nil},
-		/*  27 */ {"200 / 2 - 1", int64(99), nil},
-		/*  28 */ {"(1+1)", int64(2), nil},
-		/*  29 */ {"-(1+1)", int64(-2), nil},
-		/*  30 */ {"-(-2+1)", int64(1), nil},
-		/*  31 */ {"(1+1)*5", int64(10), nil},
-		/*  32 */ {"200 / (1+1) - 1", int64(99), nil},
-		/*  33 */ {`1+(1+(1+(1)+1)+1)+1`, int64(7), nil},
-		/*  34 */ {`(((1)))`, int64(1), nil},
-		/*  35 */ {`var2="abc"; "uno_" + var2`, `uno_abc`, nil},
-		/*  36 */ {`0 || 0.0 && "hello"`, false, nil},
-		/*  37 */ {`"s" + true`, nil, errors.New(`[1:6] left operand 's' [string] and right operand 'true' [bool] are not compatible with operator "+"`)},
-		/*  38 */ {`+false`, nil, errors.New(`[1:2] prefix/postfix operator "+" do not support operand 'false' [bool]`)},
-		/*  39 */ {`false // very simple expression`, false, nil},
-		/*  40 */ {`1 + // Missing right operator`, nil, errors.New(`[1:4] infix operator "+" requires two non-nil operands, got 1`)},
-		/*  41 */ {"", nil, nil},
-		/*  42 */ {"4!", int64(24), nil},
-		/*  43 */ {"(-4)!", nil, errors.New(`factorial of a negative integer (-4) is not allowed`)},
-		/*  44 */ {"-4!", int64(-24), nil},
-		/*  45 */ {"1.5 < 7", true, nil},
-		/*  46 */ {"1.5 > 7", false, nil},
-		/*  47 */ {"1.5 <= 7", true, nil},
-		/*  48 */ {"1.5 >= 7", false, nil},
-		/*  49 */ {"1.5 != 7", true, nil},
-		/*  50 */ {"1.5 == 7", false, nil},
-		/*  51 */ {`"1.5" < "7"`, true, nil},
-		/*  52 */ {`"1.5" > "7"`, false, nil},
-		/*  53 */ {`"1.5" == "7"`, false, nil},
-		/*  54 */ {`"1.5" != "7"`, true, nil},
-		/*  55 */ {"1.5 < ", nil, errors.New(`[1:6] infix operator "<" requires two non-nil operands, got 1`)},
-		/*  56 */ {"1.5 > ", nil, errors.New(`[1:6] infix operator ">" requires two non-nil operands, got 1`)},
-		/*  57 */ {"1.5 <= ", nil, errors.New(`[1:6] infix operator "<=" requires two non-nil operands, got 1`)},
-		/*  58 */ {"1.5 >= ", nil, errors.New(`[1:6] infix operator ">=" requires two non-nil operands, got 1`)},
-		/*  59 */ {"1.5 != ", nil, errors.New(`[1:6] infix operator "!=" requires two non-nil operands, got 1`)},
-		/*  60 */ {"1.5 == ", nil, errors.New(`[1:6] infix operator "==" requires two non-nil operands, got 1`)},
-		/*  61 */ {`"1.5" < `, nil, errors.New(`[1:8] infix operator "<" requires two non-nil operands, got 1`)},
-		/*  62 */ {`"1.5" > `, nil, errors.New(`[1:8] infix operator ">" requires two non-nil operands, got 1`)},
-		/*  63 */ {`"1.5" == `, nil, errors.New(`[1:8] infix operator "==" requires two non-nil operands, got 1`)},
-		/*  64 */ {`"1.5" != `, nil, errors.New(`[1:8] infix operator "!=" requires two non-nil operands, got 1`)},
-		/*  65 */ {"+1.5", float64(1.5), nil},
-		/*  66 */ {"+", nil, errors.New(`[1:2] prefix operator "+" requires one not nil operand`)},
-		/*  67 */ {"4 / 0", nil, errors.New(`division by zero`)},
-		/*  68 */ {"4.0 / 0", nil, errors.New(`division by zero`)},
-		/*  69 */ {"4.0 / \n2", float64(2.0), nil},
-		/*  70 */ {`123`, int64(123), nil},
-		/*  71 */ {`1.`, float64(1.0), nil},
-		/*  72 */ {`1.E-2`, float64(0.01), nil},
-		/*  73 */ {`1E2`, float64(100), nil},
-		/*  74 */ {`1 / 2`, int64(0), nil},
-		/*  75 */ {`1.0 / 2`, float64(0.5), nil},
-		/*  76 */ {`1 ./ 2`, float64(0.5), nil},
-		/*  77 */ {`5 % 2`, int64(1), nil},
-		/*  78 */ {`5 % (-2)`, int64(1), nil},
-		/*  79 */ {`-5 % 2`, int64(-1), nil},
-		/*  80 */ {`5 % 2.0`, nil, errors.New(`[1:4] left operand '5' [integer] and right operand '2' [float] are not compatible with operator "%"`)},
-		/*  81 */ {`"a" < "b" AND NOT (2 < 1)`, true, nil},
-		/*  82 */ {`"a" < "b" AND NOT (2 == 1)`, true, nil},
-		/*  83 */ {`"a" < "b" AND ~ 2 == 1`, true, nil},
-		/*  84 */ {`~ 2 > 1`, false, nil},
-		/*  85 */ {`~ true && true`, false, nil},
-		/*  86 */ {`~ false || true`, true, nil},
-		/*  87 */ {`false but true`, true, nil},
-		/*  88 */ {`2+3 but 5*2`, int64(10), nil},
-		/*  89 */ {`x=2`, int64(2), nil},
-		/*  90 */ {`x=2 but x*10`, int64(20), nil},
-		/*  91 */ {`false and true`, false, nil},
-		/*  92 */ {`false and (x==2)`, false, nil},
-		/*  93 */ {`false and (x=2 but x==2) or x==2`, nil, errors.New(`undefined variable or function "x"`)},
-		/*  94 */ {`false or true`, true, nil},
-		/*  95 */ {`false or (x==2)`, nil, errors.New(`undefined variable or function "x"`)},
-		/*  96 */ {`a=5; a`, int64(5), nil},
-		/*  97 */ {`2=5`, nil, errors.New(`[1:2] left operand of "=" must be a variable or a collection's item`)},
-		/*  98 */ {`2+a=5`, nil, errors.New(`[1:3] left operand of "=" must be a variable or a collection's item`)},
-		/*  99 */ {`2+(a=5)`, int64(7), nil},
-		/* 100 */ {`x ?? "default"`, "default", nil},
-		/* 101 */ {`x="hello"; x ?? "default"`, "hello", nil},
-		/* 102 */ {`y=x ?? func(){4}; y()`, int64(4), nil},
-		/* 103 */ {`x ?= "default"; x`, "default", nil},
-		/* 104 */ {`x="hello"; x ?= "default"; x`, "hello", nil},
-		/* 105 */ {`1 ? {"a"} : {"b"}`, "b", nil},
-		/* 106 */ {`10 ? {"a"} : {"b"} :: {"c"}`, "c", nil},
-		/* 107 */ {`10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}`, "b", nil},
-		/* 108 */ {`10 ? {"a"} :[true, 2+8] {"b"} ::[10] {"c"}`, nil, errors.New(`[1:34] case list in default clause`)},
-		/* 109 */ {`10 ? {"a"} :[10] {x="b" but x} :: {"c"}`, "b", nil},
-		/* 110 */ {`10 ? {"a"} :[10] {x="b"; x} :: {"c"}`, "b", nil},
-		/* 111 */ {`10 ? {"a"} : {"b"}`, nil, errors.New(`[1:3] no case catches the value (10) of the selection expression`)},
-		/* 112 */ {`10 ? {"a"} :: {"b"} : {"c"}`, nil, errors.New(`[1:22] selector-case outside of a selector context`)},
-		/* 113 */ {`1 ? {"a"} : {"b"} ? ["a"] {"A"} :["b"] {"B"}`, "B", nil},
-		/* 114 */ {`2 + 1 ? {"a"} : {"b"} * 3`, "2bbb", nil},
-		/* 115 */ {`nil`, nil, nil},
-		/* 116 */ {`null`, nil, errors.New(`undefined variable or function "null"`)},
-		/* 117 */ {`{"key"}`, nil, errors.New(`[1:8] expected ":", got "}"`)},
-		/* 118 */ {`{"key":}`, nil, errors.New(`[1:9] expected "dictionary-value", got "}"`)},
-		/* 119 */ {`{}`, &DictType{}, nil},
-		/* 120 */ {`v=10; v++; v`, int64(11), nil},
-		/* 121 */ {`1+1|2+0.5`, float64(2), nil},
-		/* 122 */ {`1.2()`, newFraction(6, 5), nil},
-		/* 123 */ {`1|(2-2)`, nil, errors.New(`division by zero`)},
-	}
-
-	// t.Setenv("EXPR_PATH", ".")
-	// parserTestSpec(t, section, inputs, 102)
-	parserTest(t, section, inputs)
-}
-
-func parserTestSpec(t *testing.T, section string, inputs []inputType, spec ...int) {
-	succeeded := 0
-	failed := 0
-	for _, count := range spec {
-		good := doTest(t, section, &inputs[count-1], count)
-
-		if good {
-			succeeded++
-		} else {
-			failed++
-		}
-	}
-	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(spec), succeeded, failed)
-}
-
-func parserTest(t *testing.T, section string, inputs []inputType) {
-
-	succeeded := 0
-	failed := 0
-
-	for i, input := range inputs {
-		good := doTest(t, section, &input, i+1)
-		if good {
-			succeeded++
-		} else {
-			failed++
-		}
-	}
-	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
-}
-
-func doTest(t *testing.T, section string, input *inputType, count int) (good bool) {
-	var expr Expr
-	var gotResult any
-	var gotErr error
-
-	ctx := NewSimpleStore()
-	parser := NewParser(ctx)
-
-	logTest(t, count, section, input.source, input.wantResult, input.wantErr)
-
-	r := strings.NewReader(input.source)
-	scanner := NewScanner(r, DefaultTranslations())
-
-	good = true
-	if expr, gotErr = parser.Parse(scanner); gotErr == nil {
-		gotResult, gotErr = expr.Eval(ctx)
-	}
-
-	eq := reflect.DeepEqual(gotResult, input.wantResult)
-
-	if !eq /*gotResult != input.wantResult*/ {
-		t.Errorf("%d: %q -> result = %v [%s], want = %v [%s]", count, input.source, gotResult, typeName(gotResult), input.wantResult, typeName(input.wantResult))
-		good = false
-	}
-
-	if gotErr != input.wantErr {
-		if input.wantErr == nil || gotErr == nil || (gotErr.Error() != input.wantErr.Error()) {
-			t.Errorf("%d: %q -> got-err = <%v>, expected-err = <%v>", count, input.source, gotErr, input.wantErr)
-			good = false
-		}
-	}
-	return
-}
-
-func logTest(t *testing.T, n int, section, source string, wantResult any, wantErr error) {
-	if wantErr == nil {
-		t.Logf("[+]%s nr %3d -- %q  --> %v", section, n, source, wantResult)
-	} else {
-		t.Logf("[-]%s nr %3d -- %q  --> %v", section, n, source, wantErr)
-	}
-}

t_relational_test.go

@@ -1,52 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_template_test.go
-package expr
-
-import (
-	"testing"
-)
-
-func TestRelational(t *testing.T) {
-	section := "Relational"
-	inputs := []inputType{
-		/*   1 */ {`1 == 3-2`, true, nil},
-		/*   2 */ {`"a" == "a"`, true, nil},
-		/*   3 */ {`true == false`, false, nil},
-		/*   4 */ {`1.0 == 3.0-2`, true, nil},
-		/*   5 */ {`[1,2] == [2,1]`, false, nil},
-		/*   6 */ {`1 != 3-2`, false, nil},
-		/*   7 */ {`"a" != "a"`, false, nil},
-		/*   8 */ {`true != false`, true, nil},
-		/*   9 */ {`1.0 != 3.0-2`, false, nil},
-		/*  10 */ {`[1,2] != [2,1]`, true, nil},
-		/*  11 */ {`1|2 == 1|3`, false, nil},
-		/*  12 */ {`1|2 != 1|3`, true, nil},
-		/*  13 */ {`1|2 == 4|8`, true, nil},
-		/*  14 */ {`1 < 8`, true, nil},
-		/*  15 */ {`1 <= 8`, true, nil},
-		/*  16 */ {`"a" < "b"`, true, nil},
-		/*  17 */ {`"a" <= "b"`, true, nil},
-		/*  18 */ {`1.0 < 8`, true, nil},
-		/*  19 */ {`1.0 <= 8`, true, nil},
-		/*  20 */ {`1.0 <= 1.0`, true, nil},
-		/*  21 */ {`1.0 == 1`, true, nil},
-		/*  22 */ {`1|2 < 1|3`, false, nil},
-		/*  23 */ {`1|2 <= 1|3`, false, nil},
-		/*  24 */ {`1|2 > 1|3`, true, nil},
-		/*  25 */ {`1|2 >= 1|3`, true, nil},
-		/*  26 */ {`[1,2,3] > [2]`, true, nil},
-		/*  27 */ {`[1,2,3] > [9]`, false, nil},
-		/*  28 */ {`[1,2,3] >= [6]`, false, nil},
-		/*  29 */ {`[1,2,3] >= [2,6]`, false, nil},
-		/*  30 */ {`[1,[2,3],4] > [[3,2]]`, true, nil},
-		/*  31 */ {`[1,[2,[3,4]],5] > [[[4,3],2]]`, true, nil},
-		/*  32 */ {`[[4,3],2] IN [1,[2,[3,4]],5]`, true, nil},
-	}
-
-	// t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 31)
-	parserTest(t, section, inputs)
-}

t_strings_test.go

@@ -1,21 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_strings_test.go
-package expr
-
-import (
-	"testing"
-)
-
-func TestStringsParser(t *testing.T) {
-	inputs := []inputType{
-		/*  1 */ {`"uno" + "due"`, `unodue`, nil},
-		/*  2 */ {`"uno" + 2`, `uno2`, nil},
-		/*  3 */ {`"uno" + (2+1)`, `uno3`, nil},
-		/*  4 */ {`"uno" * (2+1)`, `unounouno`, nil},
-		/*  5 */ {`"abc"[1]`, `b`, nil},
-		/*  6 */ {`#"abc"`, int64(3), nil},
-	}
-	parserTest(t, "String", inputs)
-}

t_template_test.go

@@ -1,21 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_template_test.go
-package expr
-
-import (
-	"testing"
-)
-
-func TestSomething(t *testing.T) {
-	section := "Something"
-	inputs := []inputType{
-		/*   1 */ {`1`, int64(1), nil},
-	}
-
-	// t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 1)
-	parserTest(t, section, inputs)
-}

t_utils_test.go

@@ -1,156 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_utils_test.go
-package expr
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestIsString(t *testing.T) {
-	count := 0
-	succeeded := 0
-	failed := 0
-
-	count++
-	if !IsBool(true) {
-		t.Errorf("%d: IsBool(true) -> result = false, want true", count)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	if !IsString("abc") {
-		t.Errorf("%d: IsString(\"abc\") -> result = false, want true", count)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	if !IsInteger(int64(123)) {
-		t.Errorf("%d: IsInteger(123) -> result = false, want true", count)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	if !IsFloat(1.23) {
-		t.Errorf("%d: IsFloat(1.23) -> result = false, want true", count)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	if !IsFloat(numAsFloat(123)) {
-		t.Errorf("%d: IsFloat(numAsFloat(123)) -> result = false, want true", count)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	if isIterator("fake") {
-		t.Errorf(`%d: isIterator("fake") -> result = true, want false`, count)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	b, ok := toBool(true)
-	if !(ok && b) {
-		t.Errorf("%d: toBool(true) b=%v, ok=%v -> result = false, want true", count, b, ok)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	b, ok = toBool("abc")
-	if !(ok && b) {
-		t.Errorf("%d: toBool(\"abc\") b=%v, ok=%v -> result = false, want true", count, b, ok)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	b, ok = toBool([]int{})
-	if ok {
-		t.Errorf("%d: toBool([]) b=%v, ok=%v -> result = true, want false", count, b, ok)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	t.Logf("test count: %d, succeeded count: %d, failed count: %d", count, succeeded, failed)
-}
-
-func TestToIntOk(t *testing.T) {
-	source := int64(64)
-	wantValue := int(64)
-	wantErr := error(nil)
-
-	gotValue, gotErr := toInt(source, "test")
-
-	if gotErr != nil || gotValue != wantValue {
-		t.Errorf("toInt(%v, \"test\") gotValue=%v, gotErr=%v -> wantValue=%v, wantErr=%v",
-			source, gotValue, gotErr, wantValue, wantErr)
-	}
-}
-
-func TestToIntErr(t *testing.T) {
-	source := uint64(64)
-	wantValue := 0
-	wantErr := errors.New(`test expected integer, got uint64 (64)`)
-
-	gotValue, gotErr := toInt(source, "test")
-
-	if gotErr.Error() != wantErr.Error() || gotValue != wantValue {
-		t.Errorf("toInt(%v, \"test\") gotValue=%v, gotErr=%v -> wantValue=%v, wantErr=%v",
-			source, gotValue, gotErr, wantValue, wantErr)
-	}
-}
-
-func TestAnyInteger(t *testing.T) {
-	type inputType struct {
-		source    any
-		wantValue int64
-		wantOk    bool
-	}
-	section := "utils.anyInteger"
-
-	inputs := []inputType{
-		/*  1 */ {int8(-8), int64(-8), true},
-		/*  2 */ {int16(-16), int64(-16), true},
-		/*  3 */ {int32(-32), int64(-32), true},
-		/*  4 */ {int64(-64), int64(-64), true},
-		/*  5 */ {uint8(8), int64(8), true},
-		/*  6 */ {uint16(16), int64(16), true},
-		/*  7 */ {uint32(32), int64(32), true},
-		/*  8 */ {uint64(64), int64(64), true},
-		/*  9 */ {int(-1), int64(-1), true},
-		/* 10 */ {true, 0, false},
-	}
-
-	succeeded := 0
-	failed := 0
-
-	for i, input := range inputs {
-		gotValue, gotOk := anyInteger(input.source)
-		if gotOk != input.wantOk || gotValue != input.wantValue {
-			t.Errorf("%d: anyInteger(%v) -> gotOk = %t, wantOk = %t; gotValue = %v, wantValue = %v",
-				i+1, input.source, gotOk, input.wantOk, gotValue, input.wantValue)
-			failed++
-		} else {
-			succeeded++
-		}
-	}
-	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
-}

term-constuctor-registry.go

@@ -17,10 +17,11 @@ func registerTermConstructor(sym Symbol, constructor termContructor) {
 	constructorRegistry[sym] = constructor
 }
 
-func newTerm(tk *Token) (inst *term) {
+func newTerm(tk *Token, parent *term) (inst *term) {
 	if constructorRegistry != nil {
 		if construct, exists := constructorRegistry[tk.Sym]; exists {
 			inst = construct(tk)
+			inst.setParent(parent)
 		}
 	}
 	return

term.go

@@ -12,7 +12,6 @@ type termPriority uint32
 
 const (
 	priNone termPriority = iota
-	priRange
 	priBut
 	priAssign
 	priOr
@@ -21,13 +20,10 @@ const (
 	priRelational
 	priSum
 	priProduct
-	priFraction
 	priSelector
 	priSign
 	priFact
-	priIterValue
 	priCoalesce
-	priIncDec
 	priDot
 	priValue
 )
@@ -131,10 +127,6 @@ func (self *term) setParent(parent *term) {
 	}
 }
 
-func (self *term) symbol() Symbol {
-	return self.tk.Sym
-}
-
 func (self *term) source() string {
 	return self.tk.source
 }
@@ -152,31 +144,18 @@ func (self *term) compute(ctx ExprContext) (v any, err error) {
 	return
 }
 
-func (self *term) toInt(computedValue any, valueDescription string) (i int, err error) {
-	if index64, ok := computedValue.(int64); ok {
-		i = int(index64)
-	} else {
-		err = self.Errorf("%s, got %s (%v)", valueDescription, typeName(computedValue), computedValue)
-	}
-	return
-}
-
 func (self *term) errIncompatibleTypes(leftValue, rightValue any) error {
-	leftType := typeName(leftValue)
-	leftText := getFormatted(leftValue, Truncate)
-	rightType := typeName(rightValue)
-	rightText := getFormatted(rightValue, Truncate)
 	return self.tk.Errorf(
-		"left operand '%s' [%s] and right operand '%s' [%s] are not compatible with operator %q",
+		"left operand '%v' [%T] and right operand '%v' [%T] are not compatible with operator %q",
-		leftText, leftType,
+		leftValue, leftValue,
-		rightText, rightType,
+		rightValue, rightValue,
 		self.source())
 }
 
 func (self *term) errIncompatibleType(value any) error {
 	return self.tk.Errorf(
-		"prefix/postfix operator %q do not support operand '%v' [%s]",
+		"prefix/postfix operator %q do not support operand '%v' [%T]",
-		self.source(), value, typeName(value))
+		self.source(), value, value)
 }
 
 func (self *term) Errorf(template string, args ...any) (err error) {
@@ -223,18 +202,9 @@ func (self *term) evalInfix(ctx ExprContext) (leftValue, rightValue any, err err
 	return
 }
 
-func (self *term) evalPrefix(ctx ExprContext) (childValue any, err error) {
+func (self *term) evalPrefix(ctx ExprContext) (rightValue any, err error) {
 	if err = self.checkOperands(); err == nil {
-		childValue, err = self.children[0].compute(ctx)
+		rightValue, err = self.children[0].compute(ctx)
 	}
 	return
 }
-
-// NOTE Temporary solution to support function parameters with default value
-
-func (self *term) forceChild(c *term) {
-	if self.children == nil {
-		self.children = make([]*term, 0, 1)
-	}
-	self.children = append(self.children, c)
-}

term_test.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// t_term_test.go
+// term_test.go
 package expr
 
 import (
@@ -31,7 +31,6 @@ func TestGetRoom(t *testing.T) {
 		t.Errorf("err: got <%v>, want <nil>", gotErr)
 	}
 }
-
 func TestGetChildrenCount(t *testing.T) {
 	tk1 := NewValueToken(0, 0, SymInteger, "100", 100)
 

test-file.txt

@@ -1,2 +0,0 @@
-uno
-due

token.go

@@ -46,7 +46,7 @@ func NewValueToken(row, col int, sym Symbol, source string, value any) *Token {
 
 func NewErrorToken(row, col int, err error) *Token {
 	if err == io.EOF {
-		return NewToken(row, col, SymEos, "<EOF>")
+		return NewToken(row, col, SymEos, "")
 	}
 	return NewValueToken(row, col, SymError, fmt.Sprintf("[%d:%d]", row, col), err)
 }
@@ -63,10 +63,6 @@ func (tk *Token) IsTerm(termSymbols []Symbol) bool {
 	return tk.IsEos() || tk.IsError() || (termSymbols != nil && slices.Index(termSymbols, tk.Sym) >= 0)
 }
 
-func (tk *Token) IsSymbol(sym Symbol) bool {
-	return tk.Sym == sym
-}
-
 func (self *Token) Errorf(template string, args ...any) (err error) {
 	err = fmt.Errorf(fmt.Sprintf("[%d:%d] ", self.row, self.col)+template, args...)
 	return
@@ -85,13 +81,3 @@ func (self *Token) Errors(msg string) (err error) {
 	err = fmt.Errorf("[%d:%d] %v", self.row, self.col, msg)
 	return
 }
-
-func (self *Token) ErrorExpectedGot(symbol string) (err error) {
-	err = fmt.Errorf("[%d:%d] expected %q, got %q", self.row, self.col, symbol, self)
-	return
-}
-
-func (self *Token) ErrorExpectedGotString(symbol, got string) (err error) {
-	err = fmt.Errorf("[%d:%d] expected %q, got %q", self.row, self.col, symbol, got)
-	return
-}

token_test.go

@@ -1,11 +1,10 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// t_token_test.go
+// token_test.go
 package expr
 
 import (
-	"fmt"
 	"testing"
 )
 
@@ -18,8 +17,8 @@ func TestDevString(t *testing.T) {
 	}
 
 	inputs := []inputType{
-		/*   1 */ {"100", SymInteger, 100, fmt.Sprintf(`[%d]"100"{100}`, SymInteger)},
+		/*   1 */ {"100", SymInteger, 100, `[55]"100"{100}`},
-		/*   2 */ {"+", SymPlus, nil, fmt.Sprintf(`[%d]"+"{}`, SymPlus)},
+		/*   2 */ {"+", SymPlus, nil, `[6]"+"{}`},
 	}
 
 	for i, input := range inputs {

tools/func-bolerplate.bash

@@ -1,71 +0,0 @@
-#!/usr/bin/env bash
-
-if [ $# -lt 2 ]; then
-	echo >&2 "Usage: $(basename "${0}") <module-name> <func-name>..."
-	exit 1
-fi
-
-MODULE_NAME=${1,,}
-GO_FILE="func-${MODULE_NAME//[-.]/_}.go"
-
-shift
-FUNC_LIST=
-i=0
-for name; do
-	if [ ${i} -gt 0 ]; then
-		if [ $((i+1)) -eq $# ]; then
-			FUNC_LIST+=" and "
-		else
-			FUNC_LIST+=", "
-		fi
-	fi
-	FUNC_LIST+="${name}()"
-	((i++))
-done
-
-cat > "${GO_FILE}" <<EOF
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// func-${MODULE_NAME}.go
-package expr
-
-import (
-)
-
-
-// --- Start of function definitions
-
-$(
-for name; do
-	cat <<IEOF
-func ${name}Func(ctx ExprContext, name string, args []any) (result any, err error) {
-        return
-}
-
-IEOF
-
-done
-)
-
-// --- End of function definitions
-
-// Import above functions in the context
-func Import${MODULE_NAME^}Funcs(ctx ExprContext) {
-$(
-for name; do
-        cat <<IEOF
-        ctx.RegisterFunc("${name}", &simpleFunctor{f: ${name}Func}, 1, -1)
-IEOF
-
-done
-)
-}
-
-// Register the import function in the import-register.
-// That will allow to import all function of this module by the "builtin" operator."
-func init() {
-	registerImport("${MODULE_NAME}", Import${name}Funcs, "The \"${MODULE_NAME}\" module implements the ${FUNC_LIST} function(s)")
-}
-EOF
-

utils.go

@@ -4,84 +4,41 @@
 // utils.go
 package expr
 
-import (
+import "reflect"
-	"fmt"
-	"reflect"
-)
 
-func IsString(v any) (ok bool) {
+func isString(v any) (ok bool) {
 	_, ok = v.(string)
 	return ok
 }
 
-func IsInteger(v any) (ok bool) {
+func isInteger(v any) (ok bool) {
 	_, ok = v.(int64)
 	return ok
 }
 
-func IsFloat(v any) (ok bool) {
+func isFloat(v any) (ok bool) {
 	_, ok = v.(float64)
 	return ok
 }
 
-func IsBool(v any) (ok bool) {
+func isList(v any) (ok bool) {
-	_, ok = v.(bool)
+	_, ok = v.([]any)
 	return ok
 }
 
-func IsList(v any) (ok bool) {
+func isNumber(v any) (ok bool) {
-	_, ok = v.(*ListType)
+	return isFloat(v) || isInteger(v)
-	return ok
-}
-
-func IsDict(v any) (ok bool) {
-	_, ok = v.(*DictType)
-	return ok
-}
-
-func IsFract(v any) (ok bool) {
-	_, ok = v.(*FractionType)
-	return ok
-}
-
-func IsRational(v any) (ok bool) {
-	if _, ok = v.(*FractionType); !ok {
-		_, ok = v.(int64)
-	}
-	return ok
-}
-
-func IsNumber(v any) (ok bool) {
-	return IsFloat(v) || IsInteger(v)
-}
-
-func isNumOrFract(v any) (ok bool) {
-	return IsFloat(v) || IsInteger(v) || isFraction(v)
 }
 
 func isNumberString(v any) (ok bool) {
-	return IsString(v) || IsNumber(v)
+	return isString(v) || isNumber(v)
-}
-
-func isFunctor(v any) (ok bool) {
-	_, ok = v.(Functor)
-	return
-}
-
-func isIterator(v any) (ok bool) {
-	_, ok = v.(Iterator)
-	return
 }
 
 func numAsFloat(v any) (f float64) {
 	var ok bool
 	if f, ok = v.(float64); !ok {
-		if fract, ok := v.(*FractionType); ok {
+		i, _ := v.(int64)
-			f = fract.toFloat()
+		f = float64(i)
-		} else {
-			i, _ := v.(int64)
-			f = float64(i)
-		}
 	}
 	return
 }
@@ -147,12 +104,6 @@ func fromGenericAny(v any) (exprAny any, ok bool) {
 	if exprAny, ok = anyFloat(v); ok {
 		return
 	}
-	if exprAny, ok = v.(*DictType); ok {
-		return
-	}
-	if exprAny, ok = v.(*ListType); ok {
-		return
-	}
 	return
 }
 
@@ -180,42 +131,3 @@ func CloneMap[K comparable, V any](source map[K]V) map[K]V {
 	dest := make(map[K]V, len(source))
 	return CopyMap(dest, source)
 }
-
-func CopyFilteredMap[K comparable, V any](dest, source map[K]V, filter func(key K) (accept bool)) map[K]V {
-	// fmt.Printf("--- Clone with filter %p\n", filter)
-	if filter == nil {
-		return CopyMap(dest, source)
-	} else {
-		for k, v := range source {
-			if filter(k) {
-				// fmt.Printf("\tClone var %q\n", k)
-				dest[k] = v
-			}
-		}
-	}
-	return dest
-}
-
-func CloneFilteredMap[K comparable, V any](source map[K]V, filter func(key K) (accept bool)) map[K]V {
-	dest := make(map[K]V, len(source))
-	return CopyFilteredMap(dest, source, filter)
-}
-
-func toInt(value any, description string) (i int, err error) {
-	if valueInt64, ok := value.(int64); ok {
-		i = int(valueInt64)
-	} else if valueInt, ok := value.(int); ok {
-		i = valueInt
-	} else {
-		err = fmt.Errorf("%s expected integer, got %s (%v)", description, typeName(value), value)
-	}
-	return
-}
-
-func ForAll[T, V any](ts []T, fn func(T) V) []V {
-	result := make([]V, len(ts))
-	for i, t := range ts {
-		result[i] = fn(t)
-	}
-	return result
-}