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

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

Browse Source
This commit is contained in:
Celestino Amoroso
2026-05-06 04:04:08 +02:00
parent acd4f8487d
commit 5585b496fb
7 changed files with 86 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files
iter-factory.go
+12 -15
View File
@@ -5,13 +5,13 @@
package expr package expr
import ( import (
"fmt"
"slices" "slices"
"git.portale-stac.it/go-pkg/expr/kern" "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 { if value == nil {
return NewArrayIterator([]any{}), nil return NewArrayIterator([]any{}), nil
} }
@@ -24,24 +24,21 @@ func NewIterator(ctx kern.ExprContext, value any, args map[string]any) (it kern.
case []any: case []any:
it = NewArrayIterator(v) it = NewArrayIterator(v)
case kern.Iterator: 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: default:
it = NewArrayIterator([]any{value}) it = NewArrayIterator([]any{value})
} }
return 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) 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
+21 -26
View File
@@ -9,33 +9,20 @@ import (
"io" "io"
"git.portale-stac.it/go-pkg/expr/kern" "git.portale-stac.it/go-pkg/expr/kern"
"git.portale-stac.it/go-pkg/expr/scan"
) )
type IterIter struct { type IterIter struct {
it kern.Iterator it kern.Iterator
count int64 count int64
index int64 index int64
ctx kern.ExprContext ctx kern.ExprContext
op kern.Functor exprList []*scan.Term
opName string current any
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 return
} }
@@ -48,7 +35,7 @@ func (it *IterIter) TypeName() string {
} }
func (it *IterIter) HasOperation(name string) bool { 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) { 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) { func (it *IterIter) Current() (item any, err error) {
if it.current != nil { if it.current != nil {
item = it.current 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 { } else {
var exists bool var exists bool
operand-iterator.go
+30 -47
View File
@@ -5,9 +5,7 @@
package expr package expr
import ( import (
"fmt"
"slices" "slices"
"strconv"
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern" "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 { if args, err = evalSiblings(ctx, opTerm.Children, intVal); err == nil {
v, err = NewIntIterator(args) v, err = NewIntIterator(args)
} }
} else if it, ok := firstChildValue.(kern.Iterator); ok {
v, err = NewIterIter(it, ctx, opTerm.Children[1:])
} else { } else {
var siblings []any var siblings []any
if siblings, err = evalSiblings(ctx, opTerm.Children, firstChildValue); err == nil { if siblings, err = evalSiblings(ctx, opTerm.Children, firstChildValue); err == nil {
// if v, err = evalIterIter(ctx, firstChildValue, siblings); err == nil && v == nil { v = NewArrayIterator(siblings)
// 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 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) { func evalSiblings(ctx kern.ExprContext, terms []*scan.Term, firstChildValue any) (list []any, err error) {
items := make([]any, 0, len(terms)) items := make([]any, 0, len(terms))
operator-groupby.go
+5 -2
View File
@@ -31,6 +31,7 @@ func evalGroupBy(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
var item any var item any
var sKey string var sKey string
var keyByIndex bool var keyByIndex bool
var ok bool
if err = opTerm.CheckOperands(); err != nil { if err = opTerm.CheckOperands(); err != nil {
return return
@@ -40,8 +41,10 @@ func evalGroupBy(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
return return
} }
if it, err = NewIterator(ctx, leftValue, nil); err != nil { if it, ok = leftValue.(kern.Iterator); !ok {
return nil, fmt.Errorf("left operand of MAP must be an iterable data-source; got %s", kern.TypeName(leftValue)) 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 rightTk := opTerm.Children[1].Tk
operator-join.go
+9 -4
View File
@@ -28,6 +28,7 @@ func evalJoin(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
var itLeft, itRight kern.Iterator var itLeft, itRight kern.Iterator
var item any var item any
var ok bool
if err = opTerm.CheckOperands(); err != nil { if err = opTerm.CheckOperands(); err != nil {
return return
@@ -41,12 +42,16 @@ func evalJoin(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
return return
} }
if itLeft, err = NewIterator(ctx, leftValue, nil); err != nil { if itLeft, ok = leftValue.(kern.Iterator); !ok {
return nil, fmt.Errorf("left operand of JOIN must be an iterable data-source; got %s", kern.TypeName(leftValue)) 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, err = NewIterator(ctx, rightValue, nil); err != nil { if itRight, ok = rightValue.(kern.Iterator); !ok {
return nil, fmt.Errorf("right operand of JOIN must be an iterable data-source; got %s", kern.TypeName(rightValue)) 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() values := kern.NewListA()
operator-map.go
+5 -2
View File
@@ -28,6 +28,7 @@ func evalMap(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
var it kern.Iterator var it kern.Iterator
var item any var item any
var ok bool
if err = opTerm.CheckOperands(); err != nil { if err = opTerm.CheckOperands(); err != nil {
return return
@@ -37,8 +38,10 @@ func evalMap(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
return return
} }
if it, err = NewIterator(ctx, leftValue, nil); err != nil { if it, ok = leftValue.(kern.Iterator); !ok {
return nil, fmt.Errorf("left operand of MAP must be an iterable data-source; got %s", kern.TypeName(leftValue)) 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() values := kern.NewListA()
t_iter-iter_test.go
+4 -3
View File
@@ -14,11 +14,12 @@ func TestIterIterator(t *testing.T) {
section := "Iterator" section := "Iterator"
inputs := []inputType{ inputs := []inputType{
/* 1 */ {`it=$(4); $(it) filter ${_}==100`, kern.NewListA(), nil}, /* 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) // runTestSuite(t, section, inputs)
} }