iter-iter: changed item operation from function and args to a list of expressions

iter-factory.go

@@ -5,13 +5,13 @@
 package expr
 
 import (
-	"fmt"
 	"slices"
 
 	"git.portale-stac.it/go-pkg/expr/kern"
+	"git.portale-stac.it/go-pkg/expr/scan"
 )
 
-func NewIterator(ctx kern.ExprContext, value any, args map[string]any) (it kern.Iterator, err error) {
+func NewIterator(ctx kern.ExprContext, value any, ops []*scan.Term) (it kern.Iterator, err error) {
 	if value == nil {
 		return NewArrayIterator([]any{}), nil
 	}
@@ -24,24 +24,21 @@ func NewIterator(ctx kern.ExprContext, value any, args map[string]any) (it kern.
 	case []any:
 		it = NewArrayIterator(v)
 	case kern.Iterator:
-		// it = v
+		// var exprs []*scan.Term
-		var op kern.Functor
+		it, err = NewIterIter(v, ctx, ops)
-		if len(args) >= 1 {
-			if opArg, ok := args["op"]; ok {
-				if op, ok = opArg.(kern.Functor); !ok {
-					err = fmt.Errorf("the 'op' argument must be a kern.Functor, got %T", opArg)
-				}
-			}
-		}
-		if err == nil {
-			it, err = NewIterIter(v, ctx, op, args)
-		}
 	default:
 		it = NewArrayIterator([]any{value})
 	}
 	return
 }
 
-func HasStandardOperation(name string) bool {
+func HasIterStandardOperations(name string) bool {
 	return slices.Contains([]string{kern.NextName, kern.ResetName, kern.IndexName, kern.CountName, kern.CurrentName, kern.CleanName}, name)
 }
+
+func HasIterOperations(name string, ops ...string) bool {
+	return slices.Contains([]string{
+		kern.NextName, kern.ResetName, kern.IndexName, kern.CountName, kern.CurrentName, kern.CleanName,
+	}, name) ||
+		slices.Contains(ops, name)
+}

iter-iter.go

@@ -9,6 +9,7 @@ import (
 	"io"
 
 	"git.portale-stac.it/go-pkg/expr/kern"
+	"git.portale-stac.it/go-pkg/expr/scan"
 )
 
 type IterIter struct {
@@ -16,26 +17,12 @@ type IterIter struct {
 	count    int64
 	index    int64
 	ctx      kern.ExprContext
-	op      kern.Functor
+	exprList []*scan.Term
-	opName  string
-	args    map[string]any
 	current  any
 }
 
-func NewIterIter(it kern.Iterator, ctx kern.ExprContext, op kern.Functor, args map[string]any) (iter kern.Iterator, err error) {
+func NewIterIter(it kern.Iterator, ctx kern.ExprContext, exprs []*scan.Term) (iter kern.Iterator, err error) {
-	var opName string
+	iter = &IterIter{it: it, count: 0, index: -1, ctx: ctx, exprList: exprs, current: nil}
-	if op != nil {
-		if f := op.GetFunc(); f != nil {
-			opName = f.Name()
-			// } else {
-			// 	return nil, fmt.Errorf("invalid functor argument for iter-iter: expected kern.Functor, got %T", args["op"])
-		}
-	}
-	if len(opName) == 0 {
-		opName = "anonymous"
-	}
-	iter = &IterIter{it: it, count: 0, index: -1, ctx: ctx, op: op, opName: opName, args: args}
-
 	return
 }
 
@@ -48,7 +35,7 @@ func (it *IterIter) TypeName() string {
 }
 
 func (it *IterIter) HasOperation(name string) bool {
-	return HasStandardOperation(name)
+	return HasIterStandardOperations(name)
 }
 
 func (it *IterIter) CallOperation(name string, args map[string]any) (v any, err error) {
@@ -74,9 +61,17 @@ func (it *IterIter) CallOperation(name string, args map[string]any) (v any, err
 func (it *IterIter) Current() (item any, err error) {
 	if it.current != nil {
 		item = it.current
-	} else if it.op != nil {
+	} else if len(it.exprList) > 0 {
-		if item, err = it.op.InvokeNamed(it.ctx, it.opName, it.args); err == nil {
+		// Evaluate the expression list and use the result as the current item
-			it.current = item
+		var exprValue any
+		for _, expr := range it.exprList {
+			if exprValue, err = expr.Compute(it.ctx); err != nil {
+				break
+			}
+			it.ctx.UnsafeSetVar(kern.ControlLastResult, exprValue)
+		}
+		if err == nil {
+			item = exprValue
 		}
 	} else {
 		var exists bool

operand-iterator.go

@@ -5,9 +5,7 @@
 package expr
 
 import (
-	"fmt"
 	"slices"
-	"strconv"
 	"strings"
 
 	"git.portale-stac.it/go-pkg/expr/kern"
@@ -144,60 +142,45 @@ func evalIterator(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		if args, err = evalSiblings(ctx, opTerm.Children, intVal); err == nil {
 			v, err = NewIntIterator(args)
 		}
+	} else if it, ok := firstChildValue.(kern.Iterator); ok {
+		v, err = NewIterIter(it, ctx, opTerm.Children[1:])
 	} else {
 		var siblings []any
 		if siblings, err = evalSiblings(ctx, opTerm.Children, firstChildValue); err == nil {
-			// if v, err = evalIterIter(ctx, firstChildValue, siblings); err == nil && v == nil {
-			// if it, ok := firstChildValue.(kern.Iterator); ok {
-			// 	if len(siblings) > 1 {
-			// 		if op, ok := siblings[1].(kern.Functor); ok {
-			// 			args := make(map[string]any, len(siblings)-2)
-			// 			for i, arg := range siblings[2:] {
-			// 				args["arg"+strconv.Itoa(i+1)] = arg
-			// 			}
-			// 			v, err = NewIterIter(it, ctx, op, args)
-			// 		} else {
-			// 			err = opTerm.Children[1].Errorf("the first sibling parameter must be a functor to be used as operation for the iterator")
-			// 		}
-			// 	} else {
-			// 		v, err = NewIterIter(it, ctx, nil, nil)
-			// 	}
-			if v, err = evalIterIter(ctx, firstChildValue, siblings); err == nil && v == nil {
 			v = NewArrayIterator(siblings)
 		}
 	}
-	}
 	return
 }
 
-func evalIterIter(ctx kern.ExprContext, firstChildValue any, siblings []any) (v any, err error) {
+// func evalIterIter(ctx kern.ExprContext, firstChildValue any, siblings []any) (v any, err error) {
-	var op kern.Functor
+// 	var op kern.Functor
-	var args map[string]any
+// 	var args map[string]any
 
-	if it, ok := firstChildValue.(kern.Iterator); ok {
+// 	if it, ok := firstChildValue.(kern.Iterator); ok {
-		if len(siblings) > 1 {
+// 		if len(siblings) > 1 {
-			if op, ok = siblings[1].(kern.Functor); ok {
+// 			if op, ok = siblings[1].(kern.Functor); ok {
-				args = make(map[string]any, len(siblings)-2)
+// 				args = make(map[string]any, len(siblings)-2)
-				for i, arg := range siblings[2:] {
+// 				for i, arg := range siblings[2:] {
-					switch a := arg.(type) {
+// 					switch a := arg.(type) {
-					case *kern.DictType:
+// 					case *kern.DictType:
-						for keyAny, item := range *a {
+// 						for keyAny, item := range *a {
-							if key, ok := keyAny.(string); ok {
+// 							if key, ok := keyAny.(string); ok {
-								args[key] = item
+// 								args[key] = item
-							}
+// 							}
-						}
+// 						}
-					default:
+// 					default:
-						args["arg"+strconv.Itoa(i+1)] = arg
+// 						args["arg"+strconv.Itoa(i+1)] = arg
-					}
+// 					}
-				}
+// 				}
-			} else if op == nil {
+// 			} else if op == nil {
-				return nil, fmt.Errorf("the first sibling parameter must be a functor to be used as operation for the iterator")
+// 				return nil, fmt.Errorf("the first sibling parameter must be a functor to be used as operation for the iterator")
-			}
+// 			}
-		}
+// 		}
-		v, err = NewIterIter(it, ctx, op, args)
+// 		v, err = NewIterIter(it, ctx, op, args)
-	}
+// 	}
-	return
+// 	return
-}
+// }
 
 func evalSiblings(ctx kern.ExprContext, terms []*scan.Term, firstChildValue any) (list []any, err error) {
 	items := make([]any, 0, len(terms))

operator-groupby.go

@@ -31,6 +31,7 @@ func evalGroupBy(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	var item any
 	var sKey string
 	var keyByIndex bool
+	var ok bool
 
 	if err = opTerm.CheckOperands(); err != nil {
 		return
@@ -40,9 +41,11 @@ func evalGroupBy(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		return
 	}
 
+	if it, ok = leftValue.(kern.Iterator); !ok {
 		if it, err = NewIterator(ctx, leftValue, nil); err != nil {
 			return nil, fmt.Errorf("left operand of MAP must be an iterable data-source; got %s", kern.TypeName(leftValue))
 		}
+	}
 
 	rightTk := opTerm.Children[1].Tk
 	if rightTk.IsSymbol(scan.SymVariable) && rightTk.Source() == "__" {

operator-join.go

@@ -28,6 +28,7 @@ func evalJoin(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	var leftValue, rightValue any
 	var itLeft, itRight kern.Iterator
 	var item any
+	var ok bool
 
 	if err = opTerm.CheckOperands(); err != nil {
 		return
@@ -41,13 +42,17 @@ func evalJoin(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		return
 	}
 
+	if itLeft, ok = leftValue.(kern.Iterator); !ok {
 		if itLeft, err = NewIterator(ctx, leftValue, nil); err != nil {
 			return nil, fmt.Errorf("left operand of JOIN must be an iterable data-source; got %s", kern.TypeName(leftValue))
 		}
+	}
 
+	if itRight, ok = rightValue.(kern.Iterator); !ok {
 		if itRight, err = NewIterator(ctx, rightValue, nil); err != nil {
 			return nil, fmt.Errorf("right operand of JOIN must be an iterable data-source; got %s", kern.TypeName(rightValue))
 		}
+	}
 
 	values := kern.NewListA()
 	for _, it := range []kern.Iterator{itLeft, itRight} {

operator-map.go

@@ -28,6 +28,7 @@ func evalMap(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	var leftValue, rightValue any
 	var it kern.Iterator
 	var item any
+	var ok bool
 
 	if err = opTerm.CheckOperands(); err != nil {
 		return
@@ -37,9 +38,11 @@ func evalMap(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		return
 	}
 
+	if it, ok = leftValue.(kern.Iterator); !ok {
 		if it, err = NewIterator(ctx, leftValue, nil); err != nil {
 			return nil, fmt.Errorf("left operand of MAP must be an iterable data-source; got %s", kern.TypeName(leftValue))
 		}
+	}
 
 	values := kern.NewListA()
 	for item, err = it.Next(); err == nil; item, err = it.Next() {

t_iter-iter_test.go

@@ -14,11 +14,12 @@ func TestIterIterator(t *testing.T) {
 	section := "Iterator"
 	inputs := []inputType{
 		/*   1 */ {`it=$(4); $(it) filter ${_}==100`, kern.NewListA(), nil},
-		/*   2 */ {`it=$(4); $(it, func(){$_}) filter ${_}==100`, kern.NewListA(), nil},
+		/*   2 */ {`it=$(4); $(it, $_) filter ${_}==100`, kern.NewListA(), nil},
-		/*   3 */ {`it=$(4); $(it, func(arg1){arg1+$_}, 10) filter ${_}==100`, kern.NewListA(), nil},
+		/*   3 */ {`it=$(4); $(it, 10+$_, last-1) digest ${_}`, int64(12), nil},
+		/*   4 */ {`f=func(n){last-n}; it=$(4); $(it, 10+$_, f(-1)) digest ${_}`, int64(14), nil},
 	}
 
-	runTestSuiteSpec(t, section, inputs, 3)
+	runTestSuiteSpec(t, section, inputs, 4)
 	// runTestSuite(t, section, inputs)
 }