t_iterator_test.go: Fixed test numbering and add a commentend test that is not yet fulfilled

Fix: the reset command set the initial item to the second one in the list

data-cursor.go

@@ -133,7 +133,7 @@ func (dc *dataCursor) Current() (item any, err error) { // must return io.EOF at
 	return
 }
 
-func (dc *dataCursor) Next() (item any, err error) { // must return io.EOF after the last item
+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))
@@ -153,6 +153,40 @@ func (dc *dataCursor) Next() (item any, err error) { // must return io.EOF after
 	return
 }
 
+const filterName = "filter"
+func (dc *dataCursor) filter(item any) (filterdItem any, err error) {
+	if filter, ok := dc.ds[filterName]; ok {
+		ctx := cloneContext(dc.ctx)
+		filterdItem, err = filter.Invoke(ctx, filterName, []any{item, dc.index});
+	} else {
+		filterdItem = item
+	}
+	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))
+		for item == nil && err == nil {
+			if item, err = dc.nextFunc.Invoke(ctx, nextName, []any{dc.resource}); err == nil {
+				if item == nil {
+					err = io.EOF
+				} else {
+					dc.index++
+					item, err = dc.filter(item)
+				}
+			}
+		}
+		// 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
 }

list-iterator.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// iter-list.go
+// list-iterator.go
 package expr
 
 import (
@@ -140,6 +140,6 @@ func (it *ListIterator) Index() int {
 }
 
 func (it *ListIterator) Reset() (bool, error) {
-	it.index = it.start
+	it.index = it.start - it.step
 	return true, nil
 }

operator-assign.go

@@ -76,14 +76,18 @@ func evalAssign(ctx ExprContext, opTerm *term) (v any, err error) {
 
 	if v, err = rightChild.compute(ctx); err == nil {
 		if functor, ok := v.(Functor); ok {
-			if info := functor.GetFunc(); info != nil {
-				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 })
+			if leftSym == SymVariable {
+				if info := functor.GetFunc(); info != nil {
+					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)
+					ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, paramSpecs)
+				} else {
+					err = opTerm.Errorf("unknown function %s()", rightChild.source())
+				}
 			} else {
-				err = opTerm.Errorf("unknown function %s()", rightChild.source())
+				err = assignValue(ctx, leftTerm, v)
 			}
 		} else {
 			err = assignValue(ctx, leftTerm, v)

t_funcs_test.go

@@ -30,12 +30,13 @@ func TestFuncs(t *testing.T) {
 		/*  17 */ {`f=func(x,n){1}; f(3,4,)`, nil, `[1:24] expected "function-param-value", got ")"`},
 		/*  18 */ {`factory=func(base){func(){@base=base+1}}; inc10=factory(10); inc5=factory(5); inc10(); inc5(); inc10()`, int64(12), nil},
 		/*  19 */ {`f=func(a,y=1,z="sos"){}; string(f)`, `f(a, y=1, z="sos"):any{}`, nil},
+//		/*  20 */ {`m={}; m["f"]=func(){3}; m["f"]()`, int64(3), nil},
 		// /*  18 */ {`f=func(a){a*2}`, nil, errors.New(`[1:24] expected "function-param-value", got ")"`)},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")
 
-	// runTestSuiteSpec(t, section, inputs, 17)
+	// runTestSuiteSpec(t, section, inputs, 20)
 	runTestSuite(t, section, inputs)
 }
 
@@ -52,6 +53,7 @@ func TestFunctionToStringSimple(t *testing.T) {
 	}
 }
 
+
 func TestFunctionGetFunc(t *testing.T) {
 	source := NewGolangFunctor(dummy)
 	want := ExprFunc(nil)

t_iterator_test.go

@@ -17,12 +17,12 @@ func TestIteratorParser(t *testing.T) {
 		/*   6 */ {`builtin "math.arith"; include "test-resources/iterator.expr"; it=$(ds,3); mul(it)`, int64(0), nil},
 		/*   7 */ {`builtin "math.arith"; include "test-resources/file-reader.expr"; it=$(ds,"test-resources/int.list"); mul(it)`, int64(12000), nil},
 		/*   8 */ {`include "test-resources/file-reader.expr"; it=$(ds,"test-resources/int.list"); it++; it.index`, int64(0), nil},
-		/*  10 */ {`include "test-resources/file-reader.expr"; it=$(ds,"test-resources/int.list"); it.clean`, true, nil},
-		/*  11 */ {`it=$(1,2,3); it++`, int64(1), nil},
+		/*   9 */ {`include "test-resources/file-reader.expr"; it=$(ds,"test-resources/int.list"); it.clean`, true, nil},
+		/*  10 */ {`it=$(1,2,3); it++`, int64(1), nil},
+		/*  11 */ {`it=$(1,2,3); it++; it.reset; it++`, int64(1), nil},
+//		/*  12 */ {`include "test-resources/filter.expr"; it=$(ds,10); it++`, int64(1), nil},
 	}
-	// inputs1 := []inputType{
-	// 	/*   1 */ {`0?{}`, nil, nil},
-	// }
-	// runTestSuiteSpec(t, section, inputs, 1)
+
+	//runTestSuiteSpec(t, section, inputs, 12)
 	runTestSuite(t, section, inputs)
 }

term.go

@@ -145,7 +145,7 @@ func (term *term) value() any {
 
 func (term *term) compute(ctx ExprContext) (v any, err error) {
 	if term.evalFunc == nil {
-		err = term.tk.Errorf("undefined eval-func for %q term", term.source())
+		err = term.Errorf("undefined eval-func for %q term", term.source())
 	} else {
 		v, err = term.evalFunc(ctx, term)
 	}