The content of round bracket now returns an expressione term. This way the content is decoupled from external terms.

operand-expr.go

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

parser.go

@@ -277,6 +277,7 @@ func (self *parser) parseDictionary(scanner *scanner, allowVarRef bool) (subtree
 			err = scanner.Previous().ErrorExpectedGot("}")
 		} else {
 			subtree = newDictTerm(args)
+			// subtree = newMapTerm(args)
 		}
 	}
 	return
@@ -389,7 +390,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(subTree.root)
+				err = tree.addTerm(newExprTerm(subTree.root))
 				currentTerm = subTree.root
 			}
 		case SymFuncCall:

parser_test.go

@@ -137,7 +137,7 @@ func TestGeneralParser(t *testing.T) {
 		/* 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 */ {`{}`, map[any]any{}, nil},
+		/* 119 */ {`{}`, &DictType{}, nil},
 		/* 120 */ {`1|2`, newFraction(1, 2), nil},
 		/* 121 */ {`1|2 + 1`, newFraction(3, 2), nil},
 		/* 122 */ {`1|2 - 1`, newFraction(-1, 2), nil},