map, filter and cat return an iterator

operator-context.go

@@ -35,6 +35,8 @@ func evalContextValue(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error
 		if dc, ok := childValue.(*dataCursor); ok {
 			sourceCtx = dc.ctx
 		}
+	} else {
+		return
 	}
 
 	if sourceCtx != nil {

operator-filter.go

@@ -6,7 +6,6 @@ package expr
 
 import (
 	"fmt"
-	"io"
 
 	"git.portale-stac.it/go-pkg/expr/kern"
 	"git.portale-stac.it/go-pkg/expr/scan"
@@ -25,9 +24,10 @@ func newFilterTerm(tk *scan.Token) (inst *scan.Term) {
 }
 
 func evalFilter(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
-	var leftValue, rightValue any
+	// var leftValue, rightValue any
+	var leftValue any
 	var it kern.Iterator
-	var item any
+	// var item any
 	var ok bool
 
 	if err = opTerm.CheckOperands(); err != nil {
@@ -44,31 +44,120 @@ func evalFilter(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		}
 	}
 
-	values := kern.NewListA()
+	// values := kern.NewListA()
-	for item, err = it.Next(); err == nil; item, err = it.Next() {
+	// for item, err = it.Next(); err == nil; item, err = it.Next() {
-		ctx.SetVar("_", item)
+	// 	ctx.SetVar("_", item)
+	// 	ctx.SetVar("__", it.Index())
+	// 	ctx.SetVar("_#", it.Count())
+	// 	if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil {
+	// 		if success, valid := kern.ToBool(rightValue); valid {
+	// 			if success {
+	// 				values.AppendItem(item)
+	// 			}
+	// 		} else {
+	// 			err = fmt.Errorf("filter expression must return a boolean or a castable to boolean, got %v [%T]", rightValue, rightValue)
+	// 		}
+	// 	}
+	// 	ctx.DeleteVar("_#")
+	// 	ctx.DeleteVar("__")
+	// 	ctx.DeleteVar("_")
+	// 	if err != nil {
+	// 		break
+	// 	}
+	// }
+	// if err == io.EOF {
+	// 	err = nil
+	// }
+	// v = values
+
+	v = newFilerIterator(ctx, it, opTerm.Children[1])
+	return
+}
+
+const filterIteratorType = "filter"
+
+type filterIterator struct {
+	kern.IteratorBase
+	ctx   kern.ExprContext
+	itSrc kern.Iterator
+	expr  *scan.Term
+}
+
+func newFilerIterator(ctx kern.ExprContext, itSrc kern.Iterator, filterExpr *scan.Term) (it *filterIterator) {
+	it = &filterIterator{
+		IteratorBase: kern.IteratorBase{},
+		ctx:          ctx,
+		itSrc:        itSrc,
+		expr:         filterExpr,
+	}
+	it.IteratorBase.Reset()
+	return
+}
+
+func (it *filterIterator) TypeName() string {
+	return filterIteratorType
+}
+
+func (it *filterIterator) String() string {
+	return fmt.Sprintf("$(%s %s bool-expr)", it.itSrc, filterIteratorType)
+}
+
+func (it *filterIterator) Next() (item any, err error) {
+	var attempt, result any
+
+	ctx := it.ctx
+
+	for attempt, err = it.itSrc.Next(); err == nil; attempt, err = it.itSrc.Next() {
+		ctx.SetVar("_", attempt)
 		ctx.SetVar("__", it.Index())
 		ctx.SetVar("_#", it.Count())
-		if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil {
+		result, err = it.expr.Compute(ctx)
-			if success, valid := kern.ToBool(rightValue); valid {
-				if success {
-					values.AppendItem(item)
-				}
-			} else {
-				err = fmt.Errorf("filter expression must return a boolean or a castable to boolean, got %v [%T]", rightValue, rightValue)
-			}
-		}
 		ctx.DeleteVar("_#")
 		ctx.DeleteVar("__")
 		ctx.DeleteVar("_")
+
+		if err == nil {
+			if success, valid := kern.ToBool(result); valid {
+				if success {
+					item = attempt
+					break
+				}
+			} else {
+				err = fmt.Errorf("filter expression must return a boolean or a castable to boolean, got %v [%T]", result, result)
+			}
+		}
 		if err != nil {
 			break
 		}
 	}
-	if err == io.EOF {
+
-		err = nil
+	it.SetCurrent(item)
+	return
+}
+
+// func (it *filterIterator) Reset() (err error) {
+// 	err = it.itLeft.Reset()
+// 	it.IteratorBase.Reset()
+// 	return
+// }
+
+func (it *filterIterator) CallOperation(name string, args map[string]any) (v any, err error) {
+	switch name {
+	case kern.NextName:
+		v, err = it.Next()
+	// case kern.ResetName:
+	// 	err = it.Reset()
+	// case kern.CleanName:
+	// 	err = it.Clean()
+	case kern.IndexName:
+		v = it.Index()
+	case kern.CurrentName:
+		v, err = it.Current()
+	case kern.CountName:
+		v = it.Count()
+	default:
+		err = kern.ErrNoOperation(name)
 	}
-	v = values
 	return
 }
 

operator-map.go

@@ -6,7 +6,6 @@ package expr
 
 import (
 	"fmt"
-	"io"
 
 	"git.portale-stac.it/go-pkg/expr/kern"
 	"git.portale-stac.it/go-pkg/expr/scan"
@@ -25,9 +24,10 @@ func newMapTerm(tk *scan.Token) (inst *scan.Term) {
 }
 
 func evalMap(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
-	var leftValue, rightValue any
+	// var leftValue, rightValue any
+	var leftValue any
 	var it kern.Iterator
-	var item any
+	// var item any
 	var ok bool
 
 	if err = opTerm.CheckOperands(); err != nil {
@@ -44,27 +44,28 @@ func evalMap(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		}
 	}
 
-	values := kern.NewListA()
+	// values := kern.NewListA()
-	for item, err = it.Next(); err == nil; item, err = it.Next() {
+	// for item, err = it.Next(); err == nil; item, err = it.Next() {
-		ctx.SetVar("_", item)
+	// 	ctx.SetVar("_", item)
-		ctx.SetVar("__", it.Index())
+	// 	ctx.SetVar("__", it.Index())
-		ctx.SetVar("_#", it.Count())
+	// 	ctx.SetVar("_#", it.Count())
-		if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil {
+	// 	if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil {
-			values.AppendItem(rightValue)
+	// 		values.AppendItem(rightValue)
-		}
+	// 	}
-		ctx.DeleteVar("_#")
+	// 	ctx.DeleteVar("_#")
-		ctx.DeleteVar("__")
+	// 	ctx.DeleteVar("__")
-		ctx.DeleteVar("_")
+	// 	ctx.DeleteVar("_")
-		if err != nil {
+	// 	if err != nil {
-			break
+	// 		break
-		}
+	// 	}
-	}
+	// }
-	if err == io.EOF {
+	// if err == io.EOF {
-		err = nil
+	// 	err = nil
-	}
+	// }
-	if err == nil {
+	// if err == nil {
-		v = values
+	// 	v = values
-	}
+	// }
+	v, err = NewIterIter(it, ctx, opTerm.Children[1:])
 	return
 }
 

t_funcs_test.go

@@ -54,8 +54,7 @@ func TestFuncs2(t *testing.T) {
 	inputs := []inputType{
 		/*   1 */ {`sum=func(a,b){a+b}; sum(1,2)`, int64(3), nil},
 		/*   2 */ {`sum=func(a,b){a+b}; sum(1)`, nil, `sum(): too few params -- expected 2, got 1`},
-		/*   3 */ {`["1", "2", "3"] map int()`, nil, `int(): too few params -- expected 1, got 0`},
+		/*   3 */ {`builtin "iterator"; times=func(a,b){a*b}; run($(["1", "2", "3"]), times)`, nil, `operator(): missing params -- a, b`},
-		/*   4 */ {`builtin "iterator"; times=func(a,b){a*b}; run($(["1", "2", "3"]), times)`, nil, `operator(): missing params -- a, b`},
 	}
 	// runTestSuiteSpec(t, section, inputs, 4)
 	runTestSuite(t, section, inputs)

t_iterator_test.go

@@ -35,26 +35,60 @@ func TestIteratorParser(t *testing.T) {
 		/*  20 */ {`it=$({1:"one",2:"two",3:"three"}, "default", "value"); it++`, "one", nil},
 		/*  21 */ {`it=$({1:"one",2:"two",3:"three"}, "desc", "key"); it++`, int64(3), nil},
 		/*  22 */ {`it=$({1:"one",2:"two",3:"three"}, "asc", "item"); it++`, kern.NewList([]any{int64(1), "one"}), nil},
-		/*  23 */ {`builtin "os.file"; fileLineIterator("test-file.txt") map ${__}`, kern.NewList([]any{int64(0), int64(1)}), nil},
-		/*  24 */ {`builtin "os.file"; #(fileLineIterator("test-file.txt") filter (#${_} == 2))`, int64(0), nil},
-		/*  25 */ {`builtin "os.file"; #(fileLineIterator("test-file.txt") filter (#${_} == 3))`, int64(2), nil},
-		/*  26 */ {`#($(10) map ${_})`, int64(10), nil},
-		/*  27 */ {`#($(10,0) map ${_})`, int64(10), nil},
-		/*  28 */ {`$(10) digest ${_}`, int64(9), nil},
-		/*  29 */ {`$(10,0) digest ${_}`, int64(1), nil},
-		/*  30 */ {`$(10,0,-2) digest ${_}`, int64(2), nil},
-		/*  31 */ {`[3,4,5] map ${_#}`, kern.NewList([]any{int64(1), int64(2), int64(3)}), nil},
 	}
 
 	// runTestSuiteSpec(t, section, inputs, 10)
 	runTestSuite(t, section, inputs)
 }
 
-func TestCatIterator(t *testing.T) {
+func TestFilterIterator(t *testing.T) {
-	section := "Iterator"
+	section := "Iterator-Filter"
 	inputs := []inputType{
-		/*   1 */ {`([1] cat [2]) map $_`, kern.NewList([]any{int64(1), int64(2)}), nil},
+		/*   1 */ {`$$([1,2,3] filter $_%2==0)`, kern.NewList([]any{int64(2)}), nil},
+		/*   2 */ {`it = [1,2,3] filter $_%2!=1; $$(it)`, kern.NewList([]any{int64(2)}), nil},
+		/*   3 */ {`builtin "os.file"; #$$(fileLineIterator("test-file.txt") filter (#${_} == 2))`, int64(0), nil},
+		/*   4 */ {`builtin "os.file"; #$$(fileLineIterator("test-file.txt") filter (#${_} == 3))`, int64(2), nil},
+	}
+
+	// runTestSuiteSpec(t, section, inputs, 2)
+	runTestSuite(t, section, inputs)
+}
+
+func TestDigestIterator(t *testing.T) {
+	section := "Iterator-Digest"
+	inputs := []inputType{
+		/*   1 */ {`$(10) digest ${_}`, int64(9), nil},
+		/*   2 */ {`$(10,0) digest ${_}`, int64(1), nil},
+		/*   3 */ {`$(10,0,-2) digest ${_}`, int64(2), nil},
+	}
+
+	// runTestSuiteSpec(t, section, inputs, 2)
+	runTestSuite(t, section, inputs)
+}
+
+func TestCatIterator(t *testing.T) {
+	section := "Iterator-Cat"
+	inputs := []inputType{
+		/*   1 */ {`$$([1] cat [])`, kern.NewList([]any{int64(1)}), nil},
 		/*   2 */ {`$$([1] cat [2])`, kern.NewList([]any{int64(1), int64(2)}), nil},
+		/*   3 */ {`$$([1] cat nil)`, kern.NewList([]any{int64(1)}), nil},
+		/*   4 */ {`$$(nil cat [2])`, kern.NewList([]any{int64(2)}), nil},
+		/*   5 */ {`$$(nil cat nil)`, kern.NewList([]any{}), nil},
+		/*   6 */ {`$$(["a","b"] cat ["x"-true])`, nil, `[1:23] left operand 'x' [string] and right operand 'true' [bool] are not compatible with operator "-"`},
+	}
+
+	// runTestSuiteSpec(t, section, inputs, 6)
+	runTestSuite(t, section, inputs)
+}
+
+func TestMapIterator(t *testing.T) {
+	section := "Iterator-Map"
+	inputs := []inputType{
+		/*   1 */ {`$$([3,4,5] map ${_#})`, kern.NewList([]any{int64(1), int64(2), int64(3)}), nil},
+		/*   2 */ {`#$$($(10) map ${_})`, int64(10), nil},
+		/*   3 */ {`#$$($(10,0) map ${_})`, int64(10), nil},
+		/*   4 */ {`builtin "os.file"; $$(fileLineIterator("test-file.txt") map ${__})`, kern.NewList([]any{int64(0), int64(1)}), nil},
+		/*   5 */ {`$$(["1", "2", "3"] map int())`, nil, `int(): too few params -- expected 1, got 0`},
 	}
 
 	// runTestSuiteSpec(t, section, inputs, 2)

t_operator_test.go

@@ -43,49 +43,16 @@ func TestOperator(t *testing.T) {
 	runTestSuite(t, section, inputs)
 }
 
-func TestOperatorMap(t *testing.T) {
-	section := "Operator-Map"
-	inputs := []inputType{
-		/*   1 */ {`a=1; --a`, int64(0), nil},
-		/*   2 */ {`[1,2,3] map var("_")`, kern.NewList([]any{int64(1), int64(2), int64(3)}), nil},
-		/*   3 */ {`[1,2,3] map $_`, kern.NewList([]any{int64(1), int64(2), int64(3)}), nil},
-	}
-
-	// runTestSuiteSpec(t, section, inputs, 3)
-	runTestSuite(t, section, inputs)
-}
-
-func TestOperatorFilter(t *testing.T) {
-	section := "Operator-Filter"
-	inputs := []inputType{
-		/*   1 */ {`[1,2,3,4] filter ($_ % 2 == 0)`, kern.NewList([]any{int64(2), int64(4)}), nil},
-	}
-
-	// runTestSuiteSpec(t, section, inputs, 1)
-	runTestSuite(t, section, inputs)
-}
-
 func TestOperatorDigest(t *testing.T) {
 	section := "Operator-Digest"
 	inputs := []inputType{
-		/*   1 */ {`max=0; [2,3,1] digest max=(($_ > max) ? {$_} :: {max})`, int64(3), nil},
+		/*   1 */ {`max=0; [2,3,1] digest (max=(($_ > max) ? {$_} :: {max}))`, int64(3), nil},
 	}
 
 	// runTestSuiteSpec(t, section, inputs, 29)
 	runTestSuite(t, section, inputs)
 }
 
-func TestOperatorCat(t *testing.T) {
-	section := "Operator-Cat"
-	inputs := []inputType{
-		/*   1 */ {`["a","b"] cat ["x"]`, kern.NewList([]any{"a", "b", "x"}), nil},
-		/*   2 */ {`["a","b"] cat ["x"-true]`, nil, `[1:20] left operand 'x' [string] and right operand 'true' [bool] are not compatible with operator "-"`},
-	}
-
-	// runTestSuiteSpec(t, section, inputs, 2)
-	runTestSuite(t, section, inputs)
-}
-
 func TestOperatorGroupBy(t *testing.T) {
 	section := "Operator-GroupBy"
 	inputs := []inputType{