operator-builtin.go: builtin "" output the list of builtin module names

array-iterator.go

@@ -14,7 +14,7 @@ import (
 	"git.portale-stac.it/go-pkg/expr/types/array"
 )
 
-type ListIterator struct {
+type ArrayIterator struct {
 	a     *array.ArrayType
 	count int64
 	index int64
@@ -23,13 +23,13 @@ type ListIterator struct {
 	step  int64
 }
 
-func NewListIterator(list *array.ArrayType, args []any) (it *ListIterator) {
+func NewArrayIteratorFromArray(a *array.ArrayType, args []any) (it *ArrayIterator) {
 	var argc int = 0
-	listLen := int64(len(([]any)(*list)))
+	listLen := int64(len(([]any)(*a)))
 	if args != nil {
 		argc = len(args)
 	}
-	it = &ListIterator{a: list, count: 0, index: -1, start: 0, stop: listLen - 1, step: 1}
+	it = &ArrayIterator{a: a, count: 0, index: -1, start: 0, stop: listLen - 1, step: 1}
 	if argc >= 1 {
 		if i, err := types.ToGoInt64(args[0], "start index"); err == nil {
 			if i < 0 {
@@ -62,12 +62,12 @@ func NewListIterator(list *array.ArrayType, args []any) (it *ListIterator) {
 	return
 }
 
-func NewArrayIterator(a []any) (it *ListIterator) {
-	it = &ListIterator{a: (*array.ArrayType)(&a), count: 0, index: -1, start: 0, stop: int64(len(a)) - 1, step: 1}
+func NewArrayIterator(a []any) (it *ArrayIterator) {
+	it = &ArrayIterator{a: (*array.ArrayType)(&a), count: 0, index: -1, start: 0, stop: int64(len(a)) - 1, step: 1}
 	return
 }
 
-func (it *ListIterator) String() string {
+func (it *ArrayIterator) String() string {
 	var l = int64(0)
 	if it.a != nil {
 		l = int64(len(*it.a))
@@ -75,17 +75,17 @@ func (it *ListIterator) String() string {
 	return fmt.Sprintf("$([#%d])", l)
 }
 
-func (it *ListIterator) TypeName() string {
-	return "ListIterator"
+func (it *ArrayIterator) TypeName() string {
+	return "ArrayIterator"
 }
 
-func (it *ListIterator) HasOperation(name string) bool {
+func (it *ArrayIterator) HasOperation(name string) bool {
 	//yes := name == expr.NextName || name == expr.ResetName || name == expr.IndexName || name == expr.CountName || name == expr.CurrentName
 	yes := slices.Contains([]string{kern.NextName, kern.ResetName, kern.IndexName, kern.CountName, kern.CurrentName}, name)
 	return yes
 }
 
-func (it *ListIterator) CallOperation(name string, args map[string]any) (v any, err error) {
+func (it *ArrayIterator) CallOperation(name string, args map[string]any) (v any, err error) {
 	switch name {
 	case kern.NextName:
 		v, err = it.Next()
@@ -105,7 +105,7 @@ func (it *ListIterator) CallOperation(name string, args map[string]any) (v any,
 	return
 }
 
-func (it *ListIterator) Current() (item any, err error) {
+func (it *ArrayIterator) Current() (item any, err error) {
 	a := *(it.a)
 	if it.start <= it.stop {
 		if it.stop < int64(len(a)) && it.index >= it.start && it.index <= it.stop {
@@ -124,7 +124,7 @@ func (it *ListIterator) Current() (item any, err error) {
 	return
 }
 
-func (it *ListIterator) Next() (item any, err error) {
+func (it *ArrayIterator) Next() (item any, err error) {
 	it.index += it.step
 	if item, err = it.Current(); err != io.EOF {
 		it.count++
@@ -132,20 +132,20 @@ func (it *ListIterator) Next() (item any, err error) {
 	return
 }
 
-func (it *ListIterator) Index() int64 {
+func (it *ArrayIterator) Index() int64 {
 	return it.index
 }
 
-func (it *ListIterator) Count() int64 {
+func (it *ArrayIterator) Count() int64 {
 	return it.count
 }
 
-func (it *ListIterator) Reset() error {
+func (it *ArrayIterator) Reset() error {
 	it.index = it.start - it.step
 	it.count = 0
 	return nil
 }
 
-func (it *ListIterator) Clean() error {
+func (it *ArrayIterator) Clean() error {
 	return nil
 }

builtin-math-arith.go

@@ -34,7 +34,7 @@ func doAdd(ctx kern.ExprContext, name string, it kern.Iterator, count, level int
 
 	for v, err = it.Next(); err == nil; v, err = it.Next() {
 		if list, ok := v.(*array.ArrayType); ok {
-			v = NewListIterator(list, nil)
+			v = NewArrayIteratorFromArray(list, nil)
 		}
 		if subIter, ok := v.(kern.Iterator); ok {
 			if v, err = doAdd(ctx, name, subIter, count, level); err != nil {
@@ -108,7 +108,7 @@ func doMul(ctx kern.ExprContext, name string, it kern.Iterator, count, level int
 	level++
 	for v, err = it.Next(); err == nil; v, err = it.Next() {
 		if list, ok := v.(*array.ArrayType); ok {
-			v = NewListIterator(list, nil)
+			v = NewArrayIteratorFromArray(list, nil)
 		}
 		if subIter, ok := v.(kern.Iterator); ok {
 			if v, err = doMul(ctx, name, subIter, count, level); err != nil {

builtin-string.go

@@ -12,6 +12,8 @@ import (
 	"git.portale-stac.it/go-pkg/expr/kern"
 	"git.portale-stac.it/go-pkg/expr/types"
 	"git.portale-stac.it/go-pkg/expr/types/array"
+	"git.portale-stac.it/go-pkg/expr/types/dict"
+	"git.portale-stac.it/go-pkg/expr/types/list"
 )
 
 const (
@@ -45,14 +47,24 @@ func joinStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result
 		if v, exists := args[kern.ParamItem]; exists {
 			argv := v.([]any)
 			if len(argv) == 1 {
+				var it kern.Iterator
+				if it, ok = argv[0].(kern.Iterator); !ok {
 					if a, ok := argv[0].(*array.ArrayType); ok {
-					result, err = doJoinStr(name, sep, NewListIterator(a, nil))
-				} else if it, ok := argv[0].(kern.Iterator); ok {
+						it = NewArrayIteratorFromArray(a, nil)
+					} else if l, ok := argv[0].(*list.LinkedList); ok {
+						it = NewLinkedListIterator(l, nil)
+					} else if d, ok := argv[0].(*dict.DictType); ok {
+						if it, err = NewDictIteratorA(d, "none", "values"); err != nil {
+							return
+						}
+					}
+				}
+				if it != nil {
 					result, err = doJoinStr(name, sep, it)
 				} else if s, ok := argv[0].(string); ok {
 					result = s
 				} else {
-					err = kern.ErrInvalidParameterValue(name, kern.ParamItem, v)
+					err = kern.ErrInvalidParameterValue(name, kern.ParamItem, argv[0])
 				}
 			} else {
 				result, err = doJoinStr(name, sep, NewArrayIterator(argv))
@@ -64,6 +76,30 @@ func joinStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result
 	return
 }
 
+// func joinStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+// 	if sep, ok := args[kern.ParamSeparator].(string); ok {
+// 		if v, exists := args[kern.ParamItem]; exists {
+// 			argv := v.([]any)
+// 			if len(argv) == 1 {
+// 				if a, ok := argv[0].(*array.ArrayType); ok {
+// 					result, err = doJoinStr(name, sep, NewListIterator(a, nil))
+// 				} else if it, ok := argv[0].(kern.Iterator); ok {
+// 					result, err = doJoinStr(name, sep, it)
+// 				} else if s, ok := argv[0].(string); ok {
+// 					result = s
+// 				} else {
+// 					err = kern.ErrInvalidParameterValue(name, kern.ParamItem, argv[0])
+// 				}
+// 			} else {
+// 				result, err = doJoinStr(name, sep, NewArrayIterator(argv))
+// 			}
+// 		}
+// 	} else {
+// 		err = kern.ErrWrongParamType(name, kern.ParamSeparator, kern.TypeString, args[kern.ParamSeparator])
+// 	}
+// 	return
+// }
+
 func subStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var start = 0
 	var count = -1

dict-iterator.go

@@ -70,6 +70,13 @@ func (it *DictIterator) makeKeys(m map[any]any, sort sortType) {
 	}
 }
 
+// NewDictIterator creates a new DictIterator for the given dict.DictType and optional arguments.
+// The first argument can be a string specifying the sort type ("asc", "desc", "none", or "default").
+// The second argument can be a string specifying the iteration mode ("keys", "values", "items", or "default").
+func NewDictIteratorA(dict *dict.DictType, args ...any) (it *DictIterator, err error) {
+	return NewDictIterator(dict, args)
+}
+
 func NewDictIterator(dict *dict.DictType, args []any) (it *DictIterator, err error) {
 	var sortType = sortTypeNone
 	var s string

iter-factory.go

@@ -30,7 +30,7 @@ func NewIterator(ctx kern.ExprContext, value any, ops []*scan.Term) (it kern.Ite
 
 	switch v := value.(type) {
 	case *array.ArrayType:
-		it = NewListIterator(v, nil)
+		it = NewArrayIteratorFromArray(v, nil)
 	case *list.LinkedList:
 		it = NewLinkedListIterator(v, nil)
 	case *dict.DictType:

kern/common-errors.go

@@ -52,7 +52,7 @@ func ErrFuncDivisionByZero(funcName string) error {
 // }
 
 func ErrInvalidParameterValue(funcName, paramName string, paramValue any) error {
-	return fmt.Errorf("%s(): invalid value %s (%#v) for parameter %q", funcName, TypeName(paramValue), paramValue, paramName)
+	return fmt.Errorf("%s(): invalid value %s (%s) for parameter %q", funcName, paramValue, TypeName(paramValue), paramName)
 }
 
 func undefArticle(s string) (article string) {

operand-iterator.go

@@ -140,7 +140,7 @@ func evalIterator(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	} else if a, ok := firstChildValue.(*array.ArrayType); ok {
 		var args []any
 		if args, err = evalSiblings(ctx, opTerm.Children, nil); err == nil {
-			v = NewListIterator(a, args)
+			v = NewArrayIteratorFromArray(a, args)
 		}
 	} else if ll, ok := firstChildValue.(*list.LinkedList); ok {
 		var args []any

operator-builtin.go

@@ -10,6 +10,7 @@ import (
 	"git.portale-stac.it/go-pkg/expr/kern"
 	"git.portale-stac.it/go-pkg/expr/scan"
 	"git.portale-stac.it/go-pkg/expr/sym"
+	"git.portale-stac.it/go-pkg/expr/types/list"
 	"git.portale-stac.it/go-pkg/expr/types/str"
 )
 
@@ -35,7 +36,17 @@ func evalBuiltin(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	count := 0
 	if str.IsString(childValue) {
 		module, _ := childValue.(string)
+		if module == "" {
+			ll := list.NewLinkedList()
+			IterateBuiltinModules(func(name, description string, imported bool) bool {
+				ll.PushBack(name)
+				return true
+			})
+			v = ll
+			return
+		} else {
 			count, err = ImportInContextByGlobPattern(ctx, module)
+		}
 	} else {
 		var moduleSpec any
 		var it kern.Iterator

t_expr_test.go

@@ -35,7 +35,9 @@ func TestExpr(t *testing.T) {
 		/*  19 */ {`a=2; ${a}`, int64(2), nil},
 		/*  20 */ {`$_=2; $_`, int64(2), nil},
 		/*  21 */ {`$$`, dict.NewDict(map[any]any{"vars": dict.NewDict(nil), "funcs": dict.NewDict(nil)}), nil},
-		/*  22 */ {`
+		/*  22 */ {`builtin "string"; strJoin("-", [<"a", "b", "c">])`, nil, `strJoin(): invalid value [<"a", "b", "c">] (linked-list) for parameter "item"`},
+		/*  22 */ {`builtin ""`, nil, `strJoin(): invalid value [<"a", "b", "c">] (linked-list) for parameter "item"`},
+		/*  23 */ {`
 		ds={
 			"init":func(@end){@current=0 but true},
 			//"current":func(){current},
@@ -50,6 +52,6 @@ func TestExpr(t *testing.T) {
 	}
 	// t.Setenv("EXPR_PATH", ".")
 
-	// RunTestSuiteSpec(t, section, inputs, 19)
+	// RunTestSuiteSpec(t, section, inputs, 22)
 	RunTestSuite(t, section, inputs)
 }

t_iter-list_test.go

@@ -13,7 +13,7 @@ import (
 
 func TestNewListIterator(t *testing.T) {
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	if item, err := it.Next(); err != nil {
 		t.Errorf("error: %v", err)
 	} else if item != "b" {
@@ -25,7 +25,7 @@ func TestNewListIterator(t *testing.T) {
 
 func TestNewListIterator2(t *testing.T) {
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{3, 1, -1})
+	it := NewArrayIteratorFromArray(a, []any{3, 1, -1})
 	if item, err := it.Next(); err != nil {
 		t.Errorf("error: %v", err)
 	} else if item != "d" {
@@ -37,7 +37,7 @@ func TestNewListIterator2(t *testing.T) {
 
 func TestNewListIterator3(t *testing.T) {
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, -1, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, -1, 1})
 	if item, err := it.Next(); err != nil {
 		t.Errorf("error: %v", err)
 	} else if item != "b" {
@@ -116,7 +116,7 @@ func TestNewString(t *testing.T) {
 func TestHasOperation(t *testing.T) {
 
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	hasOp := it.HasOperation("reset")
 	if !hasOp {
 		t.Errorf("HasOperation(reset) must be true, got false")
@@ -126,7 +126,7 @@ func TestHasOperation(t *testing.T) {
 func TestCallOperationReset(t *testing.T) {
 
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	if v, err := it.CallOperation("reset", nil); err != nil {
 		t.Errorf("Error on CallOperation(reset): %v", err)
 	} else {
@@ -137,7 +137,7 @@ func TestCallOperationReset(t *testing.T) {
 func TestCallOperationIndex(t *testing.T) {
 
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	if v, err := it.CallOperation("index", nil); err != nil {
 		t.Errorf("Error on CallOperation(index): %v", err)
 	} else {
@@ -148,7 +148,7 @@ func TestCallOperationIndex(t *testing.T) {
 func TestCallOperationCount(t *testing.T) {
 
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	if v, err := it.CallOperation("count", nil); err != nil {
 		t.Errorf("Error on CallOperation(count): %v", err)
 	} else {
@@ -159,7 +159,7 @@ func TestCallOperationCount(t *testing.T) {
 func TestCallOperationUnknown(t *testing.T) {
 
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	if v, err := it.CallOperation("unknown", nil); err == nil {
 		t.Errorf("Expected error on CallOperation(unknown), got %v", v)
 	}

types/list/linked-list-type.go

@@ -10,7 +10,7 @@ import (
 	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
-const LinkedListTypeName = "lisked-list"
+const LinkedListTypeName = "linked-list"
 
 func IsLinkedList(v any) (ok bool) {
 	_, ok = v.(*LinkedList)