go-pkg/expr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

map, filter and cat return an iterator

Browse Source
This commit is contained in:
Celestino Amoroso
2026-05-09 17:42:04 +02:00
parent e5a61b5638
commit 45faea7620
6 changed files with 182 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files
operator-context.go
+2
View File
@@ -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
+107 -18
View File
@@ -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()
for item, err = it.Next(); err == nil; item, err = it.Next() {
ctx.SetVar("_", item)
// values := kern.NewListA()
// for item, err = it.Next(); err == nil; item, err = it.Next() {
// 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 {
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)
}
}
result, err = it.expr.Compute(ctx)
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
+25 -24
View File
@@ -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()
for item, err = it.Next(); err == nil; item, err = it.Next() {
ctx.SetVar("_", item)
ctx.SetVar("__", it.Index())
ctx.SetVar("_#", it.Count())
if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil {
values.AppendItem(rightValue)
}
ctx.DeleteVar("_#")
ctx.DeleteVar("__")
ctx.DeleteVar("_")
if err != nil {
break
}
}
if err == io.EOF {
err = nil
}
if err == nil {
v = values
}
// values := kern.NewListA()
// for item, err = it.Next(); err == nil; item, err = it.Next() {
// ctx.SetVar("_", item)
// ctx.SetVar("__", it.Index())
// ctx.SetVar("_#", it.Count())
// if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil {
// values.AppendItem(rightValue)
// }
// ctx.DeleteVar("_#")
// ctx.DeleteVar("__")
// ctx.DeleteVar("_")
// if err != nil {
// break
// }
// }
// if err == io.EOF {
// err = nil
// }
// if err == nil {
// v = values
// }
v, err = NewIterIter(it, ctx, opTerm.Children[1:])
return
}
t_funcs_test.go
+1 -2
View File
@@ -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`},
/* 4 */ {`builtin "iterator"; times=func(a,b){a*b}; run($(["1", "2", "3"]), times)`, nil, `operator(): missing params -- a, b`},
/* 3 */ {`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
+46 -12
View File
@@ -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) {
section := "Iterator"
func TestFilterIterator(t *testing.T) {
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
+1 -34
View File
@@ -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{