Expr.adoc: typos

builtin-base.go

@@ -255,18 +255,35 @@ func setFunc(ctx kern.ExprContext, name string, args map[string]any) (result any
 	return
 }
 
-// func unsetFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-// 	var varName string
-// 	var ok bool
+func charFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+	var ord int
 
-// 	if varName, ok = args[kern.ParamName].(string); !ok {
-// 		return nil, kern.ErrWrongParamType(name, kern.ParamName, kern.TypeString, args[kern.ParamName])
-// 	} else {
-// 		ctx.GetParent().DeleteVar(varName)
-// 		result = nil
-// 	}
-// 	return
-// }
+	if n, ok := args[kern.ParamValue].(byte); ok {
+		ord = int(n)
+	} else if n, ok := args[kern.ParamValue].(int64); ok {
+		ord = int(n)
+	} else if n, ok := args[kern.ParamValue].(int); ok {
+		ord = n
+	} else {
+		return nil, kern.ErrWrongParamType(name, kern.ParamName, kern.TypeString, args[kern.ParamName])
+	}
+	if ord < 0 || ord > 255 {
+		err = kern.ErrFuncInvalidArg(name, fmt.Sprintf("character code must be in range 0-255, got %d", ord))
+	} else {
+		result = string(rune(ord))
+	}
+	return
+}
+
+func seqFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+	list := kern.NewLinkedList()
+	items := args[kern.ParamValue].([]any)
+	for _, arg := range items {
+		list.PushBack(arg)
+	}
+	result = list
+	return
+}
 
 //// import
 
@@ -308,10 +325,13 @@ func ImportBuiltinsFuncs(ctx kern.ExprContext) {
 		kern.NewFuncParam(kern.ParamValue),
 	})
 
-	// ctx.RegisterFunc("unset", kern.NewGolangFunctor(unsetFunc), kern.TypeAny, []kern.ExprFuncParam{
-	// 	kern.NewFuncParam(kern.ParamName),
-	// 	kern.NewFuncParam(kern.ParamValue),
-	// })
+	ctx.RegisterFunc("char", kern.NewGolangFunctor(charFunc), kern.TypeString, []kern.ExprFuncParam{
+		kern.NewFuncParam(kern.ParamValue),
+	})
+
+	ctx.RegisterFunc("seq", kern.NewGolangFunctor(seqFunc), kern.TypeLinkedList, []kern.ExprFuncParam{
+		kern.NewFuncParamFlag(kern.ParamValue, kern.PfRepeat),
+	})
 }
 
 func init() {

builtin-os-file-iter-byte.go

@@ -0,0 +1,102 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtin-os-file.go
+package expr
+
+import (
+	"git.portale-stac.it/go-pkg/expr/file"
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
+const fileByteIteratorType = "fileByteIterator"
+
+type fileFileByteIterator struct {
+	fileIterBase
+	b byte
+}
+
+func newFileByteIterator(r *file.Reader, autoClose bool) *fileFileByteIterator {
+	return &fileFileByteIterator{
+		fileIterBase: fileIterBase{reader: r, index: -1, count: 0, autoClose: autoClose},
+		b:            0}
+}
+
+func (it *fileFileByteIterator) TypeName() string {
+	return fileByteIteratorType
+}
+
+func (it *fileFileByteIterator) String() string {
+	return it.repr(fileByteIteratorType)
+}
+
+func (it *fileFileByteIterator) Next() (item any, err error) { // must return io.EOF after the last item
+	if it.b, err = it.reader.ReadByte(); err == nil {
+		it.increment()
+		item = it.b
+	} else if it.autoClose {
+		it.Clean()
+	}
+	return
+}
+
+func (it *fileFileByteIterator) Current() (item any, err error) {
+	item = it.b
+	return
+}
+
+func (it *fileFileByteIterator) Reset() (err error) {
+	if err = it.reader.Reset(); err == nil {
+		it.reset()
+		it.b = 0
+	}
+	return
+}
+
+func (it *fileFileByteIterator) Clean() (err error) {
+	if it.reader.Valid() {
+		if err = it.reader.GetFile().Close(); err == nil {
+			it.reader = nil
+		}
+	}
+	it.reset()
+	it.b = 0
+	return
+}
+
+func (it *fileFileByteIterator) 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 = int64(it.Index())
+	case kern.CurrentName:
+		v, err = it.Current()
+	case kern.CountName:
+		v = it.count
+	default:
+		err = kern.ErrNoOperation(name)
+	}
+	return
+}
+
+func fileByteIteratorFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+	var handle *file.Reader
+	var invalidFileHandle any
+	var autoClose bool
+
+	if handle, invalidFileHandle, autoClose, err = initFileHandle(ctx, name, args); err == nil {
+		if handle != nil {
+			result = newFileByteIterator(handle, autoClose)
+		}
+	}
+
+	if err == nil && (handle == nil || invalidFileHandle != nil) {
+		err = errInvalidFileHandle(name, invalidFileHandle)
+	}
+	return
+}

builtin-os-file-iter-line.go

@@ -0,0 +1,105 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtin-os-file.go
+package expr
+
+import (
+	"git.portale-stac.it/go-pkg/expr/file"
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
+const fileLineIteratorType = "fileLineIterator"
+
+type fileFileLineIterator struct {
+	fileIterBase
+	line string
+}
+
+func newFileLineIterator(r *file.Reader, autoClose bool) *fileFileLineIterator {
+	return &fileFileLineIterator{
+		fileIterBase: fileIterBase{reader: r, index: -1, count: 0, autoClose: autoClose},
+		line:         "",
+	}
+}
+
+func (it *fileFileLineIterator) TypeName() string {
+	return fileLineIteratorType
+}
+
+func (it *fileFileLineIterator) String() string {
+	return it.repr(fileLineIteratorType)
+}
+
+func (it *fileFileLineIterator) Next() (item any, err error) { // must return io.EOF after the last item
+	if it.line, err = it.reader.ReadString('\n'); err == nil {
+		it.increment()
+		item = it.line[0 : len(it.line)-1]
+	} else if it.autoClose {
+		it.Clean()
+	}
+	return
+}
+
+func (it *fileFileLineIterator) Current() (item any, err error) {
+	if len(it.line) > 0 {
+		item = it.line[0 : len(it.line)-1]
+	}
+	return
+}
+
+func (it *fileFileLineIterator) Reset() (err error) {
+	if err = it.reader.Reset(); err == nil {
+		it.reset()
+		it.line = ""
+	}
+	return
+}
+
+func (it *fileFileLineIterator) Clean() (err error) {
+	if it.reader != nil {
+		if err = it.reader.Close(); err == nil {
+			it.reader = nil
+		}
+	}
+	it.reset()
+	it.line = ""
+	return
+}
+
+func (it *fileFileLineIterator) 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 = int64(it.Index())
+	case kern.CurrentName:
+		v, err = it.Current()
+	case kern.CountName:
+		v = it.count
+	default:
+		err = kern.ErrNoOperation(name)
+	}
+	return
+}
+
+func fileLineIteratorFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+	var handle *file.Reader
+	var invalidFileHandle any
+	var autoClose bool
+
+	if handle, invalidFileHandle, autoClose, err = initFileHandle(ctx, name, args); err == nil {
+		if handle != nil {
+			result = newFileLineIterator(handle, autoClose)
+		}
+	}
+
+	if err == nil && (handle == nil || invalidFileHandle != nil) {
+		err = errInvalidFileHandle(name, invalidFileHandle)
+	}
+	return
+}

builtin-os-file-iter.go

@@ -6,146 +6,66 @@ package expr
 
 import (
 	"fmt"
-	"io"
 	"slices"
 
+	"git.portale-stac.it/go-pkg/expr/file"
 	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 const paramHandleOrPath = "handle-or-path"
-const fileReadTextIteratorType = "fileReadTextIterator"
 
-type fileReadTextIterator struct {
-	osReader  *osReader
+type fileIterBase struct {
+	reader    *file.Reader
 	index     int64
 	count     int64
-	line      string
 	autoClose bool
 }
 
-func newReadTextIterator(r *osReader, autoClose bool) *fileReadTextIterator {
-	return &fileReadTextIterator{osReader: r, index: -1, autoClose: autoClose}
-}
-
-func (it *fileReadTextIterator) TypeName() string {
-	return fileReadTextIteratorType
-}
-
-func (it *fileReadTextIterator) String() string {
-	if it.osReader != nil && it.osReader.fh != nil {
-		return fmt.Sprintf("$(%s@%q)", fileReadTextIteratorType, it.osReader.fh.Name())
-	}
-	return fmt.Sprintf("$(%s@<nil>)", fileReadTextIteratorType)
-}
-
-func (it *fileReadTextIterator) Count() int64 {
+func (it *fileIterBase) Count() int64 {
 	return it.count
 }
 
-func (it *fileReadTextIterator) Next() (item any, err error) { // must return io.EOF after the last item
-	if it.osReader.fh != nil {
-		if it.line, err = it.osReader.reader.ReadString('\n'); err == nil {
-			it.index++
-			it.count++
-			item = it.line[0 : len(it.line)-1]
-		} else if it.autoClose {
-			it.Clean()
-		}
-	}
-	return
-}
-
-func (it *fileReadTextIterator) Current() (item any, err error) {
-	if len(it.line) > 0 {
-		item = it.line[0 : len(it.line)-1]
-	}
-	return
-}
-
-func (it *fileReadTextIterator) Index() int64 {
+func (it *fileIterBase) Index() int64 {
 	return it.index
 }
 
-func (it *fileReadTextIterator) Reset() (err error) {
-	if _, err = it.osReader.fh.Seek(0, io.SeekStart); err == nil {
-		it.index = -1
-		it.count = 0
-		it.line = ""
-	}
-	return
-}
-
-func (it *fileReadTextIterator) HasOperation(name string) bool {
+func (it *fileIterBase) HasOperation(name string) bool {
 	return slices.Contains([]string{kern.NextName, kern.ResetName, kern.IndexName, kern.CountName, kern.CurrentName, kern.CleanName}, name)
 }
 
-func (it *fileReadTextIterator) Clean() (err error) {
-	if it.osReader.fh != nil {
-		if err = it.osReader.fh.Close(); err == nil {
-			it.osReader = nil
-		}
-	}
-	return nil
+func (it *fileIterBase) reset() {
+	it.index = -1
+	it.count = 0
 }
 
-func (it *fileReadTextIterator) 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 = int64(it.Index())
-	case kern.CurrentName:
-		v, err = it.Current()
-	case kern.CountName:
-		v = it.count
-	default:
-		err = kern.ErrNoOperation(name)
-	}
-	return
+func (it *fileIterBase) increment() {
+	it.index++
+	it.count++
 }
 
-func fileReadIteratorFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	var handle *osReader
-	var invalidFileHandle any
-	var ok, autoClose bool
+func (it *fileIterBase) repr(typeName string) string {
+	if it.reader.Valid() {
+		return fmt.Sprintf("$(%s@%q)", typeName, it.reader.GetName())
+	}
+	return fmt.Sprintf("$(%s@<nil>)", typeName)
+}
 
-	result = nil
-	if handle, ok = args[paramHandleOrPath].(*osReader); !ok {
+func initFileHandle(ctx kern.ExprContext, name string, args map[string]any) (handle *file.Reader, invalidFileHandle any, autoClose bool, err error) {
+	var ok bool
+
+	if handle, ok = args[paramHandleOrPath].(*file.Reader); !ok {
 		if fileName, ok := args[paramHandleOrPath].(string); ok && len(fileName) > 0 {
 			var handleAny any
 			if handleAny, err = openFileFunc(ctx, name, map[string]any{kern.ParamFilepath: fileName}); err != nil {
 				return
 			}
 			if handleAny != nil {
-				handle = handleAny.(*osReader)
+				handle = handleAny.(*file.Reader)
 				autoClose = true
 			}
 		} else {
 			invalidFileHandle = args[paramHandleOrPath]
 		}
 	}
-
-	if handle != nil {
-		result = newReadTextIterator(handle, autoClose)
-
-	}
-
-	if err == nil && (handle == nil || invalidFileHandle != nil) {
-		err = errInvalidFileHandle(name, invalidFileHandle)
-	}
 	return
 }
-
-// func ImportOsIterFuncs(ctx ExprContext) {
-// 	ctx.RegisterFunc("fileReadIterator", NewGolangFunctor(fileReadIteratorFunc), TypeIterator, []ExprFuncParam{
-// 		NewFuncParam(paramHandleOrPath),
-// 	})
-// }
-
-// func init() {
-// 	RegisterBuiltinModule("os.file", ImportOsIterFuncs, "Operating system file iterator functions")
-// }

builtin-os-file.go

@@ -5,11 +5,10 @@
 package expr
 
 import (
-	"bufio"
 	"fmt"
 	"io"
-	"os"
 
+	"git.portale-stac.it/go-pkg/expr/file"
 	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
@@ -17,44 +16,6 @@ const (
 	osLimitCh = "limitCh"
 )
 
-type osHandle interface {
-	getFile() *os.File
-}
-
-type osWriter struct {
-	fh     *os.File
-	writer *bufio.Writer
-}
-
-func (h *osWriter) TypeName() string {
-	return "osWriter"
-}
-
-func (h *osWriter) String() string {
-	return "writer"
-}
-
-func (h *osWriter) getFile() *os.File {
-	return h.fh
-}
-
-type osReader struct {
-	fh     *os.File
-	reader *bufio.Reader
-}
-
-func (h *osReader) TypeName() string {
-	return "osReader"
-}
-
-func (h *osReader) String() string {
-	return "reader"
-}
-
-func (h *osReader) getFile() *os.File {
-	return h.fh
-}
-
 func errMissingFilePath(funcName string) error {
 	return fmt.Errorf("%s(): missing or invalid file path", funcName)
 }
@@ -67,24 +28,26 @@ func errInvalidFileHandle(funcName string, v any) error {
 	}
 }
 
-func createFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+func openFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	if filePath, ok := args[kern.ParamFilepath].(string); ok && len(filePath) > 0 {
-		var fh *os.File
-		if fh, err = os.Create(filePath); err == nil {
-			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
-		}
+		// var fh *os.File
+		// if fh, err = os.Open(filePath); err == nil {
+		// 	result = file.NewReader(fh)
+		// }
+		result, err = file.OpenReader(filePath)
 	} else {
 		err = errMissingFilePath(name)
 	}
 	return
 }
 
-func openFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+func createFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	if filePath, ok := args[kern.ParamFilepath].(string); ok && len(filePath) > 0 {
-		var fh *os.File
-		if fh, err = os.Open(filePath); err == nil {
-			result = &osReader{fh: fh, reader: bufio.NewReader(fh)}
-		}
+		// var fh *os.File
+		// if fh, err = os.Create(filePath); err == nil {
+		// 	result = file.NewWriter(fh)
+		// }
+		result, err = file.CreateWriter(filePath)
 	} else {
 		err = errMissingFilePath(name)
 	}
@@ -93,10 +56,11 @@ func openFileFunc(ctx kern.ExprContext, name string, args map[string]any) (resul
 
 func appendFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	if filePath, ok := args[kern.ParamFilepath].(string); ok && len(filePath) > 0 {
-		var fh *os.File
-		if fh, err = os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0660); err == nil {
-			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
-		}
+		// var fh *os.File
+		// if fh, err = os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0660); err == nil {
+		// 	result = file.NewWriter(fh)
+		// }
+		result, err = file.AppendWriter(filePath)
 	} else {
 		err = errMissingFilePath(name)
 	}
@@ -104,18 +68,18 @@ func appendFileFunc(ctx kern.ExprContext, name string, args map[string]any) (res
 }
 
 func closeFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	var handle osHandle
+	var handle file.Handle
 	var invalidFileHandle any
 	var ok bool
 
-	if handle, ok = args[kern.ParamHandle].(osHandle); !ok {
+	if handle, ok = args[kern.ParamHandle].(file.Handle); !ok {
 		invalidFileHandle = args[kern.ParamHandle]
 	}
 
 	if handle != nil {
-		if fh := handle.getFile(); fh != nil {
-			if w, ok := handle.(*osWriter); ok {
-				err = w.writer.Flush()
+		if fh := handle.GetFile(); fh != nil {
+			if w, ok := handle.(*file.Writer); ok {
+				err = w.Flush()
 			}
 
 			if err == nil {
@@ -131,19 +95,20 @@ func closeFileFunc(ctx kern.ExprContext, name string, args map[string]any) (resu
 }
 
 func fileWriteTextFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	var handle osHandle
+	var handle file.Handle
 	var invalidFileHandle any
 	var ok bool
 
-	if handle, ok = args[kern.ParamHandle].(osHandle); !ok {
+	if handle, ok = args[kern.ParamHandle].(file.Handle); !ok {
 		invalidFileHandle = args[kern.ParamHandle]
 	}
 
 	if handle != nil {
-		if w, ok := handle.(*osWriter); ok {
+		if w, ok := handle.(*file.Writer); ok {
 			if v, exists := args[kern.ParamItem]; exists {
 				argv := v.([]any)
-				result, err = fmt.Fprint(w.writer, argv...)
+				// result, err = fmt.Fprint(w.writer, argv...)
+				result, err = w.Write(argv...)
 			}
 		} else {
 			invalidFileHandle = handle
@@ -157,24 +122,24 @@ func fileWriteTextFunc(ctx kern.ExprContext, name string, args map[string]any) (
 }
 
 func fileReadTextFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	var handle osHandle
+	var handle file.Handle
 	var invalidFileHandle any
 	var ok bool
 
 	result = nil
-	if handle, ok = args[kern.ParamHandle].(osHandle); !ok || args[kern.ParamHandle] == nil {
+	if handle, ok = args[kern.ParamHandle].(file.Handle); !ok || args[kern.ParamHandle] == nil {
 		invalidFileHandle = args[kern.ParamHandle]
 	}
 
 	if handle != nil {
-		if r, ok := handle.(*osReader); ok {
+		if r, ok := handle.(*file.Reader); ok {
 			var limit byte = '\n'
 			var v string
 			if s, ok := args[osLimitCh].(string); ok && len(s) > 0 {
 				limit = s[0]
 			}
 
-			v, err = r.reader.ReadString(limit)
+			v, err = r.ReadString(limit)
 			if err == io.EOF {
 				err = nil
 			}
@@ -197,19 +162,19 @@ func fileReadTextFunc(ctx kern.ExprContext, name string, args map[string]any) (r
 }
 
 func fileReadTextAllFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	var handle osHandle
+	var handle file.Handle
 	var invalidFileHandle any
 	var ok bool
 
 	result = nil
-	if handle, ok = args[kern.ParamHandle].(osHandle); !ok || args[kern.ParamHandle] == nil {
+	if handle, ok = args[kern.ParamHandle].(file.Handle); !ok || args[kern.ParamHandle] == nil {
 		invalidFileHandle = args[kern.ParamHandle]
 	}
 
 	if handle != nil {
-		if r, ok := handle.(*osReader); ok {
+		if r, ok := handle.(*file.Reader); ok {
 			var b []byte
-			b, err = io.ReadAll(r.reader)
+			b, err = r.ReadAll()
 			result = string(b)
 		} else {
 			invalidFileHandle = handle
@@ -253,9 +218,14 @@ func ImportOsFuncs(ctx kern.ExprContext) {
 		kern.NewFuncParam(kern.ParamHandle),
 	})
 
-	ctx.RegisterFunc("fileReadIterator", kern.NewGolangFunctor(fileReadIteratorFunc), kern.TypeIterator, []kern.ExprFuncParam{
+	ctx.RegisterFunc("fileLineIterator", kern.NewGolangFunctor(fileLineIteratorFunc), kern.TypeIterator, []kern.ExprFuncParam{
 		kern.NewFuncParam(paramHandleOrPath),
 	})
+
+	ctx.RegisterFunc("fileByteIterator", kern.NewGolangFunctor(fileByteIteratorFunc), kern.TypeIterator, []kern.ExprFuncParam{
+		kern.NewFuncParam(paramHandleOrPath),
+	})
+
 }
 
 func init() {

doc/Expr.adoc

@@ -1,6 +1,7 @@
 = Expr
 Expressions calculator
 :authors: Celestino Amoroso
+:email: celestino.amoroso@gmail.com
 :docinfo: shared
 :encoding: utf-8
 :toc: right
@@ -16,10 +17,11 @@ Expressions calculator
 :sectlinks:
 :sectanchors:
 :source-highlighter: rouge
-// :rouge-style: ThankfulEyes
-:rouge-style: gruvbox
-// :rouge-style: colorful
-//:rouge-style: monokay
+// :rouge-style: gruvbox
+:rouge-style: manni
+:stylesdir: /home/share/s3-howto/styles
+:stylesheet: adoc-colony.css
+
 // Workaround to manage double-column in back-tick quotes
 :2c: ::
 // Workaround to manage double-plus in back-tick quotes
@@ -34,7 +36,7 @@ Expressions calculator
 
 toc::[]
 
-#TODO: Work in progress (last update on 2026/04/21, 6:49 p.m.)#
+#TODO: Work in progress#
 
 == Expr
 _Expr_ is a GO package that can analyze, interpret and calculate expressions.
@@ -45,18 +47,18 @@ _Expr_ is a GO package that can analyze, interpret and calculate expressions.
 Expressions are texts containing sequences of operations represented by a syntax very similar to that of most programming languages. _Expr_ package provides these macro functions:
 
 * *_Scanner_* -- Its input is a text. It scans expression text characters to produce a flow of logical symbol and related attributes, aka tokens.
-* *_Parser_* -- Parser input is the token flow coming from the scanner. It analyses the token flow verifyng if it complies with the _Expr_ syntax. If that is the case, the Parser generates the Abstract Syntax Tree (AST). This is tree data structure that represents the components of an expressions and how they are related one each other.
+* *_Parser_* -- Parser input is the token flow coming from the scanner. It analyses the token flow verifying if it complies with the _Expr_ syntax. If that is the case, the Parser generates the Abstract Syntax Tree (AST). This is tree data structure that represents the components of an expression and how they are related to each other.
 * *_Calculator_*. Its input is the AST. It computes the parsed expression contained in the AST and returns the result or an error.
 
 image::expression-diagram.png[]
 
 ==== Variables
-_Expr_ supports variables. The result of an expression can be stored in a variable and reused in other espressions by simply specifying the name of the variable as an operand.
+_Expr_ supports variables. The result of an expression can be stored in a variable and reused in other expressions by simply specifying the name of the variable as an operand.
 
 ==== Multi-expression
 An input text valid for _Expr_ can contain more than an expression. Expressions are separated by [blue]`;` (semicolon). When an input contains two or more expressions it is called _multi-expression_.
 
-_Expr_ parses and computes each expression of a multi-espression, from the left to the right. If all expressions are computed without errors, it only returns the value of the last, the right most.
+_Expr_ parses and computes each expression of a multi-expression, from the left to the right. If all expressions are computed without errors, it only returns the value of the last, the right most.
 
 The result of each expression of a multi-expression is stored in an automatic variable named _last_. In this way, each expression can refer to the result of the previous one without the need to assign that value to a new dedicated variable.
 
@@ -74,7 +76,7 @@ Imported functions are registered in the _global context_. When an expression fi
 ===== Inspecting contexts
 _Expr_ provides the operator [blue]_$$_ that returns the current context. This can be used to inspect the content of the context, for example to check the value of a variable or to see which functions are currently linked to the context. This operator is primarily intended for debugging purposes.
 
-An interactive tool could like `dev-expr` (see <<_dev-expr_test_tool>>) can be used to inspect contexts interactively.
+An interactive tool like `ecli` (see <<_ecli_test_tool>>) can be used to inspect contexts interactively.
 
 
 .Example: inspecting contexts
@@ -100,26 +102,48 @@ An interactive tool could like `dev-expr` (see <<_dev-expr_test_tool>>) can be u
   [green]`{2sp}}` +
 [green]`}`
 
-In order to inspect the global context issue the [blue]`$$global` operator.
+In order to inspect the global context issue the [blue]`$$ global` operation.
+////
+.Example: list all functions whose name starts with "str"
+`>>>` [blue]`builtin "string`  [gray]__// most functions in the builtin module *string* have names starting with "str".__ +
+[green]`1`
 
-=== `dev-expr` test tool
-Before we begin to describe the syntax of _Expr_, it is worth introducing _dev-expr_ because it will be used to show many examples of expressions.
+:dollar: $
+:2dollars: $$
 
-`dev-expr` is a simple program that can be used to evaluate expressions interactively. As its name suggests, it was created for testing purpose.  In fact, in additon to the automatic verification test suite based on the Go test framework, `dev-expr` provided an important aid for quickly testing of new features during their development.
+`>>>` [blue]`($(($$global).functions) filter strStartsWith($_, "str"))` +
+[green]`[` +
+[green]`{2sp}"strEndsWith",` +
+[green]`{2sp}"strJoin",` +
+[green]`{2sp}"strLower",` +
+[green]`{2sp}"strSplit",` +
+[green]`{2sp}"strStartsWith",` +
+[green]`{2sp}"strSub",` +
+[green]`{2sp}"strTrim",` +
+[green]`{2sp}"strUpper",` +
+[green]`{2sp}"string"` +
+[green]`]`
+////
 
-`dev-expr` can work as a _REPL_, _**R**ead-**E**xecute-**P**rint-**L**oop_, or it can process expression acquired from files or standard input.
+[[sec_ecli]]
+=== `ecli` Expression Calculator Interactive Tool
+Before we begin to describe the syntax of _Expr_, it is worth introducing _ecli_, former _dev-expr_, because it will be used to show many examples of expressions.
 
-The program can be downloaded from https://git.portale-stac.it/go-pkg/-/packages/generic/dev-expr/[dev-expr].
+`ecli` is a simple program that can be used to evaluate expressions interactively. As its name suggests, it was created for testing purpose.  In fact, in addition to the automatic verification test suite based on the Go test framework, `ecli` provided an important aid for quickly testing of new features during their development.
+
+`ecli` can work as a _REPL_, _**R**ead-**E**xecute-**P**rint-**L**oop_, or it can process expression acquired from files or standard input.
+
+The program can be downloaded from https://git.portale-stac.it/go-pkg/-/packages/generic/ecli/[ecli].
 
 Here are some examples of execution.
 
-.Run `dev-expr` in REPL mode and ask for help
+.Run `ecli` in REPL mode and ask for help
 [source,shell]
 ----
 # Type 'exit' or Ctrl+D to quit the program.
 
-[user]$ ./dev-expr
-dev-expr -- Expressions calculator v1.12.0(build 1),2024/09/14 (celestino.amoroso@portale-stac.it)
+[user]$ ./ecli
+ecli -- Expressions calculator v1.12.0(build 1),2024/09/14 (celestino.amoroso@portale-stac.it)
 	Based on the Expr package v0.26.0
 	Type help to get the list of available commands
 	See also https://git.portale-stac.it/go-pkg/expr/src/branch/main/README.adoc
@@ -155,8 +179,8 @@ dev-expr -- Expressions calculator v1.12.0(build 1),2024/09/14 (celestino.amoros
 .REPL examples
 [source,shell]
 ----
-[user]$ ./dev-expr
-dev-expr -- Expressions calculator v1.10.0(build 14),2024/06/17 (celestino.amoroso@portale-stac.it)
+[user]$ ./ecli
+ecli -- Expressions calculator v1.10.0(build 14),2024/06/17 (celestino.amoroso@portale-stac.it)
 	Based on the Expr package v0.19.0
 	Type help to get the list of available commands
 	See also https://git.portale-stac.it/go-pkg/expr/src/branch/main/README.adoc
@@ -223,14 +247,20 @@ Value range: *-9223372036854775808* to *9223372036854775807*
 [cols="^1,^2,6,4"]
 |===
 | Symbol    | Operation     | Description               | Examples
-| [blue]`+` | _Sum_         | Add two values            | [blue]`-1 + 2` -> _1_
+| [blue]`+` | _Sum_         | Add two values^(<<note_int_plus_string,1>>)^            | [blue]`-1 + 2` -> _1_
 | [blue]`-` | _Subtraction_ | Subtract the right value from the left one | [blue]`3 - 1` -> _2_
-| [blue]`*` | _Product_     | Multiply two values       | [blue]`-1 * 2` -> _-2_
-| [blue]`/` | _Integer division_    | Divide the left value by the right one^(*)^ | [blue]`-11 / 2` -> _-5_
+| [blue]`*` | _Product_     | Multiply two values^(<<note_string_repl,2>>)^       | [blue]`-1 * 2` -> _-2_
+| [blue]`/` | _Integer division_    | Divide the left value by the right one^(<<note_float_division,3>>)^ | [blue]`-11 / 2` -> _-5_
 | [blue]`%` | _Modulo_      | Remainder of the integer division | [blue]`5 % 2` -> _1_
 |===
+[[note_int_plus_string]]
+^(1)^ The sum operator [blue]`+` also supports adding an integer number to a string. In this case, the number is converted to a string and prependend or appended to the string, e.g. `"x" + 48` results in `"x48"`.
 
-^(*)^ See also the _float division_ [blue]`./` below.
+[[note_string_repl]]
+^(2)^ The product operator also supports multiplying a string by an integer. In this case, the number represents how many times the string has to be repeated in the result, e.g. `"foo" * 3` returns `"foofoofoo"`.
+
+[[note_float_division]]
+^(3)^ See also the _float division_ [blue]`./` below.
 
 
 ==== Floats
@@ -268,12 +298,14 @@ _dec-seq_ = _see-integer-literal-syntax_
 [cols="^1,^2,6,4"]
 |===
 | Symbol    | Operation     | Description               | Examples
-| [blue]`+` | _Sum_         | Add two values            | [blue]`4 + 0.5` -> 4.5
+| [blue]`+` | _Sum_         | Add two values^(<<note_float_plus_string,1>>)^            | [blue]`4 + 0.5` -> 4.5
 | [blue]`-` | _Subtraction_ | Subtract the right value from the left one | [blue]`4 - 0.5` -> 3.5
 | [blue]`*` | _Product_     | Multiply two values       | [blue]`4 * 0.5` -> 2.0
 | [blue]`/` | _Float division_    | Divide the left value by the right one | [blue]`1.0 / 2` -> 0.5
 | [blue]`./`| _Forced float division_ | Force float division   | [blue]`-1 ./ 2` -> -0.5
 |===
+[[note_float_plus_string]]
+^(1)^ The sum operator [blue]`+` also supports adding a float number to a string. In this case, the number is converted to a string and prependend or appended to the string, e.g. `"x" + 1.2` results in `"x1.2"`.
 
 ==== Fractions
 _Expr_ also supports fractions. Fraction literals are made with two integers separated by a colon character `:`.
@@ -364,7 +396,7 @@ Some arithmetic operators also apply to strings.
 | [blue]`*` | _repeat_ | Make _n_ copy of a string  | [blue]`"one" * 2` -> _"oneone"_
 |===
 
-The charanters in a string can be accessed using the square `[]` operator.
+The characters in a string can be accessed using the square `[]` operator.
 
 .Item access syntax
 ====
@@ -387,7 +419,7 @@ The charanters in a string can be accessed using the square `[]` operator.
 [green]`"d"`
 
 `>>>` [blue]`#s`       [gray]_// number of chars_ +
-[gren]`4`
+[green]`4`
 
 `>>>` [blue]`#"abc"`    [gray]_// number of chars_ +
 [green]`3`
@@ -444,14 +476,14 @@ Currently, boolean operations are evaluated using _short cut evaluation_. This m
 ----
 2 > (a=1) or (a=8) > 0; a // <1>
 ----
-<1> This multi-expression returns _1_ because in the first expression the left value of [blue]`or` is _true_ and, as a conseguence, its right value is not computed. Therefore the _a_ variable only receives the integer _1_.
+<1> This multi-expression returns _1_ because in the first expression the left value of [blue]`or` is _true_ and, as a consequence, its right value is not computed. Therefore the _a_ variable only receives the integer _1_.
 
 
-TIP: `dev-expr` provides the _ctrl()_ function that allows to change this behaviour.
+TIP: `ecli` provides the _ctrl()_ function that allows to change this behaviour.
 ====
 
 === Lists
-_Expr_ supports list of mixed-type values, also specified by normal expressions. Internally, _Expr_'s lists are Go arrays.
+_Expr_ supports list of mixed-type values, also specified by normal expressions. Internally, _Expr_'s lists are Go slices.
 
 .List literal syntax
 ====
@@ -556,7 +588,21 @@ Array's items can be accessed using the index `[]` operator.
 `>>>` [blue]`[1,2,3,2,4] - [2,4]` +
 [green]`[1, 3]`
 
+=== Linked Lists
+Linked lists are a special kind of lists that are used to represent sequences of items that can be easily modified. They are represented as lists of two items: the first item is the value of the current node, and the second item is the next node in the list. The last node in the list has a next node that is _nil_. 
 
+Internally,Expr's linked lists hold two pointers: one to the head of the list and one to the tail of the list. This allows for efficient insertion and deletion of items at both ends of the list. Also, linked lists keep track of their size, so the number of items in a linked list can be obtained in constant time.
+
+.Linked List literal syntax
+====
+*_linked-list_* = "**[<**" [_item-expr_ {"**,**" _item-expr_}] "**>]**" +
+_item-expr_ = _any-value_
+====
+
+`>>>` [blue]`ls=[<1,2,3,4>]` +
+[green]`[<1, 2, 3, 4>]`
+
+#todo: to be completed#
 
 === Dictionaries
 The _dictionary_, or _dict_, data-type represents sets  of pairs _key/value_. It is also known as _map_ or _associative array_.
@@ -678,7 +724,7 @@ The value of each sub-expression is stored in the automatic variable _last_.
 [green]`2`
 
 `>>>` [blue]`x=2*3 but x-1` +
-[green]`5`.
+[green]`5`
 
 [blue]`but` behavior is very similar to [blue]`;`. The only difference is that [blue]`;` is not a true operator and can't be used inside parenthesis [blue]`(` and [blue]`)`.
 
@@ -698,9 +744,9 @@ The value on the left side of [blue]`=` must be a variable identifier or an expr
 === Selector operator [blue]`? : ::`
 The _selector operator_ is very similar to the _switch/case/default_ statement available in many programming languages.
 
-.Selector literal Syntax
+.Selector literal syntax
 ====
-_selector-operator_ = _select-expression_ "*?*" _selector-case_ { "*:*" _selector-case_ } ["*::*" _default-multi-expression_] +
+*_selector-operator_* = _select-expression_ "*?*" _selector-case_ { "*:*" _selector-case_ } ["*::*" _default-multi-expression_] +
 _selector-case_ = [_match-list_] _case-value_ +
 _match-list_ = "*[*" _item_ {"*,*" _items_} "*]*" +
 _item_ = _expression_ +
@@ -737,19 +783,38 @@ The [blue]`:` symbol (colon) is the separator of the selector-cases. Note that i
 `>>>` [blue]`10 ? {"a"} : {"b"}` +
 [red]`Eval Error: [1:3] no case catches the value (10) of the selection expression`
 
+==== Triple special case of the selector operator
+If the _select-expression_ is a boolean expression, the selector operator can be used as a sort of _if-then-else_ statement. In this case, the first case is evaluated if the _select-expression_ is true, and the second case is evaluated if the _select-expression_ is false. In this special case, the _match-list_ of both cases must be empty.
+
+.Example
+`>>>` [blue]`(true) ? {"T"}: {"F"}` +
+[green]`T` +
+`>>>` [blue]`(2 > 1) ? {"a"} : {"b"}` +
+[green]`a` +
+`>>>` [blue]`(2 < 1) ? {"a"} : {"b"}` +
+[green]`b`
+
+[WARNING]
+====
+The triple special case of the selector operator is very useful, but it only works with boolean expressions.
+
+.Example of confusion
+`>>>` [blue]`int(true) ? {"T"}: {"F"}` +
+[green]`F`
+====
 
 === Variable default value [blue]`??`, [blue]`?=`, and [blue]`?!`
-The left operand of the first two operators, [blue]`??` and [blue]`?=`, must be a variable. The right operator can be any expression. They return the value of the variable if this is defined; otherwise they return the value of the right expression.
+The left operand of the first two operators, [blue]`??` and [blue]`?=`, must be a variable. The right operand can be any expression. They return the value of the variable if this is defined; otherwise they return the value of the right expression.
 
 IMPORTANT: If the left variable is defined, the right expression is not evaluated at all.
 
 The [blue]`??` operator do not change the status of the left variable.
 
-The [blue]`?=` assigns the calculated value of the right expression to the left variable.
+The [blue]`?=` assigns the calculated value of the right expression to the variable on the left side.
 
-The third one, [blue]`?!`, is the alternate operator. If the variable on the left size is not defined, it returns [blue]_nil_. Otherwise it returns the result of the expressione on the right side.
+The third one, [blue]`?!`, is the alternate operator. If the variable on the left side is not defined, it returns [blue]_nil_. Otherwise it returns the result of the expression on the right side.
 
-IMPORTANT: If the left variable is NOT defined, the right expression is not evaluated at all.
+IMPORTANT: If the variable [blue]`?!` is NOT defined, the expression is not evaluated at all.
 
 .Examples
 `>>>` [blue]`var ?? (1+2)` +
@@ -836,14 +901,20 @@ The table below shows all supported operators by decreasing priorities.
 .2+|*INSERT*| [blue]`+>` | _Infix_ | _Prepend_ | _any_ `+>` _list_ -> _list_
 | [blue]`<+` | _Infix_ | _Append_ | _list_ `<+` _any_ -> _list_
 .2+|*ASSIGN*| [blue]`=` | _Infix_ | _Assignment_ | _identifier_ `=` _any_ -> _any_
-4+| _See also the table of special allocation operators below_
+4+| _See also the table of special assignment operators below_
 .1+|*BUT*| [blue]`but` | _Infix_ | _But_ | _any_ `but` _any_ -> _any_
+.6+|*ITER-OP*| [blue]`digest` | _Infix_ | _Item-digesting_ | _iterable_ `digest` _expr_ -> _any_
+| [blue]`filter` | _Infix_ | _Item-filtering_ | _iterable_ `filter` _expr_ -> _list_
+| [blue]`groupby` | _Infix_ | _Dict-grouping_ | _iterable_ `groupby` _key-expr_ -> _dict_
+| [blue]`cat` | _Infix_ | _Item-concatenation_ | _iterable_ `cat ` _iterable_ -> _list_
+| [blue]`map` | _Infix_ | _Item-mapping_ | _iterable_ `map` _-expr_ -> _list_
+4+| _See iterators section for examples_
 .1+|*RANGE*| [blue]`:` | _Infix_ | _Index-range_ | _integer_ `:` _integer_ -> _integer-pair_
 |===
 
 //^1^ Experimental
 
-.Special assignment perators
+.Special assignment operators
 [cols="^2,^2,^4,^6"]
 |===
 | Priority | Operator    | Operation |Equivalent operation
@@ -921,12 +992,12 @@ _param-name_ = _identifier_
 [green]`fib(n):any{}`
 
 `>>>` [gray]_// Required and optional parameters_ +
-`>>>` [blue]`measure = func(value, unit="meter"){ value + " " + unit + (value > 1) ? [true] {"s"} :: {""}}` +
+`>>>` [blue]`measure = func(value, unit="meter"){ value + " " + unit + (value > 1) ? {"s"} :: {""}}` +
 [green]`measure(value, unit="meter"):any{}`
 
 
 === _Golang_ function definition
-Description of how to define Golang functions and how to bind them to _Expr_ are topics covered in another document that I'll write, one day, maybe.
+Description of how to define Golang functions and how to bind them to _Expr_ are topics covered in other documents.
 
 === Function calls
 To call a function, either Expr or Golang type, it is necessary to specify its name and, at least, its required parameters.
@@ -1010,7 +1081,7 @@ Clone variables are normal local variables. The only diffence will appear when t
 .Example
 `>>>` [blue]`f = func() { @x = 3; x = 5 }` [gray]_// f() declares two *different* local variables: ``@x`` and ``x``_ +
 [green]`f():any{}` +
-`>>>` [blue]`f()` [gray]_// The multi-expression (two) in f() is calculated and the last result is returned_ +
+`>>>` [blue]`f()` [gray]_// The multi-expression (two expressions) in f() is calculated and the last result is returned_ +
 [green]`5` +
 `>>>` [blue]`x` [gray]_// The `x` variable was not defined in the main context before the f() invocation. It appears in the main context by cloning the `@x` variable, local to f() after its termnation._ +
 [green]`3`
@@ -1048,7 +1119,7 @@ Builtins activation is done by using the [blue]`BUILTIN` operator. All modules e
 
 .Builtin activation syntax
 ====
-*_builtin-activation_* = [blue]`BUILTIN` (_builtin-name_ | _list-of-builtin-names_) +
+*_builtin-activation_* = [blue]`BUILTIN` (_builtin-name_ | _list-of-builtin-names_ | **"*"**) +
 _builtin-name_ = _string_ +
 _list-of-builtin-names_ = **[** _string_ { "**,**" _string_ } **]**
 ====
@@ -1086,9 +1157,9 @@ The "base" builtin module provides functions for type checking and type conversi
 * <<_fract,fract()>>
 
 .Other functions
+* <<_char,char()>>
 * <<_eval,eval()>>
 * <<_set,set()>>
-* <<_unset,unset()>>
 * <<_var,var()>>
 
 
@@ -1100,7 +1171,9 @@ Returns _true_ if the value type of _<expr>_ is boolean, false otherwise.
 `>>>` [blue]`isBool(true)` +
 [green]`true` +
 `>>>` [blue]`isBool(3==2)` +
-[green]`true`
+[green]`true` +
+`>>>` [blue]`isBool(3 + 2)` +
+[green]`false`
 
 ===== isDict()
 Syntax: `isDict(<expr>) -> bool` +
@@ -1178,7 +1251,7 @@ Returns _true_ if the value type of _<expr>_ is fraction or int, false otherwise
 
 ===== isString()
 Syntax: `isString(<expr>) -> bool` +
-Returns a boolean value , false otherwise.
+Returns _true_ if the value type of _<expr>_ is string, false otherwise.
 
 .Examples
 `>>>` [blue]`isString("ciao")` +
@@ -1190,7 +1263,7 @@ Returns a boolean value , false otherwise.
 
 ===== bool()
 Syntax: `bool(<expr>) -> bool` +
-Returns a _boolean_ value consisent to the value of the expression.
+Returns a _boolean_ value consistent with the value of the expression.
 
 .Examples
 `>>>` [blue]`bool(1)` +
@@ -1295,6 +1368,16 @@ Returns a _fraction_ value consistent with the value of the expression.
 `>>>` [blue]`fract(true)` +
 [green]`1:1`
 
+===== char()
+Syntax: `char(<intexpr>) -> string` +
+Returns the character whose ASCII (soon Unicode too) code point is specified by the integer expression.
+
+.Examples
+`>>>` [blue]`char(65)` +
+[green]`"A"` +
+`>>>` [blue]`char(97)` +
+[green]`"a"`
+
 ===== eval()
 Syntax: `eval(<string-expr>) -> any` +
 Computes and returns the value of the [.underline]#string# expression.
@@ -1308,12 +1391,12 @@ Syntax: +
  `{4sp}var(<string-expr>, <expr>) -> any` +
  `{4sp}var(<string-expr>) -> any`
 
-This function allows you to define variables whose names must include special characters. The first form of the function allows you to define a variable with a name specified by the first parameter and assign it the value of the second parameter. The second form only returns the value of the variable with the specified name.
+This function allows you to define variables whose names can include special characters. The first form of the function allows you to define a variable with a name specified by the first parameter and assign it the value of the second parameter. The second form only returns the value of the variable with the specified name.
 
 .Examples
 `>>>` [blue]`var("$x", 3+9)` +
 [green]`12` +
-`>>>` [blue]`var("$x")` +
+`>>>` [blue]`var("$"+"x")` +
 [green]`12` +
 `>>>` [blue]`var("gain%", var("$x"))` +
 [green]`12` +
@@ -1334,26 +1417,17 @@ It is equivalent to the first form of the var() function, but it is more explici
 `>>>` [blue]`var("$x")` +
 [green]`100` +
 
-===== unset()
-Syntax: +
- `{4sp}unset(<string-expr>) -> any`
-
-This function allows you to unset a variable whose name can include special characters. The parameter is the name of the variable to unset.
-
-.Examples
-`>>>` [blue]`unset("$x")` +
-[green]`nil` +
-`>>>` [blue]`var("$x")` +
-[red]`Eval Error: var(): unknown variable "$x"`
 
 ==== Module "fmt"
+#to-do#
 
 ===== print()
 
 ===== println()
 
 ==== Module "import"
-Module actiovation: +
+Module activation: +
+`{4sp}BUILTIN "import"`
 
 ===== _import()_
 Syntax: +
@@ -1364,6 +1438,8 @@ Loads the multi-expression contained in the specified source and returns its val
 ===== _importAll()_
 
 ==== Module "iterator"
+Module activation: +
+`{4sp}BUILTIN "iterator"`
 
 ===== run()
 Syntax: +
@@ -1372,6 +1448,9 @@ Syntax: +
 Iterates over the specified iterator and applies the specified operator to the current value of the iterator.
 
 ==== Module "math.arith"
+Module activation: +
+`{4sp}BUILTIN "math.arith"`
+
 Currently, the "math.arith" module provides two functions, add() and mul(), that perform addition and multiplication of an arbitrary number of parameters. More functions will be added in the future.
 
 * <<_add,add()>>
@@ -1421,13 +1500,12 @@ Same as <<_add,add()>> but returns the product of the values of the parameters.
 [green]`24`
 
 ==== Module "os.file"
+Module activation: +
+`{4sp}BUILTIN "os.file"`
+
 The "os.file" module provides functions for working with files.
 
-Activation: +
-`{4sp}builtin "os.file"`
-
-Currently available functions:
-
+.File related functions
 * <<_fileOpen,fileOpen()>>
 * <<_fileAppend,fileAppend()>>
 * <<_fileCreate,fileCreate()>>
@@ -1436,6 +1514,10 @@ Currently available functions:
 * <<_fileReadText,fileReadText()>>
 * <<_fileReadTextAll,fileReadTextAll()>>
 
+.Iterator functions for files
+* <<_fileByteIterator,fileByteIterator()>>
+* <<_fileLineIterator,fileLineIterator()>>
+
 More functions will be added in the future.
 
 ---
@@ -1447,6 +1529,10 @@ Syntax: +
 Returns a file handle for the specified file path. The file is opened in read-write mode. If the file does not exist, it is created.
 
 ===== fileAppend()
+Syntax: +
+`{4sp}fileAppend(<file-path>) -> any`
+
+Like <<_fileCreate,fileCreate()>> but write operations happen at the end of the file.
 
 ===== fileCreate()
 Syntax: +
@@ -1455,21 +1541,76 @@ Syntax: +
 Creates or truncates the named _<file-path>_. If the file already exists, it is truncated. If the file does not exist, it is created with mode 0o666 (before umask). The associated file descriptor has mode [O_RDWR]. The directory containing the file must already exist.
 
 ===== fileClose()
+#to-do#
 
 ===== fileWriteText()
+#to-do#
 
 ===== fileReadText()
+#to-do#
 
 ===== fileReadTextAll()
+#to-do#
+
+===== fileByteIterator()
+Syntax: +
+`{4sp}fileByteIterator(handle-or-path) -> iterator`
+
+Returns an iterator that produces the bytes of the specified file. The parameter can be either a file handle or a file path. If a file path is provided, the file is opened and closed automatically by the iterator.
+
+.Examples
+>>> builtin "os.file" +
+[green]`1` +
+`>>>` [blue]`fileByteIterator("test-file.txt") map $_` +
+[green]`[
+  117,
+  110,
+  111,
+  10,
+  100,
+  117,
+  101,
+  10
+]`
+
+>>> builtin ["os.file", "string"] +
+[green]`2` +
+`>>>` [blue]`fileByteIterator("test-file.txt") map char($_)` +
+[green]`[
+  "u",
+  "n",
+  "o",
+  "
+",
+  "d",
+  "u",
+  "e",
+  "
+",
+]`
+
+===== fileLineIterator()
+Syntax: +
+`{4sp}fileLineIterator(handle-or-path) -> iterator`
+
+Returns an iterator that produces the lines of the specified file. The parameter can be either a file handle or a file path. If a file path is provided, the file is opened and closed automatically by the iterator.
+
+.Examples
+`>>>` [blue]`builtin "os.file"` +
+[green]`1` +
+`>>>` [blue]`fileLineIterator("test-file.txt") map $_` +
+[green]`[
+  "uno",
+  "due"
+]`
 
 
 ==== Module "string"
+Module activation: +
+`{4sp}BUILTIN "string"`
+
 This module provides functions for working with strings.
 
-Activation: +
-`{4sp}builtin "string"`
-
-
 Currently available functions:
 
 * <<_strJoin,strJoin()>>
@@ -1585,6 +1726,8 @@ Returns a string obtained by converting all characters of the specified string t
 `>>>` [blue]`strLower("Hello, world!")` +
 [green]`"hello, world!"`
 
+
+
 == Iterators
 Iterators are objects that can be used to traverse collections, such as lists and dictionaries. They are created by providing a _data-source_ object, the collection, in a `$(<data-source>)` expression. Once an iterator is created, it can be used to access the elements of the collection one by one.
 
@@ -1599,16 +1742,16 @@ _data-source_ = _explicit_ | _list-spec_ | _dict-spec_ | _custom-data-source_
 
 _explicit_ = _any-expr_ { "**,**" _any-expr_ }
 
-_list-spec_ = _list_  _range-options_ +
+_list-spec_ = _list_  ["**,**" _range-options_] +
 _list_ = "**[**" _any-expr_ { "**,**" _any-expr_ } "**]**" +
-_range-options_ = [ "**,**" _start-index_ [ "**,**" _end-index_ [ "**,**" _step_ ]]] +
+_range-options_ = _start-index_ [ "**,**" _end-index_ [ "**,**" _step_ ]] +
 _start-index_, _end-index_, _step_ = _integer-expr_
 
-_dict-spec_ = _dict_  _dict-options_ +
+_dict-spec_ = _dict_  ["**,**" _dict-options_] +
 _dict_ = "**{**" _key-value-pair_ { "**,**" _key-value-pair_ } "**}**" +
 _key-value-pair_ = _scalar-value_ "**:**" _any-expr_ +
 _scalar-value_ = _string_ | _number_ | _boolean_ +
-_dict-options_ = [ "**,**" _sort-order_ [ "**,**" _iter-mode_ ] ] +
+_dict-options_ = _sort-order_ [ "**,**" _iter-mode_ ] +
 _sort-order_ = _asc-order_ | _desc-order_ | _no-sort_ | _default-order_ +
 _asc-order_ = "**asc**" | "**a**" +
 _desc-order_ = "**desc**" | "**d**" +
@@ -1686,7 +1829,7 @@ Negative steps are also allowed. They are interpreted as reverse iteration. For
 The above example shows the use of the [blue]`{plusplus}` operator to get the next element of an iterator. The [blue]`{plusplus}` operator is a postfix operator that can be used with iterators. It returns the next element of the collection and updates the state of the iterator. When there are no more elements to iterate over, it returns the error [red]_Eval Error: EOF_.
 
 
-After the first use of the [blue]`{plusplus}` operator, the prefixed operato [blue]`{star}` operator can be used to get the current element of the collection without updating the state of the iterator. When there are no more elements to iterate over, it returns the error [red]_Eval Error: EOF_. Same error is returned if the [blue]`{star}` operator is used before the first use of the [blue]`{plusplus}` operator.
+After the first use of the [blue]`{plusplus}` operator, the prefixed operator [blue]`{star}` operator can be used to get the current element of the collection without updating the state of the iterator. When there are no more elements to iterate over, it returns the error [red]_Eval Error: EOF_. Same error is returned if the [blue]`{star}` operator is used before the first use of the [blue]`{plusplus}` operator.
 
 .Example: using the [blue]`{star}` operator
 `>>>` [blue]`it = $(["one", "two", "three"])` +
@@ -1698,12 +1841,17 @@ After the first use of the [blue]`{plusplus}` operator, the prefixed operato [bl
 `>>>` [blue]`{star}it` +
 [green]`"one"`
 
+==== [blue]*`$$()`* -- Expansion special function for iterators
+The [blue]`$$()` operator is a special function already seen applied to contexts. It can also be applied to iterators. When applied to an iterator, it returns a _linked list_ of all the remaining elements of the collection. The state of the iterator is updated to the end of the collection. If there are no more elements to iterate over, it returns an empty list.
+
+#todo: examples#
+
 ==== Named operators
 Named operators are operators that are identified by a name instead of a symbol. They are implicitly defined and can be called using a special syntax. For example, the [blue]`{plusplus}` has the equivalent named operator [blue]`.next`.
 
 .Available named operators
 * *_.next_*: same as [blue]`{plusplus}`.
-* *_.current_*: same as [blue]`{star}`.
+* *_.current_*: same as [blue]`{star}.`
 * *_.reset_*: resets the state of the iterator to the initial state.
 * *_.count_*: returns the number of elements in the iterator already visited.
 * *_.index_*: returns the index of the current element in the iterator. Before the first use of the [blue]`{plusplus}` operator, it returns the error [red]_-1_.
@@ -1726,6 +1874,92 @@ TIP: Iterators built on custom data-sources can provide additional named operato
 `>>>` [blue]`it.next` +
 [green]`"one"`
 
+=== Infixed operators on iterators
+There are also some infixed operators that can be used with iterators. They are defined as follows.
+
+* <<_cat,cat operator>>
+* <<_digest,digest operator>>
+* <<_filter,filter operator>>
+* <<_groupby,groupby operator>>
+* <<_map,map operator>>
+//* <<_reduce,reduce operator>>: applies a binary expression cumulatively to the elements of the iterator, from left to right, to reduce the iterator to a single value.
+//* <<_zip,zip operator>>: takes two or more iterators and returns a list of tuples, where the i-th tuple contains the i-th element from each of the input iterators.
+
+
+==== Automatic variables in operators
+At each iteration, the following automatic variables are available for use in the expression of the [blue]`digest`, [blue]`filter`, [blue]`groupby`, and [blue]`map` operators.
+
+* `$_`: the current element of the iterator.
+* `$__`: the index of the current element in the iterator, starting from 0.
+* `$#`: the number of elements already visited in the iterator, starting from 0.
+
+---
+
+==== [blue]`cat` operator
+Syntax: +
+`{4sp}<iterable> cat <iterable> -> <iterator>{4sp}`
+
+[blue]`cat` operator takes two iterators or iterables and returns a new iterator that produces the elements of the first iterator followed by the elements of the second iterator.
+
+.Examples
+#todo: examples#
+
+==== [blue]`filter` operator
+Syntax: +
+`{4sp}<iterable> filter <expr> -> <iterator>{4sp}`
+
+[blue]`filter` applies a boolean expression to each element of the iterator and returns a new iterator that only produces the elements of the first iterator for which the expression evaluates to true.
+
+.Examples
+#todo: examples#
+
+
+==== [blue]`groupby` operator
+Syntax: +
+`{4sp}<list-of-dicts> groupby <key> -> <dict>{4sp}`
+
+The left side of [blue]`groupby` operator is a list ofdictionaries or an iterator over a list of dictionaries. It takes a key and returns a dictionary where the keys are the unique values of the specified key in the dictionaries and the values are lists of dictionaries that have that key value. In other words, it groups the dictionaries by the specified key value.
+
+NOTE: Currently, keys of group are always strings. In the future, it will be possible to specify a key function to compute the keys of the groups.
+
+.Examples
+`>>>` [blue]`[{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}, {"name": "Charlie", "age": 30}] groupby "age"` +
+[source,yaml]
+----
+{
+  "25": [
+    {
+      "name": "Bob",
+      "age": 25
+    }
+  ],
+  "30": [
+    {
+      "name": "Alice",
+      "age": 30
+    },
+    {
+      "name": "Charlie",
+      "age": 30
+    }
+  ]
+}
+----
+
+==== [blue]`map` operator
+Syntax: +
+`{4sp}<iterable> map <expr> -> <iterator>{4sp}`
+
+[blue]`map` operator iterates over the elements of the iterator and evaluates the expressions provided on the right side for each element. Its result is a new iterator over the computed values of the that expression. The current element of the iterator is available in the expression as the variable `$_`.
+
+.Example: using the [blue]`map` operator
+`>>>` [blue]`it = $(["one", "two", "three"])` +
+[green]`$(#3)` +
+`>>>` [blue]`excl_it = it map $_ + "!"` +
+[green]`$($([#3]))` +
+`>>>` [blue]`$$(excl_it)` +
+[green]`[<"one!", "two!", "three!">]`
+
 === Iterator over custom data-sources
 It is possible to create iterators over custom data-sources by defining a dictionary that has the key `next` whose value is a function that returns the next element of the collection and updates the state of the iterator. The syntax for creating an iterator over a custom data-source is as follows.
 

doc/Expr.html

@@ -581,7 +581,11 @@ pre.rouge .ss {
 <li><a href="#_operator">4.1. <code class="blue">;</code> operator</a></li>
 <li><a href="#_but_operator">4.2. <code class="blue">but</code> operator</a></li>
 <li><a href="#_assignment_operator">4.3. Assignment operator <code class="blue">=</code></a></li>
-<li><a href="#_selector_operator">4.4. Selector operator <code class="blue">? : ::</code></a></li>
+<li><a href="#_selector_operator">4.4. Selector operator <code class="blue">? : ::</code></a>
+<ul class="sectlevel3">
+<li><a href="#_triple_special_case_of_the_selector_operator">4.4.1. Triple special case of the selector operator</a></li>
+</ul>
+</li>
 <li><a href="#_variable_default_value_and">4.5. Variable default value <code class="blue">??</code>, <code class="blue">?=</code>, and <code class="blue">?!</code></a></li>
 </ul>
 </li>
@@ -613,8 +617,10 @@ pre.rouge .ss {
 <li><a href="#_dec">dec()</a></li>
 <li><a href="#_string">string()</a></li>
 <li><a href="#_fract">fract()</a></li>
+<li><a href="#_char">char()</a></li>
 <li><a href="#_eval">eval()</a></li>
 <li><a href="#_var">var()</a></li>
+<li><a href="#_set">set</a></li>
 </ul>
 </li>
 <li><a href="#_module_fmt">7.1.2. Module "fmt"</a>
@@ -649,6 +655,8 @@ pre.rouge .ss {
 <li><a href="#_filewritetext">fileWriteText()</a></li>
 <li><a href="#_filereadtext">fileReadText()</a></li>
 <li><a href="#_filereadtextall">fileReadTextAll()</a></li>
+<li><a href="#_filebyteiterator">fileByteIterator()</a></li>
+<li><a href="#_filelineiterator">fileLineIterator()</a></li>
 </ul>
 </li>
 <li><a href="#_module_string">7.1.7. Module "string"</a>
@@ -674,7 +682,15 @@ pre.rouge .ss {
 <li><a href="#_named_operators">8.1.1. Named operators</a></li>
 </ul>
 </li>
-<li><a href="#_iterator_over_custom_data_sources">8.2. Iterator over custom data-sources</a></li>
+<li><a href="#_infixed_operators_on_iterators">8.2. Infixed operators on iterators</a>
+<ul class="sectlevel3">
+<li><a href="#_cat_operator">8.2.1. <code class="blue">cat</code> operator</a></li>
+<li><a href="#_filter_operator">8.2.2. <code class="blue">filter</code> operator</a></li>
+<li><a href="#_groupby_operator">8.2.3. <code class="blue">groupby</code> operator</a></li>
+<li><a href="#_map_operator">8.2.4. <code class="blue">map</code> operator</a></li>
+</ul>
+</li>
+<li><a href="#_iterator_over_custom_data_sources">8.3. Iterator over custom data-sources</a></li>
 </ul>
 </li>
 <li><a href="#_plugins">9. Plugins</a></li>
@@ -686,7 +702,7 @@ pre.rouge .ss {
 <div class="sectionbody">
 <!-- toc disabled -->
 <div class="paragraph">
-<p><mark>TODO: Work in progress (last update on 2026/04/15, 6:02 p.m.)</mark></p>
+<p><mark>TODO: Work in progress (last update on 2026/05/08)</mark></p>
 </div>
 </div>
 </div>
@@ -788,7 +804,26 @@ pre.rouge .ss {
 <code class="green">}</code></p>
 </div>
 <div class="paragraph">
-<p>In order to inspect the global context issue the <code class="blue">$$global</code> operator.</p>
+<p>In order to inspect the global context issue the <code class="blue">$$ global</code> operation.</p>
+</div>
+<div class="paragraph">
+<div class="title">Example: list all functions whose name starts with "str"</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">builtin "string</code>  <em class="gray">// most function in the builtin module <strong>string</strong> have names starting with "str".</em><br>
+<code class="green">1</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">($$$global).functions) filter strStartsWith($_, "str"</code><br>
+<code class="green">[</code><br>
+<code class="green">&#160;&#160;"strEndsWith",</code><br>
+<code class="green">&#160;&#160;"strJoin",</code><br>
+<code class="green">&#160;&#160;"strLower",</code><br>
+<code class="green">&#160;&#160;"strSplit",</code><br>
+<code class="green">&#160;&#160;"strStartsWith",</code><br>
+<code class="green">&#160;&#160;"strSub",</code><br>
+<code class="green">&#160;&#160;"strTrim",</code><br>
+<code class="green">&#160;&#160;"strUpper",</code><br>
+<code class="green">&#160;&#160;"string"</code><br>
+<code class="green">]</code></p>
 </div>
 </div>
 </div>
@@ -1880,10 +1915,10 @@ Technically <code class="blue">;</code> is not treated as a real operator. It ac
 <p>The <em>selector operator</em> is very similar to the <em>switch/case/default</em> statement available in many programming languages.</p>
 </div>
 <div class="exampleblock">
-<div class="title">Example 13. Selector literal Syntax</div>
+<div class="title">Example 13. Selector literal syntax</div>
 <div class="content">
 <div class="paragraph">
-<p><em>selector-operator</em> = <em>select-expression</em> "<strong>?</strong>" <em>selector-case</em> { "<strong>:</strong>" <em>selector-case</em> } ["<strong>::</strong>" <em>default-multi-expression</em>]<br>
+<p><strong><em>selector-operator</em></strong> = <em>select-expression</em> "<strong>?</strong>" <em>selector-case</em> { "<strong>:</strong>" <em>selector-case</em> } ["<strong>::</strong>" <em>default-multi-expression</em>]<br>
 <em>selector-case</em> = [<em>match-list</em>] <em>case-value</em><br>
 <em>match-list</em> = "<strong>[</strong>" <em>item</em> {"<strong>,</strong>" <em>items</em>} "<strong>]</strong>"<br>
 <em>item</em> = <em>expression</em><br>
@@ -1931,11 +1966,45 @@ Technically <code class="blue">;</code> is not treated as a real operator. It ac
 <p><code>&gt;&gt;&gt;</code> <code class="blue">10 ? {"a"} : {"b"}</code><br>
 <code class="red">Eval Error: [1:3] no case catches the value (10) of the selection expression</code></p>
 </div>
+<div class="sect3">
+<h4 id="_triple_special_case_of_the_selector_operator"><a class="anchor" href="#_triple_special_case_of_the_selector_operator"></a><a class="link" href="#_triple_special_case_of_the_selector_operator">4.4.1. Triple special case of the selector operator</a></h4>
+<div class="paragraph">
+<p>If the <em>select-expression</em> is a boolean expression, the selector operator can be used as a sort of <em>if-then-else</em> statement. In this case, the first case is evaluated if the <em>select-expression</em> is true, and the second case is evaluated if the <em>select-expression</em> is false. In this special case, the <em>match-list</em> of both cases must be empty.</p>
+</div>
+<div class="paragraph">
+<div class="title">Example</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">(true) ? {"T"}: {"F"}</code><br>
+<code class="green">T</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">(2 &gt; 1) ? {"a"} : {"b"}</code><br>
+<code class="green">a</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">(2 &lt; 1) ? {"a"} : {"b"}</code><br>
+<code class="green">b</code></p>
+</div>
+<div class="admonitionblock warning">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-warning" title="Warning"></i>
+</td>
+<td class="content">
+<div class="paragraph">
+<p>The triple special case of the selector operator is very useful, but it only works with boolean expressions.</p>
+</div>
+<div class="paragraph">
+<div class="title">Example of confusion</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">int(true) ? {"T"}: {"F"}</code><br>
+<code class="green">F</code></p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+</div>
 </div>
 <div class="sect2">
 <h3 id="_variable_default_value_and"><a class="anchor" href="#_variable_default_value_and"></a><a class="link" href="#_variable_default_value_and">4.5. Variable default value <code class="blue">??</code>, <code class="blue">?=</code>, and <code class="blue">?!</code></a></h3>
 <div class="paragraph">
-<p>The left operand of the first two operators, <code class="blue">??</code> and <code class="blue">?=</code>, must be a variable. The right operator can be any expression. They return the value of the variable if this is defined; otherwise they return the value of the right expression.</p>
+<p>The left operand of the first two operators, <code class="blue">??</code> and <code class="blue">?=</code>, must be a variable. The right operatand can be any expression. They return the value of the variable if this is defined; otherwise they return the value of the right expression.</p>
 </div>
 <div class="admonitionblock important">
 <table>
@@ -1953,7 +2022,7 @@ If the left variable is defined, the right expression is not evaluated at all.
 <p>The <code class="blue">??</code> operator do not change the status of the left variable.</p>
 </div>
 <div class="paragraph">
-<p>The <code class="blue">?=</code> assigns the calculated value of the right expression to the left variable.</p>
+<p>The <code class="blue">?=</code> assigns the calculated value of the right expression to the variable on the left side.</p>
 </div>
 <div class="paragraph">
 <p>The third one, <code class="blue">?!</code>, is the alternate operator. If the variable on the left size is not defined, it returns <em class="blue">nil</em>. Otherwise it returns the result of the expressione on the right side.</p>
@@ -1965,7 +2034,7 @@ If the left variable is defined, the right expression is not evaluated at all.
 <i class="fa icon-important" title="Important"></i>
 </td>
 <td class="content">
-If the left variable is NOT defined, the right expression is not evaluated at all.
+If the variable <code class="blue">?!</code> is NOT defined, the expression is not evaluated at all.
 </td>
 </tr>
 </table>
@@ -2371,7 +2440,7 @@ These operators have a high priority, in particular higher than the operator <co
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>identifier</em> <code>=</code> <em>any</em> &#8594; <em>any</em></p></td>
 </tr>
 <tr>
-<td class="tableblock halign-center valign-top" colspan="4"><p class="tableblock"><em>See also the table of special allocation operators below</em></p></td>
+<td class="tableblock halign-center valign-top" colspan="4"><p class="tableblock"><em>See also the table of special assignment operators below</em></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><strong>BUT</strong></p></td>
@@ -2381,6 +2450,40 @@ These operators have a high priority, in particular higher than the operator <co
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>any</em> <code>but</code> <em>any</em> &#8594; <em>any</em></p></td>
 </tr>
 <tr>
+<td class="tableblock halign-center valign-top" rowspan="6"><p class="tableblock"><strong>ITER-OP</strong></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">digest</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Item-digesting</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>iterable</em> <code>digest</code> <em>expr</em> &#8594; <em>any</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">filter</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Item-filtering</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>iterable</em> <code>filter</code> <em>expr</em> &#8594; <em>list</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">groupby</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Dict-grouping</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>iterable</em> <code>groupby</code> <em>key-expr</em> &#8594; <em>dict</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">cat</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Item-concatenation</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>iterable</em> `cat ` <em>iterable</em> &#8594; <em>list</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">map</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Item-mapping</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>iterable</em> <code>map</code> <em>-expr</em> &#8594; <em>list</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top" colspan="4"><p class="tableblock"><em>See iterators section for examples</em></p></td>
+</tr>
+<tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><strong>RANGE</strong></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">:</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
@@ -2536,14 +2639,14 @@ short for<br>
 </div>
 <div class="paragraph">
 <p><code>&gt;&gt;&gt;</code> <em class="gray">// Required and optional parameters</em><br>
-<code>&gt;&gt;&gt;</code> <code class="blue">measure = func(value, unit="meter"){ value + " " + unit + (value &gt; 1) ? [true] {"s"} :: {""}}</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">measure = func(value, unit="meter"){ value + " " + unit + (value &gt; 1) ? {"s"} :: {""}}</code><br>
 <code class="green">measure(value, unit="meter"):any{}</code></p>
 </div>
 </div>
 <div class="sect2">
 <h3 id="_golang_function_definition"><a class="anchor" href="#_golang_function_definition"></a><a class="link" href="#_golang_function_definition">6.2. <em>Golang</em> function definition</a></h3>
 <div class="paragraph">
-<p>Description of how to define Golang functions and how to bind them to <em>Expr</em> are topics covered in another document that I&#8217;ll write, one day, maybe.</p>
+<p>Description of how to define Golang functions and how to bind them to <em>Expr</em> are topics covered in another documents that I&#8217;ll write, one day, maybe.</p>
 </div>
 </div>
 <div class="sect2">
@@ -2642,7 +2745,7 @@ short for<br>
 <div class="title">Example</div>
 <p><code>&gt;&gt;&gt;</code> <code class="blue">f = func() { @x = 3; x = 5 }</code> <em class="gray">// f() declares two <strong>different</strong> local variables: <code>@x</code> and <code>x</code></em><br>
 <code class="green">f():any{}</code><br>
-<code>&gt;&gt;&gt;</code> <code class="blue">f()</code> <em class="gray">// The multi-expression (two) in f() is calculated and the last result is returned</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">f()</code> <em class="gray">// The multi-expression (two expressions) in f() is calculated and the last result is returned</em><br>
 <code class="green">5</code><br>
 <code>&gt;&gt;&gt;</code> <code class="blue">x</code> <em class="gray">// The <code>x</code> variable was not defined in the main context before the f() invocation. It appears in the main context by cloning the <code>@x</code> variable, local to f() after its termnation.</em><br>
 <code class="green">3</code></p>
@@ -2727,7 +2830,7 @@ The clone modifier <code class="blue">@</code> does not make a variable a refere
 <div class="title">Example 16. Builtin activation syntax</div>
 <div class="content">
 <div class="paragraph">
-<p><strong><em>builtin-activation</em></strong> = <code class="blue">BUILTIN</code> (<em>builtin-name</em> | <em>list-of-builtin-names</em>)<br>
+<p><strong><em>builtin-activation</em></strong> = <code class="blue">BUILTIN</code> (<em>builtin-name</em> | <em>list-of-builtin-names</em> | <strong>"*"</strong>)<br>
 <em>builtin-name</em> = <em>string</em><br>
 <em>list-of-builtin-names</em> = <strong>[</strong> <em>string</em> { "<strong>,</strong>" <em>string</em> } <strong>]</strong></p>
 </div>
@@ -2815,9 +2918,15 @@ To avoid the need to activate builtin modules one by one, it is possible to acti
 <div class="title">Other functions</div>
 <ul>
 <li>
+<p><a href="#_char">char()</a></p>
+</li>
+<li>
 <p><a href="#_eval">eval()</a></p>
 </li>
 <li>
+<p><a href="#_set">set()</a></p>
+</li>
+<li>
 <p><a href="#_var">var()</a></p>
 </li>
 </ul>
@@ -2833,7 +2942,9 @@ Returns <em>true</em> if the value type of <em>&lt;expr&gt;</em> is boolean, fal
 <p><code>&gt;&gt;&gt;</code> <code class="blue">isBool(true)</code><br>
 <code class="green">true</code><br>
 <code>&gt;&gt;&gt;</code> <code class="blue">isBool(3==2)</code><br>
-<code class="green">true</code></p>
+<code class="green">true</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">isBool(3 + 2)</code><br>
+<code class="green">false</code></p>
 </div>
 </div>
 <div class="sect4">
@@ -2938,7 +3049,7 @@ Returns <em>true</em> if the value type of <em>&lt;expr&gt;</em> is fraction or
 <h5 id="_isstring"><a class="anchor" href="#_isstring"></a><a class="link" href="#_isstring">isString()</a></h5>
 <div class="paragraph">
 <p>Syntax: <code>isString(&lt;expr&gt;) &#8594; bool</code><br>
-Returns a boolean value , false otherwise.</p>
+Returns <em>true</em> if the value type of <em>&lt;expr&gt;</em> is string, false otherwise.</p>
 </div>
 <div class="paragraph">
 <div class="title">Examples</div>
@@ -2954,7 +3065,7 @@ Returns a boolean value , false otherwise.</p>
 <h5 id="_bool"><a class="anchor" href="#_bool"></a><a class="link" href="#_bool">bool()</a></h5>
 <div class="paragraph">
 <p>Syntax: <code>bool(&lt;expr&gt;) &#8594; bool</code><br>
-Returns a <em>boolean</em> value consisent to the value of the expression.</p>
+Returns a <em>boolean</em> value consisent with the value of the expression.</p>
 </div>
 <div class="paragraph">
 <div class="title">Examples</div>
@@ -3077,6 +3188,20 @@ Returns a <em>fraction</em> value consistent with the value of the expression.</
 </div>
 </div>
 <div class="sect4">
+<h5 id="_char"><a class="anchor" href="#_char"></a><a class="link" href="#_char">char()</a></h5>
+<div class="paragraph">
+<p>Syntax: <code>char(&lt;intexpr&gt;) &#8594; string</code><br>
+Returns the character whose ASCII (soon Unicode too) code point is specified by the integer expression.</p>
+</div>
+<div class="paragraph">
+<div class="title">Examples</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">char(65)</code><br>
+<code class="green">"A"</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">char(97)</code><br>
+<code class="green">"a"</code></p>
+</div>
+</div>
+<div class="sect4">
 <h5 id="_eval"><a class="anchor" href="#_eval"></a><a class="link" href="#_eval">eval()</a></h5>
 <div class="paragraph">
 <p>Syntax: <code>eval(&lt;string-expr&gt;) &#8594; any</code><br>
@@ -3096,13 +3221,13 @@ Computes and returns the value of the <span class="underline">string</span> expr
  <code>&#160;&#160;&#160;&#160;var(&lt;string-expr&gt;) &#8594; any</code></p>
 </div>
 <div class="paragraph">
-<p>This function allows you to define variables whose names must include special characters. The first form of the function allows you to define a variable with a name specified by the first parameter and assign it the value of the second parameter. The second form only returns the value of the variable with the specified name.</p>
+<p>This function allows you to define variables whose names can include special characters. The first form of the function allows you to define a variable with a name specified by the first parameter and assign it the value of the second parameter. The second form only returns the value of the variable with the specified name.</p>
 </div>
 <div class="paragraph">
 <div class="title">Examples</div>
 <p><code>&gt;&gt;&gt;</code> <code class="blue">var("$x", 3+9)</code><br>
 <code class="green">12</code><br>
-<code>&gt;&gt;&gt;</code> <code class="blue">var("$x")</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">var("$"+"x")</code><br>
 <code class="green">12</code><br>
 <code>&gt;&gt;&gt;</code> <code class="blue">var("gain%", var("$x"))</code><br>
 <code class="green">12</code><br>
@@ -3110,9 +3235,32 @@ Computes and returns the value of the <span class="underline">string</span> expr
 <code class="green">13</code></p>
 </div>
 </div>
+<div class="sect4">
+<h5 id="_set"><a class="anchor" href="#_set"></a><a class="link" href="#_set">set</a></h5>
+<div class="paragraph">
+<p>Syntax:<br>
+ <code>&#160;&#160;&#160;&#160;set(&lt;string-expr&gt;, &lt;expr&gt;) &#8594; any</code></p>
+</div>
+<div class="paragraph">
+<p>This function allows you to set the value of a variable whose name can include special characters. The first parameter is the name of the variable and the second parameter is the new value to assign to that variable.</p>
+</div>
+<div class="paragraph">
+<p>It is equivalent to the first form of the var() function, but it is more explicit about the intent of changing the value of an existing variable.</p>
+</div>
+<div class="paragraph">
+<div class="title">Examples</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">set("$x", 100)</code><br>
+<code class="green">100</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">var("$x")</code><br>
+<code class="green">100</code><br></p>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_module_fmt"><a class="anchor" href="#_module_fmt"></a><a class="link" href="#_module_fmt">7.1.2. Module "fmt"</a></h4>
+<div class="paragraph">
+<p><mark>to-do</mark></p>
+</div>
 <div class="sect4">
 <h5 id="_print"><a class="anchor" href="#_print"></a><a class="link" href="#_print">print()</a></h5>
 
@@ -3124,10 +3272,18 @@ Computes and returns the value of the <span class="underline">string</span> expr
 </div>
 <div class="sect3">
 <h4 id="_module_import"><a class="anchor" href="#_module_import"></a><a class="link" href="#_module_import">7.1.3. Module "import"</a></h4>
+<div class="paragraph">
+<p>Module activation:<br>
+<code>&#160;&#160;&#160;&#160;BUILTIN "import"</code></p>
+</div>
 <div class="sect4">
 <h5 id="_import"><a class="anchor" href="#_import"></a><a class="link" href="#_import"><em>import()</em></a></h5>
 <div class="paragraph">
-<p><em class="blue">import(<span class="grey">&lt;source-file&gt;</span>)</em>&#8201;&#8212;&#8201;loads the multi-expression contained in the specified source and returns its value.</p>
+<p>Syntax:<br>
+<code>&#160;&#160;&#160;&#160;import(&lt;source-file&gt;)</code></p>
+</div>
+<div class="paragraph">
+<p>Loads the multi-expression contained in the specified source and returns its value.</p>
 </div>
 </div>
 <div class="sect4">
@@ -3137,16 +3293,40 @@ Computes and returns the value of the <span class="underline">string</span> expr
 </div>
 <div class="sect3">
 <h4 id="_module_iterator"><a class="anchor" href="#_module_iterator"></a><a class="link" href="#_module_iterator">7.1.4. Module "iterator"</a></h4>
+<div class="paragraph">
+<p>Module activation:<br>
+<code>&#160;&#160;&#160;&#160;BUILTIN "iterator"</code></p>
+</div>
 <div class="sect4">
 <h5 id="_run"><a class="anchor" href="#_run"></a><a class="link" href="#_run">run()</a></h5>
-
+<div class="paragraph">
+<p>Syntax:<br>
+<code>&#160;&#160;&#160;&#160;run(&lt;iterator&gt;, &lt;operator&gt;, &lt;vars&gt;) &#8594; any</code></p>
+</div>
+<div class="paragraph">
+<p>Iterates over the specified iterator and applies the specified operator to the current value of the iterator.</p>
+</div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_module_math_arith"><a class="anchor" href="#_module_math_arith"></a><a class="link" href="#_module_math_arith">7.1.5. Module "math.arith"</a></h4>
 <div class="paragraph">
+<p>Module activation:<br>
+<code>&#160;&#160;&#160;&#160;BUILTIN "math.arith"</code></p>
+</div>
+<div class="paragraph">
 <p>Currently, the "math.arith" module provides two functions, add() and mul(), that perform addition and multiplication of an arbitrary number of parameters. More functions will be added in the future.</p>
 </div>
+<div class="ulist">
+<ul>
+<li>
+<p><a href="#_add">add()</a></p>
+</li>
+<li>
+<p><a href="#_mul">mul()</a></p>
+</li>
+</ul>
+</div>
 <div class="sect4">
 <h5 id="_add"><a class="anchor" href="#_add"></a><a class="link" href="#_add">add()</a></h5>
 <div class="paragraph">
@@ -3202,37 +3382,213 @@ Computes and returns the value of the <span class="underline">string</span> expr
 </div>
 <div class="sect3">
 <h4 id="_module_os_file"><a class="anchor" href="#_module_os_file"></a><a class="link" href="#_module_os_file">7.1.6. Module "os.file"</a></h4>
+<div class="paragraph">
+<p>Module activation:<br>
+<code>&#160;&#160;&#160;&#160;BUILTIN "os.file"</code></p>
+</div>
+<div class="paragraph">
+<p>The "os.file" module provides functions for working with files.</p>
+</div>
+<div class="ulist">
+<div class="title">File related functions</div>
+<ul>
+<li>
+<p><a href="#_fileOpen">fileOpen()</a></p>
+</li>
+<li>
+<p><a href="#_fileAppend">fileAppend()</a></p>
+</li>
+<li>
+<p><a href="#_fileCreate">fileCreate()</a></p>
+</li>
+<li>
+<p><a href="#_fileClose">fileClose()</a></p>
+</li>
+<li>
+<p><a href="#_fileWriteText">fileWriteText()</a></p>
+</li>
+<li>
+<p><a href="#_fileReadText">fileReadText()</a></p>
+</li>
+<li>
+<p><a href="#_fileReadTextAll">fileReadTextAll()</a></p>
+</li>
+</ul>
+</div>
+<div class="ulist">
+<div class="title">Iterator functions for files</div>
+<ul>
+<li>
+<p><a href="#_fileByteIterator">fileByteIterator()</a></p>
+</li>
+<li>
+<p><a href="#_fileLineIterator">fileLineIterator()</a></p>
+</li>
+</ul>
+</div>
+<div class="paragraph">
+<p>More functions will be added in the future.</p>
+</div>
+<hr>
 <div class="sect4">
 <h5 id="_fileopen"><a class="anchor" href="#_fileopen"></a><a class="link" href="#_fileopen">fileOpen()</a></h5>
-
+<div class="paragraph">
+<p>Syntax:<br>
+<code>&#160;&#160;&#160;&#160;fileOpen(&lt;file-path&gt;) &#8594; file-handle</code></p>
+</div>
+<div class="paragraph">
+<p>Returns a file handle for the specified file path. The file is opened in read-write mode. If the file does not exist, it is created.</p>
+</div>
 </div>
 <div class="sect4">
 <h5 id="_fileappend"><a class="anchor" href="#_fileappend"></a><a class="link" href="#_fileappend">fileAppend()</a></h5>
-
+<div class="paragraph">
+<p>Syntax:<br>
+<code>&#160;&#160;&#160;&#160;fileAppend(&lt;file-path&gt;) &#8594; any</code></p>
+</div>
+<div class="paragraph">
+<p>Like <a href="#_fileCreate">fileCreate()</a> but write operations happen at the end of the file.</p>
+</div>
 </div>
 <div class="sect4">
 <h5 id="_filecreate"><a class="anchor" href="#_filecreate"></a><a class="link" href="#_filecreate">fileCreate()</a></h5>
-
+<div class="paragraph">
+<p>Syntax:<br>
+<code>&#160;&#160;&#160;&#160;fileCreate(&lt;file-path&gt;) &#8594; file-handle</code></p>
+</div>
+<div class="paragraph">
+<p>Creates or truncates the named <em>&lt;file-path&gt;</em>. If the file already exists, it is truncated. If the file does not exist, it is created with mode 0o666 (before umask). The associated file descriptor has mode [O_RDWR]. The directory containing the file must already exist.</p>
+</div>
 </div>
 <div class="sect4">
 <h5 id="_fileclose"><a class="anchor" href="#_fileclose"></a><a class="link" href="#_fileclose">fileClose()</a></h5>
-
+<div class="paragraph">
+<p><mark>to-do</mark></p>
+</div>
 </div>
 <div class="sect4">
 <h5 id="_filewritetext"><a class="anchor" href="#_filewritetext"></a><a class="link" href="#_filewritetext">fileWriteText()</a></h5>
-
+<div class="paragraph">
+<p><mark>to-do</mark></p>
+</div>
 </div>
 <div class="sect4">
 <h5 id="_filereadtext"><a class="anchor" href="#_filereadtext"></a><a class="link" href="#_filereadtext">fileReadText()</a></h5>
-
+<div class="paragraph">
+<p><mark>to-do</mark></p>
+</div>
 </div>
 <div class="sect4">
 <h5 id="_filereadtextall"><a class="anchor" href="#_filereadtextall"></a><a class="link" href="#_filereadtextall">fileReadTextAll()</a></h5>
-
+<div class="paragraph">
+<p><mark>to-do</mark></p>
+</div>
+</div>
+<div class="sect4">
+<h5 id="_filebyteiterator"><a class="anchor" href="#_filebyteiterator"></a><a class="link" href="#_filebyteiterator">fileByteIterator()</a></h5>
+<div class="paragraph">
+<p>Syntax:<br>
+<code>&#160;&#160;&#160;&#160;fileByteIterator(handle-or-path) &#8594; iterator</code></p>
+</div>
+<div class="paragraph">
+<p>Returns an iterator that produces the bytes of the specified file. The parameter can be either a file handle or a file path. If a file path is provided, the file is opened and closed automatically by the iterator.</p>
+</div>
+<div class="paragraph">
+<div class="title">Examples</div>
+<p>&gt;&gt;&gt; builtin "os.file"<br>
+<code class="green">1</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">fileByteIterator("test-file.txt") map $_</code><br>
+<code class="green">[
+  117,
+  110,
+  111,
+  10,
+  100,
+  117,
+  101,
+  10
+]</code></p>
+</div>
+<div class="paragraph">
+<p>&gt;&gt;&gt; builtin ["os.file", "string"]<br>
+<code class="green">2</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">fileByteIterator("test-file.txt") map char($_)</code><br>
+<code class="green">[
+  "u",
+  "n",
+  "o",
+  "
+",
+  "d",
+  "u",
+  "e",
+  "
+",
+]</code></p>
+</div>
+</div>
+<div class="sect4">
+<h5 id="_filelineiterator"><a class="anchor" href="#_filelineiterator"></a><a class="link" href="#_filelineiterator">fileLineIterator()</a></h5>
+<div class="paragraph">
+<p>Syntax:<br>
+<code>&#160;&#160;&#160;&#160;fileLineIterator(handle-or-path) &#8594; iterator</code></p>
+</div>
+<div class="paragraph">
+<p>Returns an iterator that produces the lines of the specified file. The parameter can be either a file handle or a file path. If a file path is provided, the file is opened and closed automatically by the iterator.</p>
+</div>
+<div class="paragraph">
+<div class="title">Examples</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">builtin "os.file"</code><br>
+<code class="green">1</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">fileLineIterator("test-file.txt") map $_</code><br>
+<code class="green">[
+  "uno",
+  "due"
+]</code></p>
+</div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_module_string"><a class="anchor" href="#_module_string"></a><a class="link" href="#_module_string">7.1.7. Module "string"</a></h4>
+<div class="paragraph">
+<p>Module activation:<br>
+<code>&#160;&#160;&#160;&#160;BUILTIN "string"</code></p>
+</div>
+<div class="paragraph">
+<p>This module provides functions for working with strings.</p>
+</div>
+<div class="paragraph">
+<p>Currently available functions:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p><a href="#_strJoin">strJoin()</a></p>
+</li>
+<li>
+<p><a href="#_strSub">strSub()</a></p>
+</li>
+<li>
+<p><a href="#_strSplit">strSplit()</a></p>
+</li>
+<li>
+<p><a href="#_strTrim">strTrim()</a></p>
+</li>
+<li>
+<p><a href="#_strStartsWith">strStartsWith()</a></p>
+</li>
+<li>
+<p><a href="#_strEndsWith">strEndsWith()</a></p>
+</li>
+<li>
+<p><a href="#_strUpper">strUpper()</a></p>
+</li>
+<li>
+<p><a href="#_strLower">strLower()</a></p>
+</li>
+</ul>
+</div>
+<hr>
 <div class="sect4">
 <h5 id="_strjoin"><a class="anchor" href="#_strjoin"></a><a class="link" href="#_strjoin">strJoin()</a></h5>
 <div class="paragraph">
@@ -3589,7 +3945,81 @@ Iterators built on custom data-sources can provide additional named operators, d
 </div>
 </div>
 <div class="sect2">
-<h3 id="_iterator_over_custom_data_sources"><a class="anchor" href="#_iterator_over_custom_data_sources"></a><a class="link" href="#_iterator_over_custom_data_sources">8.2. Iterator over custom data-sources</a></h3>
+<h3 id="_infixed_operators_on_iterators"><a class="anchor" href="#_infixed_operators_on_iterators"></a><a class="link" href="#_infixed_operators_on_iterators">8.2. Infixed operators on iterators</a></h3>
+<div class="paragraph">
+<p>There are also some infixed operators that can be used with iterators. They are defined as follows.</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p><a href="#_cat">cat operator</a></p>
+</li>
+<li>
+<p><a href="#_diget">digest operator</a></p>
+</li>
+<li>
+<p><a href="#_filter">filter operator</a></p>
+</li>
+<li>
+<p><a href="#_groupby">groupby operator</a></p>
+</li>
+<li>
+<p><a href="#_map">map operator</a></p>
+</li>
+</ul>
+</div>
+<hr>
+<div class="sect3">
+<h4 id="_cat_operator"><a class="anchor" href="#_cat_operator"></a><a class="link" href="#_cat_operator">8.2.1. <code class="blue">cat</code> operator</a></h4>
+<div class="paragraph">
+<p>Syntax:<br>
+<code>&#160;&#160;&#160;&#160;&lt;iterable&gt; cat &lt;iterable&gt; &#8594; &lt;iterator&gt;&#160;&#160;&#160;&#160;</code></p>
+</div>
+<div class="paragraph">
+<p><code class="blue">cat</code> operator takes two iterators or iterables and returns a new iterator that produces the elements of the first iterator followed by the elements of the second iterator.</p>
+</div>
+</div>
+<div class="sect3">
+<h4 id="_filter_operator"><a class="anchor" href="#_filter_operator"></a><a class="link" href="#_filter_operator">8.2.2. <code class="blue">filter</code> operator</a></h4>
+<div class="paragraph">
+<div class="title">Examples</div>
+<p>Syntax:<br>
+<code>&#160;&#160;&#160;&#160;&lt;iterable&gt; filter &lt;expr&gt; &#8594; &lt;iterator&gt;&#160;&#160;&#160;&#160;</code></p>
+</div>
+<div class="paragraph">
+<p><code class="blue">filter</code> applies a boolean expression to each element of the iterator and returns a list of the elements for which the expression evaluates to true.</p>
+</div>
+</div>
+<div class="sect3">
+<h4 id="_groupby_operator"><a class="anchor" href="#_groupby_operator"></a><a class="link" href="#_groupby_operator">8.2.3. <code class="blue">groupby</code> operator</a></h4>
+<div class="paragraph">
+<p>Syntax:<br>
+<code>&#160;&#160;&#160;&#160;&lt;dict&gt; groupby &lt;key&gt; &#8594; &lt;dict&gt;&#160;&#160;&#160;&#160;</code></p>
+</div>
+<div class="paragraph">
+<p><code class="blue">groupby</code> operator groups the elements of the iterator based on the value of a specified expression and returns a dictionary where the keys are the group values and the values are lists of the elements in each group.</p>
+</div>
+</div>
+<div class="sect3">
+<h4 id="_map_operator"><a class="anchor" href="#_map_operator"></a><a class="link" href="#_map_operator">8.2.4. <code class="blue">map</code> operator</a></h4>
+<div class="paragraph">
+<p>Syntax:<br>
+<code>&#160;&#160;&#160;&#160;&lt;iterable&gt; map &lt;expr&gt; &#8594; &lt;list&gt;&#160;&#160;&#160;&#160;</code></p>
+</div>
+<div class="paragraph">
+<p><code class="blue">map</code> operator iterates over the elements of the iterator and evaluates the expressions provided on the right side for each element. Its result is a list of the computed values of the that expression. The current element of the iterator is available in the expression as the variable <code>$_</code>.</p>
+</div>
+<div class="paragraph">
+<div class="title">Example: using the <code class="blue">map</code> operator</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">it = $(["one", "two", "three"])</code><br>
+<code class="green">$(#3)</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">it map $_ + "!"</code><br>
+<code class="green">["one!", "two!", "three!"]</code></p>
+</div>
+</div>
+</div>
+<div class="sect2">
+<h3 id="_iterator_over_custom_data_sources"><a class="anchor" href="#_iterator_over_custom_data_sources"></a><a class="link" href="#_iterator_over_custom_data_sources">8.3. Iterator over custom data-sources</a></h3>
 <div class="paragraph">
 <p>It is possible to create iterators over custom data-sources by defining a dictionary that has the key <code>next</code> whose value is a function that returns the next element of the collection and updates the state of the iterator. The syntax for creating an iterator over a custom data-source is as follows.</p>
 </div>
@@ -3610,7 +4040,7 @@ Iterators built on custom data-sources can provide additional named operators, d
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2026-04-21 06:35:14 +0200
+Last updated 2026-05-12 16:25:27 +0200
 </div>
 </div>
 </body>

file/coverage.html

@@ -0,0 +1,322 @@
+
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+		<title>file: Go Coverage Report</title>
+		<style>
+			body {
+				background: black;
+				color: rgb(80, 80, 80);
+			}
+			body, pre, #legend span {
+				font-family: Menlo, monospace;
+				font-weight: bold;
+			}
+			#topbar {
+				background: black;
+				position: fixed;
+				top: 0; left: 0; right: 0;
+				height: 42px;
+				border-bottom: 1px solid rgb(80, 80, 80);
+			}
+			#content {
+				margin-top: 50px;
+			}
+			#nav, #legend {
+				float: left;
+				margin-left: 10px;
+			}
+			#legend {
+				margin-top: 12px;
+			}
+			#nav {
+				margin-top: 10px;
+			}
+			#legend span {
+				margin: 0 5px;
+			}
+			.cov0 { color: rgb(192, 0, 0) }
+.cov1 { color: rgb(128, 128, 128) }
+.cov2 { color: rgb(116, 140, 131) }
+.cov3 { color: rgb(104, 152, 134) }
+.cov4 { color: rgb(92, 164, 137) }
+.cov5 { color: rgb(80, 176, 140) }
+.cov6 { color: rgb(68, 188, 143) }
+.cov7 { color: rgb(56, 200, 146) }
+.cov8 { color: rgb(44, 212, 149) }
+.cov9 { color: rgb(32, 224, 152) }
+.cov10 { color: rgb(20, 236, 155) }
+
+		</style>
+	</head>
+	<body>
+		<div id="topbar">
+			<div id="nav">
+				<select id="files">
+				
+				<option value="file0">git.portale-stac.it/go-pkg/expr/file/file.go (88.9%)</option>
+				
+				<option value="file1">git.portale-stac.it/go-pkg/expr/file/reader.go (77.8%)</option>
+				
+				<option value="file2">git.portale-stac.it/go-pkg/expr/file/writer.go (100.0%)</option>
+				
+				</select>
+			</div>
+			<div id="legend">
+				<span>not tracked</span>
+			
+				<span class="cov0">not covered</span>
+				<span class="cov8">covered</span>
+			
+			</div>
+		</div>
+		<div id="content">
+		
+		<pre class="file" id="file0" style="display: none">// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// file.go
+package file
+
+import (
+        "os"
+
+        "git.portale-stac.it/go-pkg/expr/kern"
+)
+
+type Handle interface {
+        kern.Typer
+        GetFile() *os.File
+        GetName() string
+        Valid() bool
+        Close() error
+}
+
+type handleBase struct {
+        fh *os.File
+}
+
+func (h *handleBase) GetFile() *os.File <span class="cov0" title="0">{
+        return h.fh
+}</span>
+
+func (h *handleBase) GetName() (name string) <span class="cov8" title="1">{
+        if h.fh != nil </span><span class="cov8" title="1">{
+                name = h.fh.Name()
+        }</span>
+        <span class="cov8" title="1">return</span>
+}
+
+func (h *handleBase) Valid() bool <span class="cov8" title="1">{
+        return h.fh != nil
+}</span>
+
+func (h *handleBase) Close() (err error) <span class="cov8" title="1">{
+        if h.fh != nil </span><span class="cov8" title="1">{
+                err = h.fh.Close()
+                h.fh = nil
+        }</span>
+        <span class="cov8" title="1">return</span>
+}
+</pre>
+		
+		<pre class="file" id="file1" style="display: none">// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// reader.go
+package file
+
+import (
+        "bufio"
+        "io"
+        "os"
+)
+
+type Reader struct {
+        // fh     *os.File
+        handleBase
+        reader *bufio.Reader
+}
+
+func NewReader(fh *os.File) *Reader <span class="cov8" title="1">{
+        return &amp;Reader{handleBase: handleBase{fh: fh}, reader: bufio.NewReader(fh)}
+}</span>
+
+func OpenReader(filePath string) (r *Reader, err error) <span class="cov8" title="1">{
+        var fh *os.File
+        if fh, err = os.Open(filePath); err == nil </span><span class="cov8" title="1">{
+                r = NewReader(fh)
+        }</span>
+        <span class="cov8" title="1">return</span>
+}
+
+func (h *Reader) TypeName() string <span class="cov8" title="1">{
+        return "fileReader"
+}</span>
+
+func (h *Reader) String() string <span class="cov8" title="1">{
+        return "reader"
+}</span>
+
+func (h *Reader) Valid() bool <span class="cov8" title="1">{
+        return h.handleBase.Valid() &amp;&amp; h.reader != nil
+}</span>
+
+func (w *Reader) Close() (err error) <span class="cov8" title="1">{
+        w.reader = nil
+        err = w.handleBase.Close()
+        return
+}</span>
+
+func (h *Reader) ReadByte() (b byte, err error) <span class="cov8" title="1">{
+        if h.reader != nil </span><span class="cov8" title="1">{
+                b, err = h.reader.ReadByte()
+        }</span> else<span class="cov0" title="0"> {
+                err = io.ErrClosedPipe
+        }</span>
+        <span class="cov8" title="1">return</span>
+}
+
+func (h *Reader) ReadAll() (p []byte, err error) <span class="cov8" title="1">{
+        if h.reader != nil </span><span class="cov8" title="1">{
+                p, err = io.ReadAll(h.reader)
+        }</span> else<span class="cov0" title="0"> {
+                err = io.ErrClosedPipe
+        }</span>
+        <span class="cov8" title="1">return</span>
+}
+
+func (h *Reader) ReadString(delim byte) (s string, err error) <span class="cov0" title="0">{
+        if h.reader != nil </span><span class="cov0" title="0">{
+                s, err = h.reader.ReadString(delim)
+        }</span> else<span class="cov0" title="0"> {
+                err = io.ErrClosedPipe
+        }</span>
+        <span class="cov0" title="0">return</span>
+}
+
+func (h *Reader) Reset() (err error) <span class="cov8" title="1">{
+        if h.fh != nil </span><span class="cov8" title="1">{
+                if _, err = h.fh.Seek(0, 0); err == nil </span><span class="cov8" title="1">{
+                        h.reader.Reset(h.fh)
+                }</span>
+        }
+        <span class="cov8" title="1">return</span>
+}
+</pre>
+		
+		<pre class="file" id="file2" style="display: none">// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// writer.go
+package file
+
+import (
+        "bufio"
+        "fmt"
+        "os"
+)
+
+type Writer struct {
+        // fh     *os.File
+        handleBase
+        writer *bufio.Writer
+}
+
+func NewWriter(fh *os.File) *Writer <span class="cov8" title="1">{
+        return &amp;Writer{handleBase: handleBase{fh: fh}, writer: bufio.NewWriter(fh)}
+}</span>
+
+func CreateWriter(filePath string) (w *Writer, err error) <span class="cov8" title="1">{
+        var fh *os.File
+        if fh, err = os.Create(filePath); err == nil </span><span class="cov8" title="1">{
+                w = NewWriter(fh)
+        }</span>
+        <span class="cov8" title="1">return</span>
+}
+
+func AppendWriter(filePath string) (w *Writer, err error) <span class="cov8" title="1">{
+        var fh *os.File
+        if fh, err = os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY, 0644); err == nil </span><span class="cov8" title="1">{
+                w = NewWriter(fh)
+        }</span>
+        <span class="cov8" title="1">return</span>
+}
+
+func (w *Writer) TypeName() string <span class="cov8" title="1">{
+        return "fileWriter"
+}</span>
+
+func (w *Writer) String() string <span class="cov8" title="1">{
+        return "writer"
+}</span>
+
+func (w *Writer) Valid() bool <span class="cov8" title="1">{
+        return w.handleBase.Valid() &amp;&amp; w.writer != nil
+}</span>
+
+func (w *Writer) Close() (err error) <span class="cov8" title="1">{
+        var err1 error
+        if w.writer != nil </span><span class="cov8" title="1">{
+                err1 = w.Flush()
+                w.writer = nil
+        }</span>
+        <span class="cov8" title="1">if err = w.handleBase.Close(); err == nil </span><span class="cov8" title="1">{
+                err = err1
+        }</span>
+        <span class="cov8" title="1">return</span>
+}
+
+func (w *Writer) Flush() (err error) <span class="cov8" title="1">{
+        if w.writer != nil </span><span class="cov8" title="1">{
+                err = w.writer.Flush()
+        }</span>
+        <span class="cov8" title="1">return</span>
+}
+
+func (w *Writer) Write(args ...any) (n int, err error) <span class="cov8" title="1">{
+        if w.writer != nil </span><span class="cov8" title="1">{
+                n, err = fmt.Fprint(w.writer, args...)
+        }</span>
+        <span class="cov8" title="1">return</span>
+}
+
+func (w *Writer) Writef(format string, args ...any) (n int, err error) <span class="cov8" title="1">{
+        if w.writer != nil </span><span class="cov8" title="1">{
+                n, err = fmt.Fprintf(w.writer, format, args...)
+        }</span>
+        <span class="cov8" title="1">return</span>
+}
+</pre>
+		
+		</div>
+	</body>
+	<script>
+	(function() {
+		var files = document.getElementById('files');
+		var visible;
+		files.addEventListener('change', onChange, false);
+		function select(part) {
+			if (visible)
+				visible.style.display = 'none';
+			visible = document.getElementById(part);
+			if (!visible)
+				return;
+			files.value = part;
+			visible.style.display = 'block';
+			location.hash = part;
+		}
+		function onChange() {
+			select(files.value);
+			window.scrollTo(0, 0);
+		}
+		if (location.hash != "") {
+			select(location.hash.substr(1));
+		}
+		if (!visible) {
+			select("file0");
+		}
+	})();
+	</script>
+</html>

file/file.go

@@ -0,0 +1,46 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// file.go
+package file
+
+import (
+	"os"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
+type Handle interface {
+	kern.Typer
+	GetFile() *os.File
+	GetName() string
+	Valid() bool
+	Close() error
+}
+
+type handleBase struct {
+	fh *os.File
+}
+
+func (h *handleBase) GetFile() *os.File {
+	return h.fh
+}
+
+func (h *handleBase) GetName() (name string) {
+	if h.fh != nil {
+		name = h.fh.Name()
+	}
+	return
+}
+
+func (h *handleBase) Valid() bool {
+	return h.fh != nil
+}
+
+func (h *handleBase) Close() (err error) {
+	if h.fh != nil {
+		err = h.fh.Close()
+		h.fh = nil
+	}
+	return
+}

file/reader.go

@@ -0,0 +1,83 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// reader.go
+package file
+
+import (
+	"bufio"
+	"io"
+	"os"
+)
+
+type Reader struct {
+	// fh     *os.File
+	handleBase
+	reader *bufio.Reader
+}
+
+func NewReader(fh *os.File) *Reader {
+	return &Reader{handleBase: handleBase{fh: fh}, reader: bufio.NewReader(fh)}
+}
+
+func OpenReader(filePath string) (r *Reader, err error) {
+	var fh *os.File
+	if fh, err = os.Open(filePath); err == nil {
+		r = NewReader(fh)
+	}
+	return
+}
+
+func (h *Reader) TypeName() string {
+	return "fileReader"
+}
+
+func (h *Reader) String() string {
+	return "reader"
+}
+
+func (h *Reader) Valid() bool {
+	return h.handleBase.Valid() && h.reader != nil
+}
+
+func (w *Reader) Close() (err error) {
+	w.reader = nil
+	err = w.handleBase.Close()
+	return
+}
+
+func (h *Reader) ReadByte() (b byte, err error) {
+	if h.reader != nil {
+		b, err = h.reader.ReadByte()
+	} else {
+		err = io.ErrClosedPipe
+	}
+	return
+}
+
+func (h *Reader) ReadAll() (p []byte, err error) {
+	if h.reader != nil {
+		p, err = io.ReadAll(h.reader)
+	} else {
+		err = io.ErrClosedPipe
+	}
+	return
+}
+
+func (h *Reader) ReadString(delim byte) (s string, err error) {
+	if h.reader != nil {
+		s, err = h.reader.ReadString(delim)
+	} else {
+		err = io.ErrClosedPipe
+	}
+	return
+}
+
+func (h *Reader) Reset() (err error) {
+	if h.fh != nil {
+		if _, err = h.fh.Seek(0, 0); err == nil {
+			h.reader.Reset(h.fh)
+		}
+	}
+	return
+}

file/t_reader_test.go

@@ -0,0 +1,62 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// reader.go
+package file
+
+import "testing"
+
+func TestOpenReader(t *testing.T) {
+	r, err := OpenReader("t_reader_test.go")
+	if err != nil {
+		t.Fatalf("OpenReader failed: %v", err)
+	}
+	defer r.Close()
+
+	if !r.Valid() {
+		t.Fatal("Reader should be valid after opening")
+	}
+
+	if r.TypeName() != "fileReader" {
+		t.Fatalf("Expected TypeName 'fileReader', got '%s'", r.TypeName())
+	}
+
+	if r.String() != "reader" {
+		t.Fatalf("Expected String 'reader', got '%s'", r.String())
+	}
+
+	// GetName may return either "t_reader_test.go" or "./t_reader_test.go" depending on the environment
+	name := r.GetName()
+	if (name != "t_reader_test.go") && (name != "./t_reader_test.go") {
+		t.Fatalf("Expected GetName 't_reader_test.go' or './t_reader_test.go', got '%s'", name)
+	}
+
+	// Test reading a byte
+	b, err := r.ReadByte()
+	if err != nil {
+		t.Fatalf("ReadByte failed: %v", err)
+	}
+	if b == 0 {
+		t.Fatal("ReadByte should not return zero byte")
+	}
+
+	err = r.Reset()
+	if err != nil {
+		t.Fatalf("Reset failed: %v", err)
+	}
+
+	if s, err := r.ReadString('\n'); err != nil {
+		t.Fatalf("ReadString failed: %v", err)
+	} else {
+		t.Logf("ReadString: %s", s)
+	}
+
+	// Test reading all content
+	content, err := r.ReadAll()
+	if err != nil {
+		t.Fatalf("ReadAll failed: %v", err)
+	}
+	if len(content) == 0 {
+		t.Fatal("ReadAll should return non-empty content")
+	}
+}

file/t_writer_test.go

@@ -0,0 +1,69 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// writer.go
+package file
+
+import "testing"
+
+func TestCreateWriter(t *testing.T) {
+	w, err := CreateWriter("/tmp/test_writer.txt")
+	if err != nil {
+		t.Fatalf("CreateWriter failed: %v", err)
+	}
+	defer w.Close()
+
+	if !w.Valid() {
+		t.Fatal("Writer should be valid after creation")
+	}
+
+	if w.TypeName() != "fileWriter" {
+		t.Fatalf("Expected TypeName 'fileWriter', got '%s'", w.TypeName())
+	}
+
+	if w.String() != "writer" {
+		t.Fatalf("Expected String 'writer', got '%s'", w.String())
+	}
+
+	name := w.GetName()
+	if name != "/tmp/test_writer.txt" {
+		t.Fatalf("Expected GetName '/tmp/test_writer.txt', got '%s'", name)
+	}
+
+	if n, err := w.Write("Hello, World!\n"); err != nil {
+		t.Fatalf("Write failed: %v", err)
+	} else if n != len("Hello, World!\n") {
+		t.Fatalf("Expected to write %d bytes, wrote %d", len("Hello, World!\n"), n)
+	}
+
+	if n, err := w.Writef("This is a %s.\n", "test"); err != nil {
+		t.Fatalf("Writef failed: %v", err)
+	} else if n != len("This is a test.\n") {
+		t.Fatalf("Expected to write %d bytes, wrote %d", len("This is a test.\n"), n)
+	}
+}
+
+func TestAppendWriter(t *testing.T) {
+	w, err := AppendWriter("/tmp/test_writer.txt")
+	if err != nil {
+		t.Fatalf("AppendWriter failed: %v", err)
+	}
+	defer w.Close()
+
+	if !w.Valid() {
+		t.Fatal("Writer should be valid after opening for append")
+	}
+
+	if w.TypeName() != "fileWriter" {
+		t.Fatalf("Expected TypeName 'fileWriter', got '%s'", w.TypeName())
+	}
+
+	if w.String() != "writer" {
+		t.Fatalf("Expected String 'writer', got '%s'", w.String())
+	}
+
+	name := w.GetName()
+	if name != "/tmp/test_writer.txt" {
+		t.Fatalf("Expected GetName '/tmp/test_writer.txt', got '%s'", name)
+	}
+}

file/writer.go

@@ -0,0 +1,82 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// writer.go
+package file
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+type Writer struct {
+	// fh     *os.File
+	handleBase
+	writer *bufio.Writer
+}
+
+func NewWriter(fh *os.File) *Writer {
+	return &Writer{handleBase: handleBase{fh: fh}, writer: bufio.NewWriter(fh)}
+}
+
+func CreateWriter(filePath string) (w *Writer, err error) {
+	var fh *os.File
+	if fh, err = os.Create(filePath); err == nil {
+		w = NewWriter(fh)
+	}
+	return
+}
+
+func AppendWriter(filePath string) (w *Writer, err error) {
+	var fh *os.File
+	if fh, err = os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY, 0644); err == nil {
+		w = NewWriter(fh)
+	}
+	return
+}
+
+func (w *Writer) TypeName() string {
+	return "fileWriter"
+}
+
+func (w *Writer) String() string {
+	return "writer"
+}
+
+func (w *Writer) Valid() bool {
+	return w.handleBase.Valid() && w.writer != nil
+}
+
+func (w *Writer) Close() (err error) {
+	var err1 error
+	if w.writer != nil {
+		err1 = w.Flush()
+		w.writer = nil
+	}
+	if err = w.handleBase.Close(); err == nil {
+		err = err1
+	}
+	return
+}
+
+func (w *Writer) Flush() (err error) {
+	if w.writer != nil {
+		err = w.writer.Flush()
+	}
+	return
+}
+
+func (w *Writer) Write(args ...any) (n int, err error) {
+	if w.writer != nil {
+		n, err = fmt.Fprint(w.writer, args...)
+	}
+	return
+}
+
+func (w *Writer) Writef(format string, args ...any) (n int, err error) {
+	if w.writer != nil {
+		n, err = fmt.Fprintf(w.writer, format, args...)
+	}
+	return
+}

global-context.go

@@ -42,12 +42,16 @@ func ImportInContextByGlobPattern(ctx kern.ExprContext, pattern string) (count i
 	return
 }
 
+func fixCtrlVar(name string) string {
+	if !strings.HasPrefix(name, "_") {
+		name = "_" + name
+	}
+	return name
+}
+
 func GlobalCtrlSet(ctx kern.ExprContext, name string, newValue any) (currentValue any) {
 	if globalCtx := ctx.GetGlobal(); globalCtx != nil {
-		if !strings.HasPrefix(name, "_") {
-			name = "_" + name
-		}
-
+		name = fixCtrlVar(name)
 		currentValue, _ = globalCtx.GetVar(name)
 		globalCtx.SetVar(name, newValue)
 	}
@@ -56,18 +60,14 @@ func GlobalCtrlSet(ctx kern.ExprContext, name string, newValue any) (currentValu
 
 func GlobalCtrlGet(ctx kern.ExprContext, name string) (currentValue any) {
 	if globalCtx := ctx.GetGlobal(); globalCtx != nil {
-		if !strings.HasPrefix(name, "_") {
-			name = "_" + name
-		}
+		name = fixCtrlVar(name)
 		currentValue, _ = globalCtx.GetVar(name)
 	}
 	return currentValue
 }
 
 func CtrlEnable(ctx kern.ExprContext, name string) (currentStatus bool) {
-	if !strings.HasPrefix(name, "_") {
-		name = "_" + name
-	}
+	name = fixCtrlVar(name)
 	if v, exists := ctx.GetVar(name); exists && kern.IsBool(v) {
 		currentStatus, _ = v.(bool)
 	}
@@ -77,9 +77,7 @@ func CtrlEnable(ctx kern.ExprContext, name string) (currentStatus bool) {
 }
 
 func CtrlDisable(ctx kern.ExprContext, name string) (currentStatus bool) {
-	if !strings.HasPrefix(name, "_") {
-		name = "_" + name
-	}
+	name = fixCtrlVar(name)
 	if v, exists := ctx.GetVar(name); exists && kern.IsBool(v) {
 		currentStatus, _ = v.(bool)
 	}

int-iterator.go

@@ -20,6 +20,10 @@ type IntIterator struct {
 	step  int64
 }
 
+func NewIntIteratorA(args ...any) (it *IntIterator, err error) {
+	return NewIntIterator(args)
+}
+
 func NewIntIterator(args []any) (it *IntIterator, err error) {
 	var argc int = 0
 	if args != nil {

iter-factory.go

@@ -11,6 +11,15 @@ import (
 	"git.portale-stac.it/go-pkg/expr/scan"
 )
 
+func NewFormalIterator(value any) (it kern.Iterator) {
+	if value == nil {
+		it = NewArrayIterator([]any{})
+	} else {
+		it = NewArrayIterator([]any{value})
+	}
+	return
+}
+
 func NewIterator(ctx kern.ExprContext, value any, ops []*scan.Term) (it kern.Iterator, err error) {
 	if value == nil {
 		return NewArrayIterator([]any{}), nil
@@ -19,6 +28,8 @@ func NewIterator(ctx kern.ExprContext, value any, ops []*scan.Term) (it kern.Ite
 	switch v := value.(type) {
 	case *kern.ListType:
 		it = NewListIterator(v, nil)
+	case *kern.LinkedList:
+		it = NewLinkedListIterator(v, nil)
 	case *kern.DictType:
 		it, err = NewDictIterator(v, nil)
 	case []any:
@@ -36,9 +47,9 @@ 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)
-}
+// 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

@@ -12,6 +12,8 @@ import (
 	"git.portale-stac.it/go-pkg/expr/scan"
 )
 
+const iterIterType = "IterIter"
+
 type IterIter struct {
 	it       kern.Iterator
 	count    int64
@@ -22,7 +24,13 @@ type IterIter struct {
 }
 
 func NewIterIter(it kern.Iterator, ctx kern.ExprContext, exprs []*scan.Term) (iter kern.Iterator, err error) {
-	iter = &IterIter{it: it, count: 0, index: -1, ctx: ctx, exprList: exprs, current: nil}
+	if ctx == nil {
+		err = fmt.Errorf("context is required for %s", iterIterType)
+	} else if it == nil {
+		err = fmt.Errorf("source iterator is required for %s", iterIterType)
+	} else {
+		iter = &IterIter{it: it, count: 0, index: -1, ctx: ctx, exprList: exprs, current: nil}
+	}
 	return
 }
 
@@ -31,7 +39,7 @@ func (it *IterIter) String() string {
 }
 
 func (it *IterIter) TypeName() string {
-	return "IterIter"
+	return iterIterType
 }
 
 func (it *IterIter) HasOperation(name string) bool {

kern/clone-value.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// clone-value.go
+package kern
+
+func Clone(v any) (c any) {
+	if v == nil {
+		return
+	}
+	switch unboxed := v.(type) {
+	case int64:
+		c = unboxed
+	case float64:
+		c = unboxed
+	case string:
+		c = unboxed
+	case bool:
+		c = unboxed
+	case *ListType:
+		c = unboxed.Clone()
+	case *DictType:
+		c = unboxed.Clone()
+	case *LinkedList:
+		c = unboxed.Clone()
+	default:
+		c = v
+	}
+	return
+}

kern/common-errors.go

@@ -84,6 +84,10 @@ func ErrUnknownVar(funcName, varName string) error {
 	return fmt.Errorf("%s(): unknown variable %q", funcName, varName)
 }
 
+func ErrFuncInvalidArg(funcName, details string) error {
+	return fmt.Errorf("%s(): invalid argument -- %s", funcName, details)
+}
+
 // --- Operator errors
 
 func ErrLeftOperandMustBeVariable(leftTerm, opTerm Term) error {

kern/common-type-names.go

@@ -20,4 +20,5 @@ const (
 	TypeDict          = "dict"
 	TypeListOf        = "list-of-"
 	TypeListOfStrings = "list-of-strings"
+	TypeLinkedList    = "linked-list"
 )

kern/compare.go

@@ -20,6 +20,10 @@ func Equal(value1, value2 any) (equal bool) {
 		d1 := value1.(*DictType)
 		d2 := value2.(*DictType)
 		equal = d1.Equals(*d2)
+	} else if IsLinkedList(value1) && IsLinkedList(value2) {
+		ll1 := value1.(*LinkedList)
+		ll2 := value2.(*LinkedList)
+		equal = ll1.Equals(ll2)
 	} else if IsInteger(value1) && IsInteger(value2) {
 		equal = value1.(int64) == value2.(int64)
 	} else if IsString(value1) && IsString(value2) {

kern/dict-type.go

@@ -10,6 +10,8 @@ import (
 	"strings"
 )
 
+const DictTypeName = "dict"
+
 type DictType map[any]any
 
 func IsDict(v any) (ok bool) {
@@ -74,9 +76,11 @@ func (dict *DictType) toMultiLine(sb *strings.Builder, opt FmtOpt) {
 
 			sb.WriteString(nest)
 			if key, ok := name.(string); ok {
-				sb.WriteString(string('"') + key + string('"'))
+				sb.WriteByte('"')
+				sb.WriteString(key)
+				sb.WriteByte('"')
 			} else {
-				sb.WriteString(fmt.Sprintf("%v", name))
+				fmt.Fprintf(sb, "%v", name)
 			}
 			sb.WriteString(": ")
 			if f, ok := value.(Formatter); ok {
@@ -84,7 +88,7 @@ func (dict *DictType) toMultiLine(sb *strings.Builder, opt FmtOpt) {
 			} else if _, ok = value.(Functor); ok {
 				sb.WriteString("func(){}")
 			} else {
-				sb.WriteString(fmt.Sprintf("%v", value))
+				fmt.Fprintf(sb, "%v", value)
 			}
 		}
 		sb.WriteByte('\n')
@@ -108,9 +112,11 @@ func (dict *DictType) ToString(opt FmtOpt) string {
 				sb.WriteString(", ")
 			}
 			if s, ok := key.(string); ok {
-				sb.WriteString(string('"') + s + string('"'))
+				sb.WriteByte('"')
+				sb.WriteString(s)
+				sb.WriteByte('"')
 			} else {
-				sb.WriteString(fmt.Sprintf("%v", key))
+				fmt.Fprintf(&sb, "%v", key)
 			}
 			sb.WriteString(": ")
 			if formatter, ok := value.(Formatter); ok {
@@ -118,7 +124,7 @@ func (dict *DictType) ToString(opt FmtOpt) string {
 			} else if t, ok := value.(Term); ok {
 				sb.WriteString(t.String())
 			} else {
-				sb.WriteString(fmt.Sprintf("%#v", value))
+				fmt.Fprintf(&sb, "%#v", value)
 			}
 		}
 		sb.WriteByte('}')
@@ -131,7 +137,7 @@ func (dict *DictType) String() string {
 }
 
 func (dict *DictType) TypeName() string {
-	return "dict"
+	return DictTypeName
 }
 
 func (dict *DictType) HasKey(target any) (ok bool) {
@@ -155,7 +161,7 @@ func (dict *DictType) GetItem(key any) (value any, exists bool) {
 func (dict *DictType) Clone() (c *DictType) {
 	c = newDict(nil)
 	for k, v := range *dict {
-		(*c)[k] = v
+		(*c)[k] = Clone(v)
 	}
 	return
 }

kern/expr-context.go

@@ -28,4 +28,36 @@ type ExprContext interface {
 	Call(name string, args map[string]any) (result any, err error)
 	RegisterFuncInfo(info ExprFunc)
 	RegisterFunc(name string, f Functor, returnType string, param []ExprFuncParam) (funcInfo ExprFunc, err error)
+
+	ToDict() (dict *DictType)
+	ToString(opt FmtOpt) string
+}
+
+func ContextToDict(ctx ExprContext) (dict *DictType) {
+	var keys []string
+	// Variables
+	keys = ctx.EnumVars(nil)
+	vars := MakeDict()
+	for _, key := range keys {
+		value, _ := ctx.GetVar(key)
+		vars.SetItem(key, value)
+	}
+
+	// Functions
+	keys = ctx.EnumFuncs(func(name string) bool { return true })
+	funcs := MakeDict()
+	for _, key := range keys {
+		funcInfo, _ := ctx.GetFuncInfo(key)
+		funcs.SetItem(key, funcInfo)
+	}
+
+	dict = MakeDict()
+	dict.SetItem("vars", vars)
+	dict.SetItem("funcs", funcs)
+	return
+}
+
+func ContextToString(ctx ExprContext, opt FmtOpt) string {
+	dict := ctx.ToDict()
+	return dict.ToString(opt)
 }

kern/formatter.go

@@ -4,7 +4,10 @@
 // formatter.go
 package kern
 
-import "fmt"
+import (
+	"fmt"
+	"strings"
+)
 
 type FmtOpt uint32 // lower 16 bits hold a bit-mask, higher 16 bits hold an indentation number
 
@@ -46,6 +49,18 @@ type Formatter interface {
 	ToString(options FmtOpt) string
 }
 
+func Format(sb *strings.Builder, item any, opt FmtOpt) {
+	if s, ok := item.(string); ok {
+		sb.WriteByte('"')
+		sb.WriteString(s)
+		sb.WriteByte('"')
+	} else if formatter, ok := item.(Formatter); ok {
+		sb.WriteString(formatter.ToString(opt))
+	} else {
+		fmt.Fprintf(sb, "%v", item)
+	}
+}
+
 func GetFormatted(v any, opt FmtOpt) (text string) {
 	if v == nil {
 		text = "(nil)"

kern/fraction-type.go

@@ -44,10 +44,11 @@ func MakeGeneratingFraction(s string) (f *FractionType, err error) {
 	if len(s) == 0 {
 		goto exit
 	}
-	if s[0] == '-' {
+	switch s[0] {
+	case '-':
 		sign = int64(-1)
 		s = s[1:]
-	} else if s[0] == '+' {
+	case '+':
 		s = s[1:]
 	}
 	//	if strings.HasSuffix(s, "()") {

kern/iterator.go

@@ -7,6 +7,7 @@ package kern
 import (
 	// "errors"
 	"fmt"
+	"slices"
 )
 
 // Operator names
@@ -50,3 +51,45 @@ func IsIterator(v any) (ok bool) {
 	_, ok = v.(Iterator)
 	return
 }
+
+type IteratorBase struct {
+	ItemIndex int64
+	ItemCount int64
+	current   any
+}
+
+func (it *IteratorBase) Current() (item any, err error) {
+	return it.current, nil
+}
+
+func (it *IteratorBase) Index() int64 {
+	return it.ItemIndex
+}
+
+func (it *IteratorBase) Count() int64 {
+	return it.ItemCount
+}
+
+func (it *IteratorBase) HasOperation(name string) bool {
+	return slices.Contains([]string{NextName, IndexName, CountName, CurrentName}, name)
+}
+
+func (it *IteratorBase) Clean() (err error) {
+	return
+}
+
+func (it *IteratorBase) Reset() (err error) {
+	it.ItemIndex = -1
+	it.ItemCount = 0
+	it.current = nil
+	return
+}
+
+func (it *IteratorBase) Increment() {
+	it.ItemIndex++
+	it.ItemCount++
+}
+
+func (it *IteratorBase) SetCurrent(v any) {
+	it.current = v
+}

kern/linked-list-type.go

@@ -0,0 +1,130 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// linked-list-type.go
+package kern
+
+import (
+	"strings"
+)
+
+const LinkedListTypeName = "lisked-list"
+const MaxUint64Allowed = uint64(9_223_372_036_854_775_807)
+
+func IsLinkedList(v any) (ok bool) {
+	_, ok = v.(*LinkedList)
+	return ok
+}
+
+func NewLinkedListA(listAny ...any) (list *LinkedList) {
+	if listAny == nil {
+		listAny = []any{}
+	}
+	list = NewLinkedList()
+	for _, item := range listAny {
+		list.PushBack(FixAnyNumber(item))
+	}
+	return
+}
+
+func LinkedListFromStrings(stringList []string) (list *LinkedList) {
+	list = NewLinkedList()
+	for _, s := range stringList {
+		list.PushBack(s)
+	}
+	return
+}
+
+func (ls *LinkedList) ToString(opt FmtOpt) (s string) {
+	indent := GetFormatIndent(opt)
+	flags := GetFormatFlags(opt)
+
+	var sb strings.Builder
+	sb.WriteString("[<")
+	if ls.Len() > 0 {
+		innerOpt := MakeFormatOptions(flags, indent+1)
+		nest := strings.Repeat("  ", indent+1)
+
+		if flags&MultiLine != 0 {
+			sb.WriteByte('\n')
+			sb.WriteString(nest)
+		}
+
+		i := 0
+		for item := ls.FirstNode(); item != nil; item = item.Next() {
+			if i > 0 {
+				if flags&MultiLine != 0 {
+					sb.WriteString(",\n")
+					sb.WriteString(nest)
+				} else {
+					sb.WriteString(", ")
+				}
+			}
+			// data := item.Data()
+			// if s, ok := data.(string); ok {
+			// 	sb.WriteByte('"')
+			// 	sb.WriteString(s)
+			// 	sb.WriteByte('"')
+			// } else if formatter, ok := data.(Formatter); ok {
+			// 	sb.WriteString(formatter.ToString(innerOpt))
+			// } else {
+			// 	fmt.Fprintf(&sb, "%v", data)
+			// }
+			Format(&sb, item.Data(), innerOpt)
+			i++
+		}
+		if flags&MultiLine != 0 {
+			sb.WriteByte('\n')
+			sb.WriteString(strings.Repeat("  ", indent))
+		}
+	}
+	sb.WriteString(">]")
+	s = sb.String()
+	if flags&Truncate != 0 && len(s) > TruncateSize {
+		s = TruncateString(s)
+	}
+	return
+}
+
+func (ls *LinkedList) String() string {
+	return ls.ToString(0)
+}
+
+func (ls *LinkedList) TypeName() string {
+	return LinkedListTypeName
+}
+
+// func (ls *LinkedList) Contains(t *ListType) (answer bool) {
+// 	if len(*ls) >= len(*t) {
+// 		answer = true
+// 		for _, item := range *t {
+// 			if answer = ls.IndexDeepSameCmp(item) >= 0; !answer {
+// 				break
+// 			}
+// 		}
+// 	}
+// 	return
+// }
+
+func (ls1 *LinkedList) Equals(ls2 *LinkedList) (answer bool) {
+	if ls2 != nil && ls1.Len() == ls2.Len() {
+		answer = true
+		i2 := ls2.FirstNode()
+		for i1 := ls1.FirstNode(); i1 != nil; i1 = i1.Next() {
+			if !Equal(i1.Data(), i2.Data()) {
+				answer = false
+				break
+			}
+			i2 = i2.Next()
+		}
+	}
+	return
+}
+
+func (ls1 *LinkedList) Clone() (ls2 *LinkedList) {
+	ls2 = NewLinkedListA()
+	for i1 := ls1.FirstNode(); i1 != nil; i1 = i1.Next() {
+		ls2.PushBack(Clone(i1.Data()))
+	}
+	return
+}

kern/linked-list.go

@@ -0,0 +1,284 @@
+// simple-list project slist.go
+package kern
+
+import (
+	"fmt"
+)
+
+type ListNode struct {
+	data any
+	next *ListNode
+}
+
+func (node *ListNode) Next() *ListNode {
+	return node.next
+}
+
+func (self *ListNode) Data() any {
+	return self.data
+}
+
+type LinkedList struct {
+	count int
+	first *ListNode
+	last  *ListNode
+}
+
+func NewLinkedList() (list *LinkedList) {
+	list = &LinkedList{0, nil, nil}
+	return
+}
+
+func (ls *LinkedList) Len() int {
+	return ls.count
+}
+
+func (ls *LinkedList) Empty() bool {
+	return ls.count == 0
+}
+
+func (ls *LinkedList) PushFront(data any) *ListNode {
+	ls.first = &ListNode{data, ls.first}
+	if ls.last == nil {
+		ls.last = ls.first
+	}
+	ls.count++
+	return ls.first
+}
+
+func (ls *LinkedList) SeqPushFront(data any) (result *LinkedList) {
+	switch seq := data.(type) {
+	case Iterator:
+		result = ls.IterPushFront(seq)
+	default:
+		ls.PushFront(data)
+		result = ls
+	}
+	return
+}
+
+func (ls *LinkedList) IterPushFront(it Iterator) *LinkedList {
+	for item, err1 := it.Next(); err1 == nil; item, err1 = it.Next() {
+		ls.PushFront(item)
+	}
+	return ls
+}
+
+func (ls *LinkedList) PushBack(data any) (node *ListNode) {
+	node = &ListNode{data, nil}
+	if ls.last != nil {
+		ls.last.next = node
+	}
+	ls.last = node
+	if ls.first == nil {
+		ls.first = node
+	}
+	ls.count++
+	return
+}
+
+func (ls *LinkedList) SeqPushBack(data any) (result *LinkedList) {
+	switch seq := data.(type) {
+	case Iterator:
+		result = ls.IterPushBack(seq)
+	default:
+		ls.PushBack(data)
+		result = ls
+	}
+	return
+}
+
+func (ls *LinkedList) IterPushBack(it Iterator) *LinkedList {
+	for item, err1 := it.Next(); err1 == nil; item, err1 = it.Next() {
+		ls.PushBack(item)
+	}
+	return ls
+}
+
+func (ls *LinkedList) FirstNode() *ListNode {
+	return ls.first
+}
+
+func (ls *LinkedList) First() (data any, err error) {
+	if ls.first != nil {
+		data = ls.first.data
+	} else {
+		err = errorListEmpty()
+	}
+	return
+}
+
+func (ls *LinkedList) LastNode() *ListNode {
+	return ls.last
+}
+
+func (ls *LinkedList) Last() (data interface{}, err error) {
+	if ls.last != nil {
+		data = ls.last.data
+	} else {
+		err = errorListEmpty()
+	}
+	return
+}
+
+func (ls *LinkedList) NodeAt(index int) (node *ListNode, err error) {
+	if ls.count == 0 {
+		err = errorListEmpty()
+	} else if index > ls.count {
+		err = errorOutOfRange()
+	} else if index == ls.count-1 {
+		node = ls.last
+	} else {
+		current := ls.first
+		for range index {
+			current = current.next
+		}
+		node = current
+	}
+	return
+}
+
+func (ls *LinkedList) At(index int) (data interface{}, err error) {
+	node, err := ls.NodeAt(index)
+	if err == nil {
+		data = node.data
+	}
+	return
+}
+
+func (ls *LinkedList) Insert(index int, data any) *ListNode {
+	var prev *ListNode
+
+	prev = nil
+	current := ls.first
+	for pos := 0; current != nil && pos < index; pos++ {
+		prev = current
+		current = current.next
+	}
+
+	node := &ListNode{data, current}
+
+	if prev != nil {
+		prev.next = node
+	}
+
+	if ls.first == current {
+		ls.first = node
+	}
+	if node.next == nil {
+		ls.last = node
+	}
+	ls.count++
+	return node
+}
+
+func (ls *LinkedList) PushBackStringArray(items []string) {
+	for _, v := range items {
+		ls.PushBack(v)
+	}
+}
+
+func (ls *LinkedList) Sub(start, end int) (subList *LinkedList) {
+	subList = NewLinkedList()
+	if node, err := ls.NodeAt(start); err == nil {
+		for i := start; i < end && node != nil; i++ {
+			subList.PushBack(node.data)
+			node = node.next
+		}
+	}
+	return
+}
+
+// type TraverseOperator func(index int, elem interface{}, userData interface{}) (err error)
+
+// func (self *LinkedList) Traverse(op TraverseOperator, user_data interface{}) (err error) {
+// 	index := int(0)
+// 	for current := self.first; current != nil; current = current.next {
+// 		err = op(index, current.data, user_data)
+// 		if err != nil {
+// 			break
+// 		}
+// 		index++
+// 	}
+// 	return
+// }
+
+// func (self *LinkedList) Traverse2(observer Observer, abortOnError bool) (err error) {
+// 	index := int(0)
+// 	for current := self.first; current != nil; current = current.next {
+// 		err = observer.Observe(current, index)
+// 		if err != nil && abortOnError {
+// 			break
+// 		}
+// 		index++
+// 	}
+// 	return
+// }
+
+type EqualFunc func(current, target any) bool
+
+func (ls *LinkedList) FindFirst(eqFunc EqualFunc, targetData any) (targetNode *ListNode) {
+	for current := ls.first; current != nil && targetNode == nil; current = current.next {
+		if eqFunc(current.data, targetData) {
+			targetNode = current
+		}
+	}
+	return
+}
+
+func (ls *LinkedList) FindNext(eqFunc EqualFunc, startNode *ListNode) (targetNode *ListNode) {
+	if startNode != nil {
+		for current := startNode.next; current != nil && targetNode == nil; current = current.next {
+			if eqFunc(current.data, startNode.Data()) {
+				targetNode = current
+			}
+		}
+	}
+	return
+}
+
+// type DataFeeder func(user_data interface{}) interface{}
+// type NodeObserver func(node *ListNode, index int, userData interface{})
+
+// func (self *LinkedList) FeedTail(feeder DataFeeder, feederUserData interface{}, observer NodeObserver, observerUserData interface{}) (count int) {
+// 	count = 0
+// 	for item := feeder(feederUserData); item != nil; item = feeder(feederUserData) {
+// 		// fmt.Println("Item", count, item)
+// 		node := self.PushBack(item)
+// 		if observer != nil {
+// 			observer(node, count, observerUserData)
+// 		}
+// 		count++
+// 	}
+// 	return
+// }
+
+// func (self *LinkedList) FeedTail2(feeder Feeder, observer Observer, abortOnError bool) (count int, err error) {
+// 	count = 0
+// 	// item := feeder.Next()
+// 	for item, err1 := feeder.Next(); item != nil; item, err1 = feeder.Next() {
+// 		if err1 != nil {
+// 			if err == nil {
+// 				err = err1
+// 			}
+// 			if abortOnError {
+// 				break
+// 			}
+// 		}
+// 		// fmt.Println("Item", count, item)
+// 		node := self.PushBack(item)
+// 		if observer != nil {
+// 			observer.Observe(node, count)
+// 		}
+// 		count++
+// 	}
+// 	return
+// }
+
+func errorListEmpty() error {
+	return fmt.Errorf("List is empty")
+}
+
+func errorOutOfRange() error {
+	return fmt.Errorf("Out of range")
+}

kern/list-type.go

@@ -50,13 +50,13 @@ func ListFromStrings(stringList []string) (list *ListType) {
 	return
 }
 
-func (dict *ListType) ToString(opt FmtOpt) (s string) {
+func (ls *ListType) ToString(opt FmtOpt) (s string) {
 	indent := GetFormatIndent(opt)
 	flags := GetFormatFlags(opt)
 
 	var sb strings.Builder
 	sb.WriteByte('[')
-	if len(*dict) > 0 {
+	if len(*ls) > 0 {
 		innerOpt := MakeFormatOptions(flags, indent+1)
 		nest := strings.Repeat("  ", indent+1)
 
@@ -64,7 +64,7 @@ func (dict *ListType) ToString(opt FmtOpt) (s string) {
 			sb.WriteByte('\n')
 			sb.WriteString(nest)
 		}
-		for i, item := range []any(*dict) {
+		for i, item := range []any(*ls) {
 			if i > 0 {
 				if flags&MultiLine != 0 {
 					sb.WriteString(",\n")
@@ -73,15 +73,7 @@ func (dict *ListType) ToString(opt FmtOpt) (s string) {
 					sb.WriteString(", ")
 				}
 			}
-			if s, ok := item.(string); ok {
-				sb.WriteByte('"')
-				sb.WriteString(s)
-				sb.WriteByte('"')
-			} else if formatter, ok := item.(Formatter); ok {
-				sb.WriteString(formatter.ToString(innerOpt))
-			} else {
-				sb.WriteString(fmt.Sprintf("%v", item))
-			}
+			Format(&sb, item, innerOpt)
 		}
 		if flags&MultiLine != 0 {
 			sb.WriteByte('\n')
@@ -96,19 +88,19 @@ func (dict *ListType) ToString(opt FmtOpt) (s string) {
 	return
 }
 
-func (dict *ListType) String() string {
-	return dict.ToString(0)
+func (ls *ListType) String() string {
+	return ls.ToString(0)
 }
 
-func (dict *ListType) TypeName() string {
+func (ls *ListType) TypeName() string {
 	return "list"
 }
 
-func (dict *ListType) Contains(t *ListType) (answer bool) {
-	if len(*dict) >= len(*t) {
+func (ls *ListType) Contains(t *ListType) (answer bool) {
+	if len(*ls) >= len(*t) {
 		answer = true
 		for _, item := range *t {
-			if answer = dict.IndexDeepSameCmp(item) >= 0; !answer {
+			if answer = ls.IndexDeepSameCmp(item) >= 0; !answer {
 				break
 			}
 		}
@@ -116,10 +108,10 @@ func (dict *ListType) Contains(t *ListType) (answer bool) {
 	return
 }
 
-func (ls1 *ListType) Equals(ls2 ListType) (answer bool) {
-	if ls2 != nil && len(*ls1) == len(ls2) {
+func (ls *ListType) Equals(ls2 ListType) (answer bool) {
+	if ls2 != nil && len(*ls) == len(ls2) {
 		answer = true
-		for index, i1 := range *ls1 {
+		for index, i1 := range *ls {
 			// if !reflect.DeepEqual(i1, ls2[index]) {
 			// 	answer = false
 			// 	break
@@ -133,11 +125,20 @@ func (ls1 *ListType) Equals(ls2 ListType) (answer bool) {
 	return
 }
 
-func (dict *ListType) IndexDeepSameCmp(target any) (index int) {
+func (ls1 *ListType) Clone() (ls2 *ListType) {
+	ls := make(ListType, len(*ls1))
+	for i, item := range *ls1 {
+		ls[i] = Clone(item)
+	}
+	ls2 = &ls
+	return
+}
+
+func (ls *ListType) IndexDeepSameCmp(target any) (index int) {
 	var eq bool
 	var err error
 	index = -1
-	for i, item := range *dict {
+	for i, item := range *ls {
 		if eq, err = deepSame(item, target, SameContent); err != nil {
 			break
 		} else if eq {
@@ -188,15 +189,15 @@ func deepSame(a, b any, deepCmp DeepFuncTemplate) (eq bool, err error) {
 	return
 }
 
-func (dict *ListType) SetItem(index int64, value any) (err error) {
-	if index >= 0 && index < int64(len(*dict)) {
-		(*dict)[index] = value
+func (ls *ListType) SetItem(index int64, value any) (err error) {
+	if index >= 0 && index < int64(len(*ls)) {
+		(*ls)[index] = value
 	} else {
-		err = fmt.Errorf("index %d out of bounds (0, %d)", index, len(*dict)-1)
+		err = fmt.Errorf("index %d out of bounds (0, %d)", index, len(*ls)-1)
 	}
 	return
 }
 
-func (dict *ListType) AppendItem(value any) {
-	*dict = append(*dict, value)
+func (ls *ListType) AppendItem(value any) {
+	*ls = append(*ls, value)
 }

kern/number.go

@@ -65,6 +65,38 @@ func AnyInteger(v any) (i int64, ok bool) {
 	return
 }
 
+func FixAnyNumber(v any) (fixed any) {
+	switch unboxed := v.(type) {
+	case int:
+		fixed = int64(unboxed)
+	case int8:
+		fixed = int64(unboxed)
+	case int16:
+		fixed = int64(unboxed)
+	case int32:
+		fixed = int64(unboxed)
+	case uint:
+		fixed = int64(unboxed)
+	case uint8:
+		fixed = int64(unboxed)
+	case uint16:
+		fixed = int64(unboxed)
+	case uint32:
+		fixed = int64(unboxed)
+	case uint64:
+		if unboxed <= MaxUint64Allowed {
+			fixed = int64(unboxed)
+		} else {
+			fixed = float64(unboxed)
+		}
+	case float32:
+		fixed = float64(unboxed)
+	default:
+		fixed = v
+	}
+	return
+}
+
 func ToGoInt(value any, description string) (i int, err error) {
 	if valueInt64, ok := value.(int64); ok {
 		i = int(valueInt64)

linked-list-iterator.go

@@ -0,0 +1,102 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// list-iterator.go
+package expr
+
+import (
+	"fmt"
+	"io"
+	"slices"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
+type LinkedListIterator struct {
+	a       *kern.LinkedList
+	count   int64
+	index   int64
+	current *kern.ListNode
+}
+
+func NewLinkedListIterator(list *kern.LinkedList, args []any) (it *LinkedListIterator) {
+	it = &LinkedListIterator{a: list, count: 0, index: -1, current: list.FirstNode()}
+	return
+}
+
+func (it *LinkedListIterator) String() string {
+	var l = int64(0)
+	if it.a != nil {
+		l = int64(it.a.Len())
+	}
+	return fmt.Sprintf("$([<#%d>])", l)
+}
+
+func (it *LinkedListIterator) TypeName() string {
+	return "LinkedListIterator"
+}
+
+func (it *LinkedListIterator) HasOperation(name string) bool {
+	yes := slices.Contains([]string{kern.NextName, kern.ResetName, kern.IndexName, kern.CountName, kern.CurrentName}, name)
+	return yes
+}
+
+func (it *LinkedListIterator) 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 = int64(it.Index())
+	case kern.CurrentName:
+		v, err = it.Current()
+	case kern.CountName:
+		v = it.count
+	default:
+		err = kern.ErrNoOperation(name)
+	}
+	return
+}
+
+func (it *LinkedListIterator) Current() (item any, err error) {
+	if it.current != nil {
+		item = it.current.Data()
+	} else {
+		err = io.EOF
+	}
+	return
+}
+
+func (it *LinkedListIterator) Next() (item any, err error) {
+	if it.current != nil {
+		item = it.current.Data()
+		it.current = it.current.Next()
+		it.index++
+		it.count++
+	} else {
+		err = io.EOF
+	}
+	return
+}
+
+func (it *LinkedListIterator) Index() int64 {
+	return it.index
+}
+
+func (it *LinkedListIterator) Count() int64 {
+	return it.count
+}
+
+func (it *LinkedListIterator) Reset() error {
+	it.current = it.a.FirstNode()
+	it.index = -1
+	it.count = 0
+	return nil
+}
+
+func (it *LinkedListIterator) Clean() error {
+	return nil
+}

operand-dict.go

@@ -30,7 +30,14 @@ func evalDict(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		if param, err = tree.Compute(ctx); err != nil {
 			break
 		}
-		items[key] = param
+		var keyValue any
+		if keyValue, err = (key.(*scan.Term)).Compute(ctx); err == nil {
+			if kern.IsInteger(keyValue) || kern.IsString(keyValue) {
+				items[keyValue] = param
+			} else {
+				err = key.(*scan.Term).Errorf("dict key can be integer or string, got %s", kern.TypeName(keyValue))
+			}
+		}
 	}
 	if err == nil {
 		v = &items

operand-iterator.go

@@ -137,6 +137,11 @@ func evalIterator(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		if args, err = evalSiblings(ctx, opTerm.Children, nil); err == nil {
 			v = NewListIterator(list, args)
 		}
+	} else if list, ok := firstChildValue.(*kern.LinkedList); ok {
+		var args []any
+		if args, err = evalSiblings(ctx, opTerm.Children, nil); err == nil {
+			v = NewLinkedListIterator(list, args)
+		}
 	} else if intVal, ok := firstChildValue.(int64); ok {
 		var args []any
 		if args, err = evalSiblings(ctx, opTerm.Children, intVal); err == nil {

operand-linked-list.go

@@ -0,0 +1,43 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operand-list.go
+package expr
+
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+	"git.portale-stac.it/go-pkg/expr/scan"
+)
+
+// -------- list term
+// func newLinkedListTermA(args ...*scan.Term) *scan.Term {
+// 	return newLinkedListTerm(0, 0, args)
+// }
+
+func newLinkedListTerm(row, col int, args []*scan.Term) *scan.Term {
+	return &scan.Term{
+		Tk:       *scan.NewValueToken(row, col, scan.SymLinkedList, "[<>]", args),
+		Parent:   nil,
+		Children: nil,
+		Position: scan.PosLeaf,
+		Priority: scan.PriValue,
+		EvalFunc: evalLinkedList,
+	}
+}
+
+// -------- list func
+func evalLinkedList(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
+	list, _ := opTerm.Value().([]*scan.Term)
+	items := kern.NewLinkedList()
+	for _, tree := range list {
+		var param any
+		if param, err = tree.Compute(ctx); err != nil {
+			break
+		}
+		items.PushBack(param)
+	}
+	if err == nil {
+		v = items
+	}
+	return
+}

operator-assign.go

@@ -22,6 +22,26 @@ func newAssignTerm(tk *scan.Token) (inst *scan.Term) {
 	}
 }
 
+func evalAssign(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
+	v, err = generalEvalAssign(ctx, opTerm, false)
+	return
+}
+
+func newDeepCopyAssignTerm(tk *scan.Token) (inst *scan.Term) {
+	return &scan.Term{
+		Tk:       *tk,
+		Children: make([]*scan.Term, 0, 2),
+		Position: scan.PosInfix,
+		Priority: scan.PriAssign,
+		EvalFunc: evalDeepCopyAssign,
+	}
+}
+
+func evalDeepCopyAssign(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
+	v, err = generalEvalAssign(ctx, opTerm, true)
+	return
+}
+
 func assignCollectionItem(ctx kern.ExprContext, collectionTerm, keyListTerm *scan.Term, value any) (err error) {
 	var collectionValue, keyListValue, keyValue any
 	var keyList *kern.ListType
@@ -57,23 +77,62 @@ func assignCollectionItem(ctx kern.ExprContext, collectionTerm, keyListTerm *sca
 	return
 }
 
-func assignValue(ctx kern.ExprContext, leftTerm *scan.Term, v any) (err error) {
+func assignValue(ctx kern.ExprContext, leftTerm *scan.Term, v any, deepCopy bool) (err error) {
 	if leftTerm.Symbol() == scan.SymIndex {
 		err = assignCollectionItem(ctx, leftTerm.Children[0], leftTerm.Children[1], v)
 	} else {
+		if deepCopy {
+			v = kern.Clone(v)
+		}
 		ctx.UnsafeSetVar(leftTerm.Source(), v)
 	}
 	return
 }
 
-func evalAssign(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
+func evalAssignDictItem(ctx kern.ExprContext, dotTerm *scan.Term, valueTerm kern.Term) (v any, err error) {
+	var ok bool
+	var dictAny, dotKey any
+	var dict *kern.DictType
+
+	if err = dotTerm.CheckOperands(); err != nil {
+		return
+	}
+
+	dotLeftTerm := dotTerm.GetChild(0)
+	if dictAny, err = dotLeftTerm.Compute(ctx); err != nil {
+		return
+	}
+	if dict, ok = dictAny.(*kern.DictType); !ok {
+		err = dotTerm.Tk.ErrorExpectedGot(kern.DictTypeName)
+		return
+	}
+
+	dotRightTerm := dotTerm.Children[1]
+	dotRightSym := dotRightTerm.Symbol()
+	if dotRightSym == scan.SymVariable || dotRightSym == scan.SymString {
+		dotKey = util.UnquoteString(dotRightTerm.Source())
+	} else if dotKey, err = dotRightTerm.Compute(ctx); err != nil {
+		return
+	}
+
+	if v, err = valueTerm.Compute(ctx); err != nil {
+		return
+	}
+
+	dict.SetItem(dotKey, v)
+	return
+}
+
+func generalEvalAssign(ctx kern.ExprContext, opTerm *scan.Term, deepCopy bool) (v any, err error) {
 	if err = opTerm.CheckOperands(); err != nil {
 		return
 	}
 
 	leftTerm := opTerm.Children[0]
 	leftSym := leftTerm.Symbol()
-	if leftSym != scan.SymVariable && leftSym != scan.SymIndex {
+	if leftSym == scan.SymDot {
+		return evalAssignDictItem(ctx, opTerm.Children[0], opTerm.GetChild(1))
+	} else if leftSym != scan.SymVariable && leftSym != scan.SymIndex {
 		err = leftTerm.Tk.Errorf("left operand of %q must be a variable or a collection's item", opTerm.Tk.Source())
 		return
 	}
@@ -93,10 +152,10 @@ func evalAssign(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 					err = opTerm.Errorf("unknown function %s()", rightChild.Source())
 				}
 			} else {
-				err = assignValue(ctx, leftTerm, v)
+				err = assignValue(ctx, leftTerm, v, deepCopy)
 			}
 		} else {
-			err = assignValue(ctx, leftTerm, v)
+			err = assignValue(ctx, leftTerm, v, deepCopy)
 		}
 	}
 	if err != nil {
@@ -203,7 +262,7 @@ func evalOpAssign(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 				err = opTerm.Errorf("unsupported assign operator %q", opTerm.Source())
 			}
 			if err == nil {
-				err = assignValue(ctx, leftTerm, v)
+				err = assignValue(ctx, leftTerm, v, false)
 			}
 		}
 	}
@@ -213,6 +272,7 @@ func evalOpAssign(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 // init
 func init() {
 	scan.RegisterTermConstructor(scan.SymEqual, newAssignTerm)
+	scan.RegisterTermConstructor(scan.SymColonEqual, newDeepCopyAssignTerm)
 	scan.RegisterTermConstructor(scan.SymPlusEqual, newOpAssignTerm)
 	scan.RegisterTermConstructor(scan.SymMinusEqual, newOpAssignTerm)
 	scan.RegisterTermConstructor(scan.SymStarEqual, newOpAssignTerm)

operator-cat.go

@@ -0,0 +1,151 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-cat.go
+package expr
+
+import (
+	"fmt"
+	"io"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+	"git.portale-stac.it/go-pkg/expr/scan"
+)
+
+//-------- cat term
+
+func newCatTerm(tk *scan.Token) (inst *scan.Term) {
+	return &scan.Term{
+		Tk:       *tk,
+		Children: make([]*scan.Term, 0, 2),
+		Position: scan.PosInfix,
+		Priority: scan.PriIterOp,
+		EvalFunc: evalCat,
+	}
+}
+
+func evalCat(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
+	}
+
+	if leftValue, err = opTerm.Children[0].Compute(ctx); err != nil {
+		return
+	}
+
+	if rightValue, err = opTerm.Children[1].Compute(ctx); err != nil {
+		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} {
+	// 	for item, err = it.Next(); err == nil; item, err = it.Next() {
+	// 		values.AppendItem(item)
+	// 	}
+	// }
+	// if err == io.EOF {
+	// 	err = nil
+	// }
+	// v = values
+	v = newCatIterator(itLeft, itRight)
+	return
+}
+
+const catIteratorType = "cat"
+
+type catIterator struct {
+	kern.IteratorBase
+	itLeft    kern.Iterator
+	itRight   kern.Iterator
+	itCurrent kern.Iterator
+}
+
+func newCatIterator(itLeft, itRight kern.Iterator) (it *catIterator) {
+	it = &catIterator{
+		IteratorBase: kern.IteratorBase{},
+		itLeft:       itLeft,
+		itRight:      itRight,
+		itCurrent:    itLeft,
+	}
+	it.Reset()
+	return
+}
+
+func (it *catIterator) TypeName() string {
+	return catIteratorType
+}
+
+func (it *catIterator) String() string {
+	return fmt.Sprintf("$(%s %s %s)", it.itLeft, catIteratorType, it.itRight)
+}
+
+func (it *catIterator) Next() (item any, err error) {
+	if it.itCurrent == nil {
+		err = io.EOF
+	} else {
+		if item, err = it.itCurrent.Next(); err == nil {
+			it.Increment()
+		} else if err == io.EOF {
+			if it.itCurrent == it.itLeft {
+				it.itCurrent = it.itRight
+			} else {
+				return
+			}
+			if item, err = it.itCurrent.Next(); err == nil {
+				it.Increment()
+			} else {
+				it.itCurrent = nil
+			}
+		}
+	}
+	it.SetCurrent(item)
+	return
+}
+
+// func (it *catIterator) Reset() (err error) {
+// 	err = it.itLeft.Reset()
+// 	it.IteratorBase.Reset()
+// 	return
+// }
+
+func (it *catIterator) 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)
+	}
+	return
+}
+
+// init
+func init() {
+	scan.RegisterTermConstructor(scan.SymKwCat, newCatTerm)
+}

operator-context.go

@@ -5,6 +5,8 @@
 package expr
 
 import (
+	"io"
+
 	"git.portale-stac.it/go-pkg/expr/kern"
 	"git.portale-stac.it/go-pkg/expr/scan"
 )
@@ -23,8 +25,8 @@ func newContextTerm(tk *scan.Token) (inst *scan.Term) {
 
 func evalContextValue(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	var childValue any
-
 	var sourceCtx kern.ExprContext
+
 	if len(opTerm.Children) == 0 {
 		sourceCtx = ctx
 	} else if opTerm.Children[0].Symbol() == scan.SymVariable && opTerm.Children[0].Source() == "global" {
@@ -33,25 +35,27 @@ 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 {
-		if formatter, ok := sourceCtx.(kern.DictFormat); ok {
-			v = formatter.ToDict()
-		} else if formatter, ok := sourceCtx.(kern.Formatter); ok {
-			v = formatter.ToString(0)
-		} else {
-			// keys := sourceCtx.EnumVars(func(name string) bool { return name[0] != '_' })
-			keys := sourceCtx.EnumVars(nil)
-			d := make(map[string]any)
-			for _, key := range keys {
-				d[key], _ = sourceCtx.GetVar(key)
+		v = sourceCtx.ToDict()
+	} else if childValue != nil {
+		it, ok := childValue.(kern.Iterator)
+		if !ok {
+			it, err = NewIterator(ctx, childValue, nil)
+		}
+		if err == nil {
+			var item any
+			values := kern.NewLinkedListA()
+			for item, err = it.Next(); err == nil; item, err = it.Next() {
+				values.PushBack(item)
 			}
-			keys = sourceCtx.EnumFuncs(func(name string) bool { return true })
-			for _, key := range keys {
-				d[key], _ = sourceCtx.GetFuncInfo(key)
+			if err == io.EOF {
+				err = nil
+				v = values
 			}
-			v = d
 		}
 	} else {
 		err = opTerm.ErrIncompatiblePrefixPostfixType(childValue)

operator-digest.go

@@ -45,7 +45,7 @@ func evalDigest(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	for item, err = it.Next(); err == nil; item, err = it.Next() {
 		ctx.SetVar("_", item)
 		ctx.SetVar("__", it.Index())
-		ctx.SetVar("_#", it.Count())
+		ctx.SetVar("#", it.Count())
 		if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil {
 			if rightValue == nil {
 				break
@@ -53,7 +53,7 @@ func evalDigest(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 				lastValue = rightValue
 			}
 		}
-		ctx.DeleteVar("_#")
+		ctx.DeleteVar("#")
 		ctx.DeleteVar("__")
 		ctx.DeleteVar("_")
 		if err != nil {

operator-dot.go

@@ -7,6 +7,7 @@ package expr
 import (
 	"git.portale-stac.it/go-pkg/expr/kern"
 	"git.portale-stac.it/go-pkg/expr/scan"
+	"git.portale-stac.it/go-pkg/expr/util"
 )
 
 // -------- dot term
@@ -34,7 +35,7 @@ func evalDot(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 
 	switch unboxedValue := leftValue.(type) {
 	case kern.ExtIterator:
-		if indexTerm.Tk.Sym == scan.SymVariable /*|| indexTerm.Tk.Sym == scan.SymString */ {
+		if indexTerm.Symbol() == scan.SymVariable /*|| indexTerm.Tk.Sym == scan.SymString */ {
 			opName := indexTerm.Source()
 			if unboxedValue.HasOperation(opName) {
 				v, err = unboxedValue.CallOperation(opName, map[string]any{})
@@ -46,21 +47,22 @@ func evalDot(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 			err = indexTerm.Tk.ErrorExpectedGot("identifier")
 		}
 	case *kern.DictType:
-		var ok bool
-		s := opTerm.Children[1].Tk.Sym
-		if s == scan.SymVariable || s == scan.SymString {
-			src := opTerm.Children[1].Source()
-			if len(src) > 1 && src[0] == '"' && src[len(src)-1] == '"' {
-				src = src[1 : len(src)-1]
-			}
-			if v, ok = unboxedValue.GetItem(src); !ok {
-				err = opTerm.Errorf("key %q not found", src)
-			}
-		} else if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil {
-			if v, ok = unboxedValue.GetItem(rightValue); !ok {
-				err = opTerm.Errorf("key %q not found", rightValue)
-			}
-		}
+		// var ok bool
+		// s := opTerm.Children[1].Symbol()
+		// if s == scan.SymVariable || s == scan.SymString {
+		// 	src := opTerm.Children[1].Source()
+		// 	if len(src) > 1 && src[0] == '"' && src[len(src)-1] == '"' {
+		// 		src = src[1 : len(src)-1]
+		// 	}
+		// 	if v, ok = unboxedValue.GetItem(src); !ok {
+		// 		err = opTerm.Errorf("key %q not found", src)
+		// 	}
+		// } else if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil {
+		// 	if v, ok = unboxedValue.GetItem(rightValue); !ok {
+		// 		err = opTerm.Errorf("key %q not found", rightValue)
+		// 	}
+		// }
+		v, err = dotGetDictItemValue(ctx, unboxedValue, opTerm.Children[1])
 	default:
 		if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil {
 			err = opTerm.Errorf("incompatible types: %s and %s", kern.TypeName(leftValue), kern.TypeName(rightValue))
@@ -69,6 +71,34 @@ func evalDot(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	return
 }
 
+func dotGetDictItemValue(ctx kern.ExprContext, d *kern.DictType, rightTerm *scan.Term) (v any, err error) {
+	var ok bool
+	var rightValue any
+	s := rightTerm.Symbol()
+	if s == scan.SymVariable || s == scan.SymString {
+		// src := rightTerm.Source()
+		// if len(src) > 1 && src[0] == '"' && src[len(src)-1] == '"' {
+		// 	src = src[1 : len(src)-1]
+		// }
+		src := util.UnquoteString(rightTerm.Source())
+		if v, ok = d.GetItem(src); !ok {
+			err = errDictKeyNotFound(rightTerm, src)
+		}
+	} else if rightValue, err = rightTerm.Compute(ctx); err == nil {
+		if v, ok = d.GetItem(rightValue); !ok {
+			err = errDictKeyNotFound(rightTerm, rightValue)
+		}
+	}
+	return
+}
+
+func errDictKeyNotFound(term *scan.Term, key any) error {
+	if s, ok := key.(string); ok {
+		return term.Errorf("key %q not found", s)
+	}
+	return term.Errorf("key %v not found", key)
+}
+
 // init
 func init() {
 	scan.RegisterTermConstructor(scan.SymDot, newDotTerm)

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()
-	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)
-			}
-		}
-		ctx.DeleteVar("_#")
+		ctx.SetVar("#", it.Count())
+		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-groupby.go

@@ -62,7 +62,7 @@ func evalGroupBy(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	for item, err = it.Next(); err == nil; item, err = it.Next() {
 		ctx.SetVar("_", item)
 		ctx.SetVar("__", it.Index())
-		ctx.SetVar("_#", it.Count())
+		ctx.SetVar("#", it.Count())
 
 		var sItemKey string
 
@@ -71,7 +71,11 @@ func evalGroupBy(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 				sItemKey = strconv.Itoa(int(it.Index()))
 			} else if d.HasKey(sKey) {
 				if keyValue, exists := d.GetItem(sKey); exists {
-					sItemKey = fmt.Sprintf("%v", keyValue)
+					if s, ok := keyValue.(string); ok {
+						sItemKey = s
+					} else {
+						sItemKey = fmt.Sprintf("%v", keyValue)
+					}
 				} else {
 					sItemKey = "_"
 				}
@@ -92,7 +96,7 @@ func evalGroupBy(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		ls.AppendItem(item)
 		values.SetItem(sItemKey, ls)
 
-		ctx.DeleteVar("_#")
+		ctx.DeleteVar("#")
 		ctx.DeleteVar("__")
 		ctx.DeleteVar("_")
 	}

operator-index.go

@@ -89,6 +89,11 @@ func evalIndex(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 			if index, err = verifyIndex(indexTerm, indexList, len(*unboxedValue)); err == nil {
 				v = (*unboxedValue)[index]
 			}
+		case *kern.LinkedList:
+			var index int
+			if index, err = verifyIndex(indexTerm, indexList, unboxedValue.Len()); err == nil {
+				v, err = unboxedValue.At(index)
+			}
 		case string:
 			var index int
 			if index, err = verifyIndex(indexTerm, indexList, len(unboxedValue)); err == nil {
@@ -107,6 +112,11 @@ func evalIndex(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 				sublist := kern.ListType((*unboxedValue)[start:end])
 				v = &sublist
 			}
+		case *kern.LinkedList:
+			var start, end int
+			if start, end, err = verifyRange(indexTerm, indexList, unboxedValue.Len()); err == nil {
+				v = unboxedValue.Sub(start, end)
+			}
 		case string:
 			var start, end int
 			if start, end, err = verifyRange(indexTerm, indexList, len(unboxedValue)); err == nil {

operator-insert.go

@@ -31,6 +31,40 @@ func newAppendTerm(tk *scan.Token) (inst *scan.Term) {
 	}
 }
 
+func prependToList(opTerm *scan.Term, leftValue, rightValue any) (result any, err error) {
+	if list, ok := rightValue.(*kern.ListType); ok {
+		var it kern.Iterator
+		if it, ok = leftValue.(kern.Iterator); !ok {
+			it = NewFormalIterator(leftValue)
+		}
+
+		ls := kern.NewLinkedList()
+		ls.SeqPushBack(it)
+
+		newList := kern.ListType(nil)
+		if newSize := len(*list) + int(ls.Len()); newSize > cap(*list) {
+			newList = make([]any, 0, newSize)
+			for node := ls.FirstNode(); node != nil; node = node.Next() {
+				newList = append(newList, node.Data())
+			}
+		}
+		for _, item := range *list {
+			newList = append(newList, item)
+		}
+		result = &newList
+	} else if list, ok := rightValue.(*kern.LinkedList); ok {
+		var it kern.Iterator
+		if it, ok = leftValue.(kern.Iterator); !ok {
+			it = NewFormalIterator(leftValue)
+		}
+
+		result = list.SeqPushBack(it)
+	} else {
+		err = opTerm.ErrIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
 func evalPrepend(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	var leftValue, rightValue any
 
@@ -38,13 +72,38 @@ func evalPrepend(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		return
 	}
 
-	if kern.IsList(rightValue) {
-		list, _ := rightValue.(*kern.ListType)
-		newList := append(kern.ListType{leftValue}, *list...)
-		v = &newList
-		if opTerm.Children[1].Symbol() == scan.SymVariable {
-			ctx.UnsafeSetVar(opTerm.Children[1].Source(), v)
+	v, err = prependToList(opTerm, leftValue, rightValue)
+	return
+}
+
+func appendToList(opTerm *scan.Term, leftValue, rightValue any) (result any, err error) {
+	if list, ok := leftValue.(*kern.ListType); ok {
+		var it kern.Iterator
+		if it, ok = rightValue.(kern.Iterator); !ok {
+			it = NewFormalIterator(rightValue)
 		}
+
+		ls := kern.NewLinkedList()
+		ls.SeqPushBack(it)
+
+		newList := *list
+		if newSize := len(*list) + int(ls.Len()); newSize > cap(*list) {
+			newList = make([]any, 0, newSize)
+			for _, item := range *list {
+				newList = append(newList, item)
+			}
+		}
+		for node := ls.FirstNode(); node != nil; node = node.Next() {
+			newList = append(newList, node.Data())
+		}
+		result = &newList
+	} else if list, ok := leftValue.(*kern.LinkedList); ok {
+		var it kern.Iterator
+		if it, ok = rightValue.(kern.Iterator); !ok {
+			it = NewFormalIterator(rightValue)
+		}
+
+		result = list.SeqPushBack(it)
 	} else {
 		err = opTerm.ErrIncompatibleTypes(leftValue, rightValue)
 	}
@@ -58,16 +117,8 @@ func evalAppend(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		return
 	}
 
-	if kern.IsList(leftValue) {
-		list, _ := leftValue.(*kern.ListType)
-		newList := append(*list, rightValue)
-		v = &newList
-		if opTerm.Children[0].Symbol() == scan.SymVariable {
-			ctx.UnsafeSetVar(opTerm.Children[0].Source(), v)
-		}
-	} else {
-		err = opTerm.ErrIncompatibleTypes(leftValue, rightValue)
-	}
+	v, err = appendToList(opTerm, leftValue, rightValue)
+
 	return
 }
 

operator-join.go

@@ -1,73 +0,0 @@
-// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-join.go
-package expr
-
-import (
-	"fmt"
-	"io"
-
-	"git.portale-stac.it/go-pkg/expr/kern"
-	"git.portale-stac.it/go-pkg/expr/scan"
-)
-
-//-------- join term
-
-func newJoinTerm(tk *scan.Token) (inst *scan.Term) {
-	return &scan.Term{
-		Tk:       *tk,
-		Children: make([]*scan.Term, 0, 2),
-		Position: scan.PosInfix,
-		Priority: scan.PriIterOp,
-		EvalFunc: evalJoin,
-	}
-}
-
-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
-	}
-
-	if leftValue, err = opTerm.Children[0].Compute(ctx); err != nil {
-		return
-	}
-
-	if rightValue, err = opTerm.Children[1].Compute(ctx); err != nil {
-		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} {
-		for item, err = it.Next(); err == nil; item, err = it.Next() {
-			values.AppendItem(item)
-		}
-	}
-	if err == io.EOF {
-		err = nil
-	}
-	v = values
-	return
-}
-
-// init
-func init() {
-	scan.RegisterTermConstructor(scan.SymKwJoin, newJoinTerm)
-}

operator-length.go

@@ -37,6 +37,8 @@ func evalLength(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	} else if kern.IsDict(childValue) {
 		m, _ := childValue.(*kern.DictType)
 		v = int64(len(*m))
+	} else if lls, ok := childValue.(*kern.LinkedList); ok {
+		v = int64(lls.Len())
 	} else if it, ok := childValue.(kern.Iterator); ok {
 		v = int64(it.Count())
 		// if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(CountName) {

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()
-	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
 }
 

operator-shift.go

@@ -39,7 +39,9 @@ func evalRightShift(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error)
 		return
 	}
 
-	v, err = bitRightShift(opTerm, leftValue, rightValue)
+	if v, err = bitRightShift(opTerm, leftValue, rightValue); err != nil {
+		v, err = prependToList(opTerm, leftValue, rightValue)
+	}
 	return
 }
 
@@ -71,7 +73,9 @@ func evalLeftShift(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 		return
 	}
 
-	v, err = bitLeftShift(opTerm, leftValue, rightValue)
+	if v, err = bitLeftShift(opTerm, leftValue, rightValue); err != nil {
+		v, err = appendToList(opTerm, leftValue, rightValue)
+	}
 	return
 }
 

parser.go

@@ -6,6 +6,8 @@ package expr
 
 import (
 	"errors"
+	"fmt"
+	"slices"
 
 	"git.portale-stac.it/go-pkg/expr/scan"
 	"golang.org/x/exp/constraints"
@@ -163,16 +165,16 @@ func paramAlreadyDefined(args []*scan.Term, param *scan.Term) (position int) {
 	return
 }
 
-func (parser *parser) parseList(scanner *scan.Scanner, ctx parserContext) (listTerm *scan.Term, err error) {
+func (parser *parser) parseList(scanner *scan.Scanner, ctx parserContext, termSym scan.Symbol) (listTerm *scan.Term, err error) {
 	r, c := scanner.LastPos()
 	args := make([]*scan.Term, 0)
 	lastSym := scan.SymUnknown
 	itemExpected := false
 	itemCtx := remFlags(ctx, allowIndex)
-	for lastSym != scan.SymClosedSquare && lastSym != scan.SymEos {
+	for lastSym != termSym && lastSym != scan.SymEos {
 		zeroRequired := scanner.Current().Sym == scan.SymColon
 		var itemTree *scan.Ast
-		if itemTree, err = parser.parseItem(scanner, itemCtx, scan.SymComma, scan.SymClosedSquare); err == nil {
+		if itemTree, err = parser.parseItem(scanner, itemCtx, scan.SymComma, termSym); err == nil {
 			root := itemTree.Root()
 			if root != nil {
 				if hasFlag(ctx, allowIndex) && root.Symbol() == scan.SymColon {
@@ -211,10 +213,14 @@ func (parser *parser) parseList(scanner *scan.Scanner, ctx parserContext) (listT
 		}
 	}
 	if err == nil {
-		if lastSym != scan.SymClosedSquare {
+		if lastSym != termSym {
 			err = scanner.Previous().ErrorExpectedGot("]")
-		} else {
+		} else if termSym == scan.SymClosedSquare {
 			listTerm = newListTerm(r, c, args)
+		} else if termSym == scan.SymGreaterClosedSquare {
+			listTerm = newLinkedListTerm(r, c, args)
+		} else {
+			err = fmt.Errorf("[%d:%d] unknown list type", r, c)
 		}
 	}
 	return
@@ -251,24 +257,41 @@ func (parser *parser) parseIterDef(scanner *scan.Scanner, ctx parserContext) (su
 	return
 }
 
-func (parser *parser) parseDictKey(scanner *scan.Scanner) (key any, err error) {
-	tk := parser.Next(scanner)
-	if tk.Sym == scan.SymError {
-		err = tk.Error()
-		return
-	}
-	if tk.Sym == scan.SymClosedBrace || tk.Sym == scan.SymEos {
-		return
-	}
-	if tk.Sym == scan.SymInteger || tk.Sym == scan.SymString {
-		tkSep := parser.Next(scanner)
-		if tkSep.Sym != scan.SymColon {
+// func (parser *parser) parseDictKey(scanner *scan.Scanner) (key any, err error) {
+// 	tk := parser.Next(scanner)
+// 	if tk.Sym == scan.SymError {
+// 		err = tk.Error()
+// 		return
+// 	}
+// 	if tk.Sym == scan.SymClosedBrace || tk.Sym == scan.SymEos {
+// 		return
+// 	}
+// 	if tk.Sym == scan.SymInteger || tk.Sym == scan.SymString || tk.Sym == scan.SymIdentifier {
+// 		tkSep := parser.Next(scanner)
+// 		if tkSep.Sym != scan.SymColon {
+// 			err = tkSep.ErrorExpectedGot(":")
+// 		} else {
+// 			key = tk.Value
+// 		}
+// 	} else {
+// 		err = tk.ErrorExpectedGot("dictionary-key or }")
+// 	}
+// 	return
+// }
+
+func (parser *parser) parseDictKey(scanner *scan.Scanner) (key *scan.Term, err error) {
+	var keyTree *scan.Ast
+	if keyTree, err = parser.parseItem(scanner, parserNoFlags, scan.SymColon, scan.SymClosedBrace); err == nil {
+		key = keyTree.Root()
+		tkSep := scanner.Previous()
+		sym := tkSep.Sym
+		if sym == scan.SymClosedBrace || sym == scan.SymEos {
+			if key != nil {
+				err = tkSep.ErrorExpectedGot(":")
+			}
+		} else if sym != scan.SymColon {
 			err = tkSep.ErrorExpectedGot(":")
-		} else {
-			key = tk.Value
 		}
-	} else {
-		err = tk.ErrorExpectedGot("dictionary-key or }")
 	}
 	return
 }
@@ -278,11 +301,11 @@ func (parser *parser) parseDictionary(scanner *scan.Scanner, ctx parserContext)
 	lastSym := scan.SymUnknown
 	itemExpected := false
 	for lastSym != scan.SymClosedBrace && lastSym != scan.SymEos {
-		var subTree *scan.Ast
+		var valueTree *scan.Ast
 		var key any
 		if key, err = parser.parseDictKey(scanner); err != nil {
 			break
-		} else if key == nil {
+		} else if key.(*scan.Term) == nil {
 			tk := scanner.Previous()
 			lastSym = tk.Sym
 			if itemExpected {
@@ -290,9 +313,9 @@ func (parser *parser) parseDictionary(scanner *scan.Scanner, ctx parserContext)
 			}
 			break
 		}
-		if subTree, err = parser.parseItem(scanner, ctx, scan.SymComma, scan.SymClosedBrace); err == nil {
-			if subTree.Root() != nil {
-				args[key] = subTree.Root()
+		if valueTree, err = parser.parseItem(scanner, ctx, scan.SymComma, scan.SymClosedBrace); err == nil {
+			if valueTree.Root() != nil {
+				args[key] = valueTree.Root()
 			} else /*if key != nil*/ {
 				prev := scanner.Previous()
 				err = prev.ErrorExpectedGot("dictionary-value")
@@ -326,7 +349,7 @@ func (parser *parser) parseSelectorCase(scanner *scan.Scanner, ctx parserContext
 			err = tk.Errorf("case list in default clause")
 			return
 		}
-		if filterList, err = parser.parseList(scanner, remFlags(ctx, allowIndex)); err != nil {
+		if filterList, err = parser.parseList(scanner, remFlags(ctx, allowIndex), scan.SymClosedSquare); err != nil {
 			return
 		}
 		tk = parser.Next(scanner)
@@ -401,7 +424,8 @@ func couldBeACollection(t *scan.Term) bool {
 	if t != nil {
 		sym = t.Symbol()
 	}
-	return sym == scan.SymList || sym == scan.SymString || sym == scan.SymDict || sym == scan.SymExpression || sym == scan.SymVariable
+	// return sym == scan.SymList || sym == scan.SymString || sym == scan.SymDict || sym == scan.SymExpression || sym == scan.SymVariable
+	return slices.Contains([]scan.Symbol{scan.SymList, scan.SymLinkedList, scan.SymString, scan.SymDict, scan.SymExpression, scan.SymVariable, scan.SymIndex}, sym)
 }
 
 func listSubTree(tree *scan.Ast, listTerm *scan.Term, allowIndeces bool) (root *scan.Term, err error) {
@@ -444,7 +468,7 @@ func (parser *parser) parseGeneral(scanner *scan.Scanner, ctx parserContext, ter
 	tree = scan.NewAst()
 	firstToken := true
 	// lastSym := SymUnknown
-	for tk = parser.Next(scanner); err == nil && tk != nil && !tk.IsTerm(termSymbols); /*&& !areSymbolsOutOfCtx(tk, selectorTerm, SymColon, SymDoubleColon)*/ tk = parser.Next(scanner) {
+	for tk = parser.Next(scanner); err == nil && tk != nil && !tk.IsTerm(termSymbols); tk = parser.Next(scanner) {
 		// if tk.Sym == SymComment {
 		// 	continue
 		// }
@@ -457,7 +481,7 @@ func (parser *parser) parseGeneral(scanner *scan.Scanner, ctx parserContext, ter
 				selectorTerm = nil
 				continue
 			} else {
-				err = tk.Errorf(`unexpected token %q, expected ",", "]", or ")"`, tk.Source())
+				err = tk.ErrorExpectedOneOfGot(termSymbols...)
 				break
 			}
 		}
@@ -489,7 +513,13 @@ func (parser *parser) parseGeneral(scanner *scan.Scanner, ctx parserContext, ter
 		case scan.SymOpenSquare:
 			var listTerm *scan.Term
 			newCtx := addFlagsCond(addFlags(ctx, squareContext), allowIndex, couldBeACollection(currentTerm))
-			if listTerm, err = parser.parseList(scanner, newCtx); err == nil {
+			if listTerm, err = parser.parseList(scanner, newCtx, scan.SymClosedSquare); err == nil {
+				currentTerm, err = listSubTree(tree, listTerm, hasFlag(newCtx, allowIndex))
+			}
+		case scan.SymOpenSquareLess:
+			var listTerm *scan.Term
+			newCtx := addFlagsCond(addFlags(ctx, listContext), allowIndex, false)
+			if listTerm, err = parser.parseList(scanner, newCtx, scan.SymGreaterClosedSquare); err == nil {
 				currentTerm, err = listSubTree(tree, listTerm, hasFlag(newCtx, allowIndex))
 			}
 		case scan.SymOpenBrace:

scan/ast.go

@@ -98,7 +98,7 @@ func (ast *Ast) insert(tree, node *Term) (root *Term, err error) {
 		root = node
 		tree.SetParent(node)
 	} else {
-		err = node.Errorf("two adjacent operators: %q and %q", tree, node)
+		err = node.Errorf("two adjacent operators: %q and %q", tree, node.Source())
 	}
 	return
 }

scan/scanner.go

@@ -192,6 +192,8 @@ func (scanner *Scanner) fetchNextToken() (tk *Token) {
 		case ':':
 			if next, _ := scanner.peek(); next == ':' {
 				tk = scanner.moveOn(SymDoubleColon, ch, next)
+			} else if next == '=' {
+				tk = scanner.moveOn(SymColonEqual, ch, next)
 			} else {
 				tk = scanner.MakeToken(SymColon, ch)
 			}
@@ -313,6 +315,8 @@ func (scanner *Scanner) fetchNextToken() (tk *Token) {
 				} else {
 					tk = scanner.accept(SymDoubleGreater, ch, next)
 				}
+			} else if next == ']' {
+				tk = scanner.moveOn(SymGreaterClosedSquare, ch, next)
 			} else {
 				tk = scanner.MakeToken(SymGreater, ch)
 			}
@@ -342,7 +346,11 @@ func (scanner *Scanner) fetchNextToken() (tk *Token) {
 		case ')':
 			tk = scanner.MakeToken(SymClosedRound, ch)
 		case '[':
-			tk = scanner.MakeToken(SymOpenSquare, ch)
+			if next, _ := scanner.peek(); next == '<' {
+				tk = scanner.moveOn(SymOpenSquareLess, ch, next)
+			} else {
+				tk = scanner.MakeToken(SymOpenSquare, ch)
+			}
 		case ']':
 			tk = scanner.MakeToken(SymClosedSquare, ch)
 		case '{':

scan/symbol-map.go

@@ -32,79 +32,82 @@ type symbolSpec struct {
 func init() {
 
 	symbolMap = map[Symbol]symbolSpec{
-		SymUnknown:            {"<unknown>", SymClassOther, PosLeaf},  //  -1: Unknown symbol
-		SymNone:               {"<null>", SymClassOther, PosLeaf},     //   0: Null value for variable of type symbol
-		SymError:              {"<error>", SymClassOther, PosLeaf},    //   1: Error reading from stream
-		SymEos:                {"<eos>", SymClassOther, PosLeaf},      //   2: End of stream
-		SymMinus:              {"-", SymClassOperator, PosInfix},      //   3: '-'
-		SymMinusEqual:         {"-=", SymClassOperator, PosInfix},     //   4: '-='
-		SymDoubleMinus:        {"--", SymClassOperator, PosPostfix},   //   5: '--'
-		SymPlus:               {"+", SymClassOperator, PosInfix},      //   6: '+'
-		SymPlusEqual:          {"+=", SymClassOperator, PosInfix},     //   7: '+='
-		SymDoublePlus:         {"++", SymClassOperator, PosPostfix},   //   8: '++'
-		SymStar:               {"*", SymClassOperator, PosInfix},      //   9: '*'
-		SymDoubleStar:         {"**", SymClassOperator, PosInfix},     //  10: '**'
-		SymSlash:              {"/", SymClassOperator, PosInfix},      //  11: '/'
-		SymBackSlash:          {"\\", SymClassOperator, PosLeaf},      //  12: '\'
-		SymVertBar:            {"|", SymClassOperator, PosInfix},      //  13: '|'
-		SymDoubleVertBar:      {"||", SymClassOperator, PosInfix},     //  14: '||'
-		SymComma:              {",", SymClassOperator, PosInfix},      //  15: ','
-		SymColon:              {":", SymClassOperator, PosInfix},      //  16: ':'
-		SymSemiColon:          {";", SymClassOperator, PosInfix},      //  17: ';'
-		SymDot:                {".", SymClassOperator, PosInfix},      //  18: '.'
-		SymDotSlash:           {"./", SymClassOperator, PosInfix},     //  19: './'
-		SymQuote:              {"'", SymClassDelimiter, PosLeaf},      //  20: '\''
-		SymDoubleQuote:        {"\"", SymClassDelimiter, PosLeaf},     //  21: '"'
-		SymBackTick:           {"`", SymClassDelimiter, PosLeaf},      //  22: '`'
-		SymExclamation:        {"!", SymClassOperator, PosPostfix},    //  23: '!'
-		SymQuestion:           {"?", SymClassOperator, PosInfix},      //  24: '?'
-		SymAmpersand:          {"&", SymClassOperator, PosInfix},      //  25: '&'
-		SymDoubleAmpersand:    {"&&", SymClassOperator, PosInfix},     //  26: '&&'
-		SymPercent:            {"%", SymClassOperator, PosInfix},      //  27: '%'
-		SymAt:                 {"@", SymClassOperator, PosPrefix},     //  28: '@'
-		SymUndescore:          {"_", SymClassIdentifier, PosLeaf},     //  29: '_'
-		SymEqual:              {"=", SymClassOperator, PosInfix},      //  30: '='
-		SymDoubleEqual:        {"==", SymClassOperator, PosInfix},     //  31: '=='
-		SymLess:               {"<", SymClassOperator, PosInfix},      //  32: '<'
-		SymLessOrEqual:        {"<=", SymClassOperator, PosInfix},     //  33: '<='
-		SymGreater:            {">", SymClassOperator, PosInfix},      //  34: '>'
-		SymGreaterOrEqual:     {">=", SymClassOperator, PosInfix},     //  35: '>='
-		SymLessGreater:        {"<>", SymClassOperator, PosInfix},     //  36: '<>'
-		SymNotEqual:           {"!=", SymClassOperator, PosInfix},     //  37: '!='
-		SymDollar:             {"$", SymClassOperator, PosPrefix},     //  38: '$'
-		SymHash:               {"#", SymClassOperator, PosPrefix},     //  39: '#'
-		SymOpenRound:          {"(", SymClassParenthesis, PosPrefix},  //  40: '('
-		SymClosedRound:        {")", SymClassParenthesis, PosPostfix}, //  41: ')'
-		SymOpenSquare:         {"[", SymClassParenthesis, PosPrefix},  //  42: '['
-		SymClosedSquare:       {"]", SymClassParenthesis, PosPostfix}, //  43: ']'
-		SymOpenBrace:          {"{", SymClassParenthesis, PosPrefix},  //  44: '{'
-		SymClosedBrace:        {"}", SymClassParenthesis, PosPostfix}, //  45: '}'
-		SymTilde:              {"~", SymClassOperator, PosPrefix},     //  46: '~'
-		SymDoubleQuestion:     {"??", SymClassOperator, PosInfix},     //  47: '??'
-		SymQuestionEqual:      {"?=", SymClassOperator, PosInfix},     //  48: '?='
-		SymQuestionExclam:     {"?!", SymClassOperator, PosInfix},     //  49: '?!'
-		SymDoubleAt:           {"@@", SymClassCommand, PosLeaf},       //  50: '@@'
-		SymDoubleColon:        {"::", SymClassOperator, PosInfix},     //  51: '::'
-		SymDoubleGreater:      {">>", SymClassOperator, PosInfix},     //  52: '>>'
-		SymDoubleLess:         {"<<", SymClassOperator, PosInfix},     //  53: '<<'
-		SymCaret:              {"^", SymClassOperator, PosInfix},      //  54: '^'
-		SymDollarRound:        {"$(", SymClassOperator, PosPrefix},    //  55: '$('
-		SymOpenClosedRound:    {"()", SymClassOperator, PosPostfix},   //  56: '()'
-		SymDoubleDollar:       {"$$", SymClassCommand, PosLeaf},       //  57: '$$'
-		SymDoubleDot:          {"..", SymClassOperator, PosInfix},     //  58: '..'
-		SymTripleDot:          {"...", SymClassOperator, PosPostfix},  //  59: '...'
-		SymStarEqual:          {"*=", SymClassOperator, PosInfix},     //  60: '*='
-		SymSlashEqual:         {"/=", SymClassOperator, PosInfix},     //  61: '/='
-		SymPercEqual:          {"%=", SymClassOperator, PosInfix},     //  62: '%='
-		SymDoubleLessEqual:    {"<<=", SymClassOperator, PosInfix},    //  63: '<<='
-		SymDoubleGreaterEqual: {">>=", SymClassOperator, PosInfix},    //  64: '>>='
-		SymAmpersandEqual:     {"&=", SymClassOperator, PosInfix},     //  65: '&='
-		SymVertBarEqual:       {"|=", SymClassOperator, PosInfix},     //  65: '|='
-		SymCaretEqual:         {"^=", SymClassOperator, PosInfix},     //  66: '^='
-		SymPlusGreater:        {"+>", SymClassOperator, PosInfix},     //  67: '+>'
-		SymLessPlus:           {"<+", SymClassOperator, PosInfix},     //  68: '<+'
-		SymPreInc:             {"++", SymClassOperator, PosPrefix},    //    : '++'
-		SymPreDec:             {"--", SymClassOperator, PosPrefix},    //    : '--'
+		SymUnknown:             {"<unknown>", SymClassOther, PosLeaf},  //  -1: Unknown symbol
+		SymNone:                {"<null>", SymClassOther, PosLeaf},     //   0: Null value for variable of type symbol
+		SymError:               {"<error>", SymClassOther, PosLeaf},    //   1: Error reading from stream
+		SymEos:                 {"<eos>", SymClassOther, PosLeaf},      //   2: End of stream
+		SymMinus:               {"-", SymClassOperator, PosInfix},      //   3: '-'
+		SymMinusEqual:          {"-=", SymClassOperator, PosInfix},     //   4: '-='
+		SymDoubleMinus:         {"--", SymClassOperator, PosPostfix},   //   5: '--'
+		SymPlus:                {"+", SymClassOperator, PosInfix},      //   6: '+'
+		SymPlusEqual:           {"+=", SymClassOperator, PosInfix},     //   7: '+='
+		SymDoublePlus:          {"++", SymClassOperator, PosPostfix},   //   8: '++'
+		SymStar:                {"*", SymClassOperator, PosInfix},      //   9: '*'
+		SymDoubleStar:          {"**", SymClassOperator, PosInfix},     //  10: '**'
+		SymSlash:               {"/", SymClassOperator, PosInfix},      //  11: '/'
+		SymBackSlash:           {"\\", SymClassOperator, PosLeaf},      //  12: '\'
+		SymVertBar:             {"|", SymClassOperator, PosInfix},      //  13: '|'
+		SymDoubleVertBar:       {"||", SymClassOperator, PosInfix},     //  14: '||'
+		SymComma:               {",", SymClassOperator, PosInfix},      //  15: ','
+		SymColon:               {":", SymClassOperator, PosInfix},      //  16: ':'
+		SymSemiColon:           {";", SymClassOperator, PosInfix},      //  17: ';'
+		SymDot:                 {".", SymClassOperator, PosInfix},      //  18: '.'
+		SymDotSlash:            {"./", SymClassOperator, PosInfix},     //  19: './'
+		SymQuote:               {"'", SymClassDelimiter, PosLeaf},      //  20: '\''
+		SymDoubleQuote:         {"\"", SymClassDelimiter, PosLeaf},     //  21: '"'
+		SymBackTick:            {"`", SymClassDelimiter, PosLeaf},      //  22: '`'
+		SymExclamation:         {"!", SymClassOperator, PosPostfix},    //  23: '!'
+		SymQuestion:            {"?", SymClassOperator, PosInfix},      //  24: '?'
+		SymAmpersand:           {"&", SymClassOperator, PosInfix},      //  25: '&'
+		SymDoubleAmpersand:     {"&&", SymClassOperator, PosInfix},     //  26: '&&'
+		SymPercent:             {"%", SymClassOperator, PosInfix},      //  27: '%'
+		SymAt:                  {"@", SymClassOperator, PosPrefix},     //  28: '@'
+		SymUndescore:           {"_", SymClassIdentifier, PosLeaf},     //  29: '_'
+		SymEqual:               {"=", SymClassOperator, PosInfix},      //  30: '='
+		SymColonEqual:          {":=", SymClassOperator, PosInfix},     //  31: ':='
+		SymDoubleEqual:         {"==", SymClassOperator, PosInfix},     //  32: '=='
+		SymLess:                {"<", SymClassOperator, PosInfix},      //  33: '<'
+		SymLessOrEqual:         {"<=", SymClassOperator, PosInfix},     //  34: '<='
+		SymGreater:             {">", SymClassOperator, PosInfix},      //  35: '>'
+		SymGreaterOrEqual:      {">=", SymClassOperator, PosInfix},     //  36: '>='
+		SymLessGreater:         {"<>", SymClassOperator, PosInfix},     //  37: '<>'
+		SymNotEqual:            {"!=", SymClassOperator, PosInfix},     //  38: '!='
+		SymDollar:              {"$", SymClassOperator, PosPrefix},     //  39: '$'
+		SymHash:                {"#", SymClassOperator, PosPrefix},     //  40: '#'
+		SymOpenRound:           {"(", SymClassParenthesis, PosPrefix},  //  41: '('
+		SymClosedRound:         {")", SymClassParenthesis, PosPostfix}, //  42: ')'
+		SymOpenSquare:          {"[", SymClassParenthesis, PosPrefix},  //  43: '['
+		SymClosedSquare:        {"]", SymClassParenthesis, PosPostfix}, //  44: ']'
+		SymOpenBrace:           {"{", SymClassParenthesis, PosPrefix},  //  45: '{'
+		SymClosedBrace:         {"}", SymClassParenthesis, PosPostfix}, //  46: '}'
+		SymTilde:               {"~", SymClassOperator, PosPrefix},     //  47: '~'
+		SymDoubleQuestion:      {"??", SymClassOperator, PosInfix},     //  48: '??'
+		SymQuestionEqual:       {"?=", SymClassOperator, PosInfix},     //  49: '?='
+		SymQuestionExclam:      {"?!", SymClassOperator, PosInfix},     //  50: '?!'
+		SymDoubleAt:            {"@@", SymClassCommand, PosLeaf},       //  51: '@@'
+		SymDoubleColon:         {"::", SymClassOperator, PosInfix},     //  52: '::'
+		SymDoubleGreater:       {">>", SymClassOperator, PosInfix},     //  53: '>>'
+		SymDoubleLess:          {"<<", SymClassOperator, PosInfix},     //  54: '<<'
+		SymCaret:               {"^", SymClassOperator, PosInfix},      //  55: '^'
+		SymDollarRound:         {"$(", SymClassOperator, PosPrefix},    //  56: '$('
+		SymOpenClosedRound:     {"()", SymClassOperator, PosPostfix},   //  57: '()'
+		SymDoubleDollar:        {"$$", SymClassCommand, PosLeaf},       //  58: '$$'
+		SymDoubleDot:           {"..", SymClassOperator, PosInfix},     //  59: '..'
+		SymTripleDot:           {"...", SymClassOperator, PosPostfix},  //  60: '...'
+		SymStarEqual:           {"*=", SymClassOperator, PosInfix},     //  61: '*='
+		SymSlashEqual:          {"/=", SymClassOperator, PosInfix},     //  62: '/='
+		SymPercEqual:           {"%=", SymClassOperator, PosInfix},     //  63: '%='
+		SymDoubleLessEqual:     {"<<=", SymClassOperator, PosInfix},    //  64: '<<='
+		SymDoubleGreaterEqual:  {">>=", SymClassOperator, PosInfix},    //  65: '>>='
+		SymAmpersandEqual:      {"&=", SymClassOperator, PosInfix},     //  66: '&='
+		SymVertBarEqual:        {"|=", SymClassOperator, PosInfix},     //  67: '|='
+		SymCaretEqual:          {"^=", SymClassOperator, PosInfix},     //  68: '^='
+		SymPlusGreater:         {"+>", SymClassOperator, PosInfix},     //  69: '+>'
+		SymLessPlus:            {"<+", SymClassOperator, PosInfix},     //  70: '<+'
+		SymPreInc:              {"++", SymClassOperator, PosPrefix},    //  71: '++'
+		SymPreDec:              {"--", SymClassOperator, PosPrefix},    //  72: '--'
+		SymOpenSquareLess:      {"[<", SymClassOperator, PosPrefix},    //  97: '[<'
+		SymGreaterClosedSquare: {">]", SymClassOperator, PosPostfix},   //  98: '>]'
 		// SymChangeSign
 		// SymUnchangeSign
 		// SymIdentifier
@@ -122,6 +125,7 @@ func init() {
 		// SymFuncCall
 		// SymFuncDef
 		// SymList
+		// SymLinkedList
 		// SymDict
 		// SymIndex
 		// SymExpression
@@ -138,6 +142,7 @@ func init() {
 		SymKwMap:     {"map", SymClassOperator, PosInfix},
 		SymKwFilter:  {"filter", SymClassOperator, PosInfix},
 		SymKwDigest:  {"digest", SymClassOperator, PosInfix},
+		SymKwCat:     {"cat", SymClassOperator, PosInfix},
 		SymKwJoin:    {"join", SymClassOperator, PosInfix},
 		SymKwGroupBy: {"groupby", SymClassOperator, PosInfix},
 		SymKwFunc:    {"func(", SymClassDeclaration, PosPrefix},
@@ -183,25 +188,6 @@ func StringEndsWithOperator(s string) bool {
 	return endingOperator(s) != SymNone
 }
 
-// func endingOperator(s string) (sym Symbol) {
-// 	var matchLength = 0
-// 	sym = SymNone
-// 	lower := strings.TrimRight(strings.ToLower(s), " \t")
-// 	for symbol, spec := range symbolMap {
-// 		if strings.HasSuffix(lower, spec.repr) {
-// 			if len(spec.repr) > matchLength {
-// 				matchLength = len(spec.repr)
-// 				if spec.kind == symClassOperator && (spec.opType == PosInfix || spec.opType == PosPrefix) {
-// 					sym = symbol
-// 				} else {
-// 					sym = SymNone
-// 				}
-// 			}
-// 		}
-// 	}
-// 	return
-// }
-
 func endingOperator(s string) (sym Symbol) {
 	var matchLength = 0
 	var repr string

scan/symbol.go

@@ -1,109 +1,113 @@
 // Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// Symbol.go
+// symbol.go
 package scan
 
 type Symbol int16
 
 const (
-	SymUnknown            Symbol = iota - 1 //  -1: Unknown symbol
-	SymNone                                 //   0: Null value for variable of type symbol
-	SymError                                //   1: Error reading from stream
-	SymEos                                  //   2: End of stream
-	SymMinus                                //   3: '-'
-	SymMinusEqual                           //   4: '-='
-	SymDoubleMinus                          //   5: '--'
-	SymPlus                                 //   6: '+'
-	SymPlusEqual                            //   7: '+='
-	SymDoublePlus                           //   8: '++'
-	SymStar                                 //   9: '*'
-	SymDoubleStar                           //  10: '**'
-	SymSlash                                //  11: '/'
-	SymBackSlash                            //  12: '\'
-	SymVertBar                              //  13: '|'
-	SymDoubleVertBar                        //  14: '||'
-	SymComma                                //  15: ','
-	SymColon                                //  16: ':'
-	SymSemiColon                            //  17: ';'
-	SymDot                                  //  18: '.'
-	SymDotSlash                             //  19: './'
-	SymQuote                                //  20: '\''
-	SymDoubleQuote                          //  21: '"'
-	SymBackTick                             //  22: '`'
-	SymExclamation                          //  23: '!'
-	SymQuestion                             //  24: '?'
-	SymAmpersand                            //  25: '&'
-	SymDoubleAmpersand                      //  26: '&&'
-	SymPercent                              //  27: '%'
-	SymAt                                   //  28: '@'
-	SymUndescore                            //  29: '_'
-	SymEqual                                //  30: '='
-	SymDoubleEqual                          //  31: '=='
-	SymLess                                 //  32: '<'
-	SymLessOrEqual                          //  33: '<='
-	SymGreater                              //  34: '>'
-	SymGreaterOrEqual                       //  35: '>='
-	SymLessGreater                          //  36: '<>'
-	SymNotEqual                             //  37: '!='
-	SymDollar                               //  38: '$'
-	SymHash                                 //  39: '#'
-	SymOpenRound                            //  40: '('
-	SymClosedRound                          //  41: ')'
-	SymOpenSquare                           //  42: '['
-	SymClosedSquare                         //  43: ']'
-	SymOpenBrace                            //  44: '{'
-	SymClosedBrace                          //  45: '}'
-	SymTilde                                //  46: '~'
-	SymDoubleQuestion                       //  47: '??'
-	SymQuestionEqual                        //  48: '?='
-	SymQuestionExclam                       //  49: '?!'
-	SymDoubleAt                             //  50: '@@'
-	SymDoubleColon                          //  51: '::'
-	SymDoubleGreater                        //  52: '>>'
-	SymDoubleLess                           //  53: '<<'
-	SymCaret                                //  54: '^'
-	SymDollarRound                          //  55: '$('
-	SymOpenClosedRound                      //  56: '()'
-	SymDoubleDollar                         //  57: '$$'
-	SymDoubleDot                            //  58: '..'
-	SymTripleDot                            //  59: '...'
-	SymStarEqual                            //  60: '*='
-	SymSlashEqual                           //  61: '/='
-	SymPercEqual                            //  62: '%='
-	SymDoubleLessEqual                      //  63: '<<='
-	SymDoubleGreaterEqual                   //  64: '>>='
-	SymAmpersandEqual                       //  65: '&='
-	SymVertBarEqual                         //  65: '|='
-	SymCaretEqual                           //  66: '^='
-	SymPlusGreater                          //  67: '+>'
-	SymLessPlus                             //  68: '<+'
-	SymChangeSign
-	SymUnchangeSign
-	SymDereference
-	SymPreInc
-	SymPreDec
-	SymIdentifier
-	SymBool
-	SymInteger
-	SymVariable
-	SymFloat
-	SymFraction
-	SymString
-	SymIterator
-	SymOr
-	SymAnd
-	SymNot
-	SymComment
-	SymFuncCall
-	SymFuncDef
-	SymList
-	SymDict
-	SymIndex
-	SymRange // [index : index]
-	SymExpression
-	SymSelector     // <selector> ::= <expr> "?" <selector-case> {":" <selector-case>} ["::" <default-selector-case>]
-	SymSelectorCase // <selector-case> ::= [<list>] "{" <multi-expr> "}"
+	SymUnknown             Symbol = iota - 1 //  -1: Unknown symbol
+	SymNone                                  //   0: Null value for variable of type symbol
+	SymError                                 //   1: Error reading from stream
+	SymEos                                   //   2: End of stream
+	SymMinus                                 //   3: '-'
+	SymMinusEqual                            //   4: '-='
+	SymDoubleMinus                           //   5: '--'
+	SymPlus                                  //   6: '+'
+	SymPlusEqual                             //   7: '+='
+	SymDoublePlus                            //   8: '++'
+	SymStar                                  //   9: '*'
+	SymDoubleStar                            //  10: '**'
+	SymSlash                                 //  11: '/'
+	SymBackSlash                             //  12: '\'
+	SymVertBar                               //  13: '|'
+	SymDoubleVertBar                         //  14: '||'
+	SymComma                                 //  15: ','
+	SymColon                                 //  16: ':'
+	SymSemiColon                             //  17: ';'
+	SymDot                                   //  18: '.'
+	SymDotSlash                              //  19: './'
+	SymQuote                                 //  20: '\''
+	SymDoubleQuote                           //  21: '"'
+	SymBackTick                              //  22: '`'
+	SymExclamation                           //  23: '!'
+	SymQuestion                              //  24: '?'
+	SymAmpersand                             //  25: '&'
+	SymDoubleAmpersand                       //  26: '&&'
+	SymPercent                               //  27: '%'
+	SymAt                                    //  28: '@'
+	SymUndescore                             //  29: '_'
+	SymEqual                                 //  30: '='
+	SymColonEqual                            //  31: ':='
+	SymDoubleEqual                           //  32: '=='
+	SymLess                                  //  33: '<'
+	SymLessOrEqual                           //  34: '<='
+	SymGreater                               //  35: '>'
+	SymGreaterOrEqual                        //  36: '>='
+	SymLessGreater                           //  37: '<>'
+	SymNotEqual                              //  38: '!='
+	SymDollar                                //  39: '$'
+	SymHash                                  //  40: '#'
+	SymOpenRound                             //  41: '('
+	SymClosedRound                           //  42: ')'
+	SymOpenSquare                            //  43: '['
+	SymClosedSquare                          //  44: ']'
+	SymOpenBrace                             //  45: '{'
+	SymClosedBrace                           //  46: '}'
+	SymTilde                                 //  47: '~'
+	SymDoubleQuestion                        //  48: '??'
+	SymQuestionEqual                         //  49: '?='
+	SymQuestionExclam                        //  50: '?!'
+	SymDoubleAt                              //  51: '@@'
+	SymDoubleColon                           //  52: '::'
+	SymDoubleGreater                         //  53: '>>'
+	SymDoubleLess                            //  54: '<<'
+	SymCaret                                 //  55: '^'
+	SymDollarRound                           //  56: '$('
+	SymOpenClosedRound                       //  57: '()'
+	SymDoubleDollar                          //  58: '$$'
+	SymDoubleDot                             //  59: '..'
+	SymTripleDot                             //  60: '...'
+	SymStarEqual                             //  61: '*='
+	SymSlashEqual                            //  62: '/='
+	SymPercEqual                             //  63: '%='
+	SymDoubleLessEqual                       //  64: '<<='
+	SymDoubleGreaterEqual                    //  65: '>>='
+	SymAmpersandEqual                        //  66: '&='
+	SymVertBarEqual                          //  67: '|='
+	SymCaretEqual                            //  68: '^='
+	SymPlusGreater                           //  69: '+>'
+	SymLessPlus                              //  70: '<+'
+	SymChangeSign                            //  71: '-'
+	SymUnchangeSign                          //  72: '+''
+	SymDereference                           //  73: '*'
+	SymPreInc                                //  74: '++'
+	SymPreDec                                //  75: '--'
+	SymIdentifier                            //  76: identifier
+	SymBool                                  //  77: boolean
+	SymInteger                               //  78: integer
+	SymVariable                              //  79: variable
+	SymFloat                                 //  80: float
+	SymFraction                              //  81: fraction
+	SymString                                //  82: string
+	SymIterator                              //  83: iterator
+	SymOr                                    //  84: 'or'
+	SymAnd                                   //  85: 'and'
+	SymNot                                   //  86: 'not'
+	SymComment                               //  87: comment
+	SymFuncCall                              //  88: function call
+	SymFuncDef                               //  89: function definition
+	SymList                                  //  90: list
+	SymDict                                  //  91: dict
+	SymIndex                                 //  92: index
+	SymRange                                 //  93: range [index : index]
+	SymExpression                            //  94: expression
+	SymSelector                              //  95: selector <selector> ::= <expr> "?" <selector-case> {":" <selector-case>} ["::" <default-selector-case>]
+	SymSelectorCase                          //  96: <selector-case> ::= [<list>] "{" <multi-expr> "}"
+	SymOpenSquareLess                        //  97: '[<'
+	SymGreaterClosedSquare                   //  98: '>]'
+	SymLinkedList                            //  99: linked-list
 	// SymOpenComment                       //   0: '/*'
 	// SymClosedComment                     //   0: '*/'
 	// SymOneLineComment                    //   0: '//'
@@ -122,6 +126,7 @@ const (
 	SymKwMap
 	SymKwFilter
 	SymKwDigest
+	SymKwCat
 	SymKwGroupBy
 	SymKwJoin
 	SymKwNil
@@ -141,6 +146,7 @@ func init() {
 		"IN":      SymKwIn,
 		"INCLUDE": SymKwInclude,
 		"MAP":     SymKwMap,
+		"CAT":     SymKwCat,
 		"FILTER":  SymKwFilter,
 		"NOT":     SymKwNot,
 		"OR":      SymKwOr,

scan/term.go

@@ -15,9 +15,9 @@ type TermPriority uint32
 const (
 	PriNone TermPriority = iota
 	PriRange
-	PriIterOp // map, filter, digest, etc
 	PriBut
 	PriAssign
+	PriIterOp // map, filter, digest, etc
 	PriInsert
 	PriOr
 	PriAnd

scan/token.go

@@ -136,3 +136,7 @@ func (tk *Token) ErrorExpectedGotStringWithPrefix(prefix, symbol, got string) (e
 	err = fmt.Errorf("[%d:%d] %s %s, got `%s`", tk.row, tk.col, prefix, symbol, got)
 	return
 }
+
+func (tk *Token) ErrorExpectedOneOfGot(expected ...Symbol) (err error) {
+	return tk.ErrorExpectedGotStringWithPrefix("expected one of ", SymListToString(expected, true), SymToString(tk.Sym))
+}

simple-store.go

@@ -6,7 +6,6 @@ package expr
 
 import (
 	"fmt"
-	"slices"
 
 	"git.portale-stac.it/go-pkg/expr/kern"
 	"git.portale-stac.it/go-pkg/expr/util"
@@ -77,48 +76,56 @@ func (ctx *SimpleStore) Clone() kern.ExprContext {
 // 	}
 // }
 
-func (ctx *SimpleStore) ToString(opt kern.FmtOpt) string {
-	dict := ctx.ToDict()
-	return dict.ToString(opt)
-}
-
-func (ctx *SimpleStore) varsToDict(dict *kern.DictType) *kern.DictType {
-	names := ctx.EnumVars(nil)
-	slices.Sort(names)
-	for _, name := range ctx.EnumVars(nil) {
-		value, _ := ctx.GetVar(name)
-		if f, ok := value.(kern.Formatter); ok {
-			(*dict)[name] = f.ToString(0)
-		} else if _, ok = value.(kern.Functor); ok {
-			(*dict)[name] = "func(){}"
-		} else {
-			(*dict)[name] = fmt.Sprintf("%v", value)
-		}
-	}
-	return dict
-}
-
-func (ctx *SimpleStore) funcsToDict(dict *kern.DictType) *kern.DictType {
-	names := ctx.EnumFuncs(func(name string) bool { return true })
-	slices.Sort(names)
-	for _, name := range names {
-		value, _ := ctx.GetFuncInfo(name)
-		if formatter, ok := value.(kern.Formatter); ok {
-			(*dict)[name] = formatter.ToString(0)
-		} else {
-			(*dict)[name] = fmt.Sprintf("%v", value)
-		}
-	}
-	return dict
-}
-
 func (ctx *SimpleStore) ToDict() (dict *kern.DictType) {
-	dict = kern.MakeDict()
-	(*dict)["variables"] = ctx.varsToDict(kern.MakeDict())
-	(*dict)["functions"] = ctx.funcsToDict(kern.MakeDict())
-	return
+	return kern.ContextToDict(ctx)
 }
 
+func (ctx *SimpleStore) ToString(opt kern.FmtOpt) string {
+	return kern.ContextToString(ctx, opt)
+}
+
+// func (ctx *SimpleStore) ToString(opt kern.FmtOpt) string {
+// 	dict := ctx.ToDict()
+// 	return dict.ToString(opt)
+// }
+
+// func (ctx *SimpleStore) varsToDict(dict *kern.DictType) *kern.DictType {
+// 	names := ctx.EnumVars(nil)
+// 	slices.Sort(names)
+// 	for _, name := range ctx.EnumVars(nil) {
+// 		value, _ := ctx.GetVar(name)
+// 		if f, ok := value.(kern.Formatter); ok {
+// 			(*dict)[name] = f.ToString(0)
+// 		} else if _, ok = value.(kern.Functor); ok {
+// 			(*dict)[name] = "func(){}"
+// 		} else {
+// 			(*dict)[name] = fmt.Sprintf("%v", value)
+// 		}
+// 	}
+// 	return dict
+// }
+
+// func (ctx *SimpleStore) funcsToDict(dict *kern.DictType) *kern.DictType {
+// 	names := ctx.EnumFuncs(func(name string) bool { return true })
+// 	slices.Sort(names)
+// 	for _, name := range names {
+// 		value, _ := ctx.GetFuncInfo(name)
+// 		if formatter, ok := value.(kern.Formatter); ok {
+// 			(*dict)[name] = formatter.ToString(0)
+// 		} else {
+// 			(*dict)[name] = fmt.Sprintf("%v", value)
+// 		}
+// 	}
+// 	return dict
+// }
+
+// func (ctx *SimpleStore) ToDict() (dict *kern.DictType) {
+// 	dict = kern.MakeDict()
+// 	(*dict)["variables"] = ctx.varsToDict(kern.MakeDict())
+// 	(*dict)["functions"] = ctx.funcsToDict(kern.MakeDict())
+// 	return
+// }
+
 func (ctx *SimpleStore) GetVar(varName string) (value any, exists bool) {
 	if value, exists = ctx.varStore[varName]; !exists && ctx.global != nil {
 		value, exists = ctx.global.GetVar(varName)

t_builtin-base_test.go

@@ -118,8 +118,8 @@ func TestFuncBaseOthers(t *testing.T) {
 	inputs := []inputType{
 		/*   1 */ {`set("a", 3); a`, int64(3), nil},
 		/*   2 */ {`set(true, 3)`, nil, `set(): the "name" parameter must be a string, got a bool (true)`},
-		// /*   3 */ {`a=3; unset("a"); a`, nil, `undefined variable or function "a"`},
-		// /*   4 */ {`unset("a")`, nil, `undefined variable or function "a"`},
+		/*   3 */ {`seq(1,2,3)`, kern.NewLinkedListA(int64(1), int64(2), int64(3)), nil},
+		// /*   4 */ {`seq(1,2,4)`, kern.NewLinkedListA(int64(1), int64(2), int64(3)), nil},
 	}
 
 	// runTestSuiteSpec(t, section, inputs, 4)

t_builtin-iterator_test.go

@@ -21,7 +21,7 @@ func TestFuncRun(t *testing.T) {
 		/*   7 */ {`builtin "iterator"; run($(1,2,3), func(){1}, "prrr")`, nil, `paramter "vars" must be a dictionary, passed prrr [string]`},
 		/*   8 */ {`builtin "iterator"; run($(1,2,3), operator=nil)`, nil, nil},
 		/*   9 */ {`builtin "iterator"; run($(1,2,3), operatorx=nil)`, nil, `run(): unknown param "operatorx"`},
-		/*   10 */ {`builtin ["os.file", "iterator"]; it = fileReadIterator("test-file.txt"); run(it)`, nil, nil},
+		/*   10 */ {`builtin ["os.file", "iterator"]; it = fileLineIterator("test-file.txt"); run(it)`, nil, nil},
 	}
 
 	//t.Setenv("EXPR_PATH", ".")

t_builtin-os-file_test.go

@@ -27,16 +27,30 @@ func TestFuncOs(t *testing.T) {
 		/*  13 */ {`builtin "os.file"; handle=fileClose(123)`, nil, `fileClose(): invalid file handle`},
 		/*  14 */ {`builtin "os.file"; handle=fileOpen("/tmp/dummy"); c=fileReadTextAll(handle); fileClose(handle); c`, "bye-bye", nil},
 		/*  15 */ {`builtin "os.file"; c=fileReadTextAll(123)`, nil, `fileReadTextAll(): invalid file handle 123 [int64]`},
-		/*  16 */ {`builtin "os.file"; it=fileReadIterator("test-file.txt"); it++`, "uno", nil},
-		/*  17 */ {`builtin "os.file"; it=fileReadIterator("test-file.txt"); it++;it++;it++`, nil, io.EOF.Error()},
-		/*  18 */ {`builtin "os.file"; it=fileReadIterator("test-file.txt"); it.clean`, nil, nil},
-		/*  19 */ {`builtin "os.file"; it=fileReadIterator("test-file.txt"); string(it)`, `$(fileReadTextIterator@"test-file.txt")`, nil},
+		/*  16 */ {`builtin "os.file"; it=fileLineIterator("test-file.txt"); it++`, "uno", nil},
+		/*  17 */ {`builtin "os.file"; it=fileLineIterator("test-file.txt"); it++;it++;it++`, nil, io.EOF.Error()},
+		/*  18 */ {`builtin "os.file"; it=fileLineIterator("test-file.txt"); it.clean`, nil, nil},
+		/*  19 */ {`builtin "os.file"; it=fileLineIterator("test-file.txt"); string(it)`, `$(fileLineIterator@"test-file.txt")`, nil},
 		/*  20 */ {`builtin "os.file"; handle=fileOpen("/etc/hosts"); fileClose(handle); string(handle)`, `reader`, nil},
 		/*  21 */ {`builtin "os.file"; handle=fileCreate("/tmp/dummy"); fileClose(handle); string(handle)`, `writer`, nil},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")
 
-	// runTestSuiteSpec(t, section, inputs, 19)
+	// runTestSuiteSpec(t, section, inputs, 24)
+	runTestSuite(t, section, inputs)
+}
+
+func TestFuncOsByteIter(t *testing.T) {
+	section := "Builtin-OS-File-Byte-Iter"
+	inputs := []inputType{
+		/*   1 */ {`builtin "os.file"; it=fileByteIterator("test-file.txt"); string(it)`, `$(fileByteIterator@"test-file.txt")`, nil},
+		/*   2 */ {`builtin ["os.file", "string"]; it=fileByteIterator("test-file.txt"); char(it++)`, `u`, nil},
+		/*   3 */ {`builtin ["os.file", "string"]; it=fileByteIterator("test-file.txt"); it++; it.reset; char(it++)`, `u`, nil},
+	}
+
+	// t.Setenv("EXPR_PATH", ".")
+
+	// runTestSuiteSpec(t, section, inputs, 24)
 	runTestSuite(t, section, inputs)
 }

t_common_test.go

@@ -23,11 +23,17 @@ func runCtxTestSuiteSpec(t *testing.T, ctx kern.ExprContext, section string, inp
 	succeeded := 0
 	failed := 0
 	for _, count := range spec {
-		good := doTest(t, ctx, section, &inputs[count-1], count)
+		index := count - 1
+		if index >= 0 && index < len(inputs) {
+			good := doTest(t, ctx, section, &inputs[index], count)
 
-		if good {
-			succeeded++
+			if good {
+				succeeded++
+			} else {
+				failed++
+			}
 		} else {
+			t.Errorf("%s -- test count: %d, invalid index", section, count)
 			failed++
 		}
 	}
@@ -115,3 +121,27 @@ func logTest(t *testing.T, n int, section, source string, wantResult any, wantEr
 		t.Logf("[-]%s nr %3d -- `%s`  --> %v", section, n, source, wantErr)
 	}
 }
+
+func testIteratorCallOp(t *testing.T, section string, it kern.Iterator) {
+	if _, err := it.CallOperation("next", map[string]any{}); err != nil {
+		t.Errorf(`%s -- CallOperation("next") failed: %v`, section, err)
+	}
+	if _, err := it.CallOperation("current", map[string]any{}); err != nil {
+		t.Errorf(`%s -- CallOperation("current") failed: %v`, section, err)
+	}
+	if _, err := it.CallOperation("clean", map[string]any{}); err != nil {
+		t.Errorf(`%s -- CallOperation("clean") failed: %v`, section, err)
+	}
+	if _, err := it.CallOperation("index", map[string]any{}); err != nil {
+		t.Errorf(`%s -- CallOperation("index") failed: %v`, section, err)
+	}
+	if _, err := it.CallOperation("count", map[string]any{}); err != nil {
+		t.Errorf(`%s -- CallOperation("count") failed: %v`, section, err)
+	}
+	if _, err := it.CallOperation("reset", map[string]any{}); err != nil {
+		t.Errorf(`%s -- CallOperation("reset") failed: %v`, section, err)
+	}
+	if _, err := it.CallOperation("fake", map[string]any{}); err == nil {
+		t.Errorf(`%s -- CallOperation("fake") should return error`, section)
+	}
+}

t_context_test.go

@@ -6,6 +6,8 @@ package expr
 
 import (
 	"testing"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 func TestCtrlSet(t *testing.T) {
@@ -58,3 +60,34 @@ func TestCtrlGetNotDefined(t *testing.T) {
 		t.Errorf(`%s -- CtrlGet(%q) should have returned nil, got %v`, section, varName, v)
 	}
 }
+
+func TestCtrlEnable(t *testing.T) {
+	section := "Context"
+	varName := "test_var"
+	varValue := true
+
+	ctx := NewSimpleStore()
+	GlobalCtrlSet(ctx, varName, varValue)
+	if !CtrlEnable(ctx, varName) {
+		t.Errorf(`%s -- CtrlEnable(ctx, %q) should have returned 'true', got 'false'`, section, varName)
+	}
+
+	if !CtrlDisable(ctx, varName) {
+		t.Errorf(`%s -- CtrlEnable(ctx, %q) should have returned 'true', got 'false'`, section, varName)
+	}
+
+}
+
+func TestList(t *testing.T) {
+	section := "Context"
+
+	inputs := []inputType{
+		/*  1 */ {`$$(5)`, kern.NewLinkedListA(5), nil},
+		/*  2 */ {`$$($(2))`, kern.NewLinkedListA(0, 1), nil},
+		/*  3 */ {`string(($$global).funcs.bool)`, `bool(value):boolean{}`, nil},
+	}
+
+	// runTestSuiteSpec(t, section, inputs, 3)
+	runTestSuite(t, section, inputs)
+
+}

t_dict_test.go

@@ -7,7 +7,6 @@ package expr
 import (
 	"errors"
 
-	"strings"
 	"testing"
 
 	"git.portale-stac.it/go-pkg/expr/kern"
@@ -17,105 +16,60 @@ import (
 func TestDictParser(t *testing.T) {
 	section := "Dict"
 
-	type inputType struct {
-		source     string
-		wantResult any
-		wantErr    error
-	}
-
 	inputs := []inputType{
-		/*  1 */ {`{}`, map[any]any{}, nil},
+		/*  1 */ {`{}`, kern.NewDict(nil), nil},
 		/*  2 */ {`{123}`, nil, errors.New("[1:6] expected `:`, got `}`")},
-		/*  3 */ {`{1:"one",2:"two",3:"three"}`, map[int64]any{int64(1): "one", int64(2): "two", int64(3): "three"}, nil},
+		/*  3 */ {`{1:"one",2:"two",3:"three"}`, kern.NewDict(map[any]any{int64(1): "one", int64(2): "two", int64(3): "three"}), nil},
 		/*  4 */ {`{1:"one",2:"two",3:"three"}[3]`, "three", nil},
 		/*  5 */ {`#{1:"one",2:"two",3:"three"}`, int64(3), nil},
-		/*  6 */ {`{1:"one"} + {2:"two"}`, map[any]any{1: "one", 2: "two"}, nil},
+		/*  6 */ {`{1:"one"} + {2:"two"}`, kern.NewDict(map[any]any{int64(1): "one", int64(2): "two"}), nil},
 		/*  7 */ {`2 in {1:"one", 2:"two"}`, true, nil},
-		/*  8 */ {`D={"a":1, "b":2}; D["a"]=9; D`, map[any]any{"a": 9, "b": 2}, nil},
-		/*  9 */ {`D={"a":1, "b":2}; D["z"]=9; D`, map[any]any{"z": 9, "a": 1, "b": 2}, nil},
+		/*  8 */ {`D={"a":1, "b":2}; D["a"]=9; D`, kern.NewDict(map[any]any{"a": int64(9), "b": int64(2)}), nil},
+		/*  9 */ {`D={"a":1, "b":2}; D["z"]=9; D`, kern.NewDict(map[any]any{"z": int64(9), "a": int64(1), "b": int64(2)}), nil},
 		/* 10 */ {`D={"a":1, "b":2}; D[nil]=9`, nil, errors.New(`[1:21] index/key is nil`)},
 		/* 11 */ {`D={"a":1, "b":2}; D["a"]`, int64(1), nil},
 		/* 12 */ {`m={
 			"a":1,
 			//"b":2,
 			"c":3
-			}`, map[any]any{"a": 1, "c": 3}, nil},
+			}`, kern.NewDict(map[any]any{"a": int64(1), "c": int64(3)}), nil},
 		/* 13 */ {`D={"a":1, "b":2}; D."a"`, int64(1), nil},
 		/* 14 */ {`D={"a":1, "b":2}; D.a`, int64(1), nil},
 		/* 15 */ {`D={1:"a", 2:"b", 3:"c"}; D.(1+2)`, "c", nil},
+		/* 16 */ {`D={1:"a"}; D.2`, nil, `[1:15] key 2 not found`},
+		/* 17 */ {`D={1:"a"}; D."2"`, nil, `[1:17] key "2" not found`},
+		/* 18 */ {`D={"a":1, "b":2}; D.a = 10; D.a`, int64(10), nil},
+		/* 19 */ {`k="a"; D={k: 10}`, kern.NewDict(map[any]any{"a": int64(10)}), nil},
+		/* 20 */ {`k=[<1,2>]; D={k: 10}`, nil, `[1:16] dict key can be integer or string, got lisked-list`},
+		/* 21 */ {`f=func(n){"x"+n}; d{f(5):10}`, nil, `[0:0] two adjacent operators: "d" and "{}"`},
+		/* 22 */ {`f=func(n){"x"+n}; d={f(5):10}`, kern.NewDict(map[any]any{"x5": int64(10)}), nil},
+		/* 23 */ {`f=func(n){"x"+n}; d={f(5); "z":10}`, nil, "[1:27] expected one of  `:`, `}`, got `;`"},
+		/* 24 */ {`f=func(n){"x"+n}; d={f(5) but "z":10}`, kern.NewDict(map[any]any{"z": int64(10)}), nil},
 	}
 
-	succeeded := 0
-	failed := 0
+	// runTestSuiteSpec(t, section, inputs, 23, 24)
+	runTestSuite(t, section, inputs)
+}
 
-	// inputs1 := []inputType{
-	// 	/*  7 */ {`add([1,4,3,2])`, int64(10), nil},
-	// }
+func TestAccessSubFields(t *testing.T) {
+	section := "Dict-Assign-Item"
+	ctx := NewSimpleStore()
+	ctx.UnsafeSetVar(
+		"D",
+		kern.NewDict(map[any]any{
+			"a": kern.NewDict(map[any]any{"uno": int64(10)}),
+			"b": kern.NewListA(1, 2, 3),
+		}),
+	) // D={"a": {"uno":1}}
 
-	for i, input := range inputs {
-		var expr *scan.Ast
-		var gotResult any
-		var gotErr error
-
-		ctx := NewSimpleStoreWithoutGlobalContext()
-		ctx.SetVar("var1", int64(123))
-		ctx.SetVar("var2", "abc")
-		ImportMathFuncs(ctx)
-		parser := NewParser()
-
-		logTest(t, i+1, "Dict", input.source, input.wantResult, input.wantErr)
-
-		r := strings.NewReader(input.source)
-		scanner := scan.NewScanner(r, scan.DefaultTranslations())
-
-		good := true
-		if expr, gotErr = parser.Parse(scanner); gotErr == nil {
-			gotResult, gotErr = expr.Eval(ctx)
-		}
-
-		if (gotResult == nil && input.wantResult != nil) || (gotResult != nil && input.wantResult == nil) {
-			t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-			good = false
-		}
-
-		if gotList, okGot := gotResult.([]any); okGot {
-			if wantList, okWant := input.wantResult.([]any); okWant {
-				if (gotList == nil && wantList != nil) || (gotList != nil && wantList == nil) {
-					t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-					good = false
-				} else {
-					equal := len(gotList) == len(wantList)
-					if equal {
-						for i, gotItem := range gotList {
-							wantItem := wantList[i]
-							equal = gotItem == wantItem
-							if !equal {
-								break
-							}
-						}
-					}
-					if !equal {
-						t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-						good = false
-					}
-				}
-			}
-		}
-
-		if gotErr != input.wantErr {
-			if input.wantErr == nil || gotErr == nil || (gotErr.Error() != input.wantErr.Error()) {
-				t.Errorf("%d: %q  -> err = <%v>, want <%v>", i+1, input.source, gotErr, input.wantErr)
-				good = false
-			}
-		}
-
-		if good {
-			succeeded++
-		} else {
-			failed++
-		}
+	inputs := []inputType{
+		/* 1 */ {`D.a.uno`, int64(10), nil},
+		/* 2 */ {`D.a.uno = 111; D.a."uno"`, int64(111), nil},
+		/* 3 */ {`D.a.uno = 111; D["a"]["uno"]`, int64(111), nil},
+		/* 4 */ {`D.b[1] = 22; D["b"][1]`, int64(22), nil},
 	}
-	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
+	// runCtxTestSuiteSpec(t, ctx, section, inputs, 4)
+	runCtxTestSuite(t, ctx, section, inputs)
 }
 
 func TestDictToStringMultiLine(t *testing.T) {

t_expr_test.go

@@ -31,8 +31,7 @@ func TestExpr(t *testing.T) {
 		/*  15 */ {`a=3; a*=2)+1; a`, nil, `[1:11] unexpected token ")"`},
 		/*  16 */ {`v=[2]; a=1; v[a-=1]=5; v[0]`, int64(5), nil},
 		/*  17 */ {`true ? {"a"} :: {"b"}`, "a", nil},
-		/*  18 */ {`$$`, kern.NewDict(map[any]any{"variables": kern.NewDict(nil), "functions": kern.NewDict(nil)}), nil},
-		///*  19 */ {`$$global`, NewDict(map[any]any{"variables": NewDict(nil), "functions": NewDict(nil)}), nil},
+		/*  18 */ {`$$`, kern.NewDict(map[any]any{"vars": kern.NewDict(nil), "funcs": kern.NewDict(nil)}), nil},
 		/*  19 */ {`
 		ds={
 			"init":func(@end){@current=0 but true},

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`},
-		/*   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_helpers_test.go

@@ -5,51 +5,55 @@
 package expr
 
 import (
+	"fmt"
+
 	"testing"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
-// TODO The new function param model does not allow this kind of test
-// ------------------------------------------------------------------
-// func subtract(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-// 	if len(args) != 2 {
-// 		err = fmt.Errorf("%s(): requires exactly two arguments", name)
-// 		return
-// 	}
-// 	x, xok := args[0].(int64)
-// 	y, yok := args[1].(int64)
-// 	if xok && yok {
-// 		result = x - y
-// 	} else {
-// 		err = fmt.Errorf("expected integer (int64) arguments, got %T and %T values", x, y)
-// 	}
-// 	return
-// }
+func subtract(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+	if len(args) != 2 {
+		err = fmt.Errorf("%s(): requires exactly two arguments", name)
+		return
+	}
+	x, xok := args["a"].(int64)
+	y, yok := args["b"].(int64)
+	if xok && yok {
+		result = x - y
+	} else {
+		err = fmt.Errorf("expected integer (int64) arguments, got %T and %T values", x, y)
+	}
+	return
+}
 
-// func TestEvalStringA(t *testing.T) {
+func TestEvalStringA(t *testing.T) {
 
-// 	source := `a + b * subtract(4,2)`
-// 	args := []Arg{
-// 		{"a", uint8(1)},
-// 		{"b", int8(2)},
-// 		{"subtract", FuncTemplate2(subtract)},
-// 		// force coverage
-// 		{"a16", uint16(1)},
-// 		{"b16", int16(2)},
-// 		{"a32", uint32(1)},
-// 		{"b32", int32(2)},
-// 		{"a64", uint64(1)},
-// 		{"b64", int64(2)},
-// 		{"f32", float32(1.0)},
-// 		{"f64", float64(1.0)},
-// 	}
+	source := `a + b * subtract(4,2)`
+	args := []Arg{
+		{"a", uint8(1)},
+		{"b", int8(2)},
+		{"subtract", kern.FuncTemplate(subtract)},
+		// force coverage
+		{"a16", uint16(1)},
+		{"b16", int16(2)},
+		{"a32", uint32(1)},
+		{"b32", int32(2)},
+		{"a64", uint64(1)},
+		{"b64", int64(2)},
+		{"f32", float32(1.0)},
+		{"f64", float64(1.0)},
+		{"string", "text"},
+		{"bool", true},
+	}
 
-// 	wantResult := int64(5)
-// 	gotResult, gotErr := EvalStringA(source, args...)
-// 	if value, ok := gotResult.(int64); ok && value != wantResult {
-// 		t.Errorf("Source %q got %v, want %v", source, gotResult, wantResult)
-// 		t.Errorf("Error: %v", gotErr)
-// 	}
-// }
+	wantResult := int64(5)
+	gotResult, gotErr := EvalStringA(source, args...)
+	if value, ok := gotResult.(int64); ok && value != wantResult {
+		t.Errorf("Source %q got %v, want %v", source, gotResult, wantResult)
+		t.Errorf("Error: %v", gotErr)
+	}
+}
 
 func TestEvalString(t *testing.T) {
 

t_index_test.go

@@ -6,19 +6,21 @@ package expr
 
 import (
 	"testing"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 func TestCollections(t *testing.T) {
-	section := "Collection"
+	section := "Index"
 	inputs := []inputType{
 		/*   1 */ {`"abcdef"[1:3]`, "bc", nil},
 		/*   2 */ {`"abcdef"[:3]`, "abc", nil},
 		/*   3 */ {`"abcdef"[1:]`, "bcdef", nil},
 		/*   4 */ {`"abcdef"[:]`, "abcdef", nil},
-		// /*   5 */ {`[0,1,2,3,4][:]`, ListType{int64(0), int64(1), int64(2), int64(3), int64(4)}, nil},
 		/*   5 */ {`"abcdef"[1:2:3]`, nil, `[1:14] invalid range specification`},
 		/*   6 */ {`"abcdef"[((1>0)?{1}:{0}):3]`, "bc", nil},
 		/*   7 */ {`"abcdef"[[0,1][0]:1]`, "a", nil},
+		/*   8 */ {`[0,1,2,3,4][:]`, kern.NewListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil},
 	}
 
 	t.Setenv("EXPR_PATH", ".")

t_iter-iter_test.go

@@ -11,16 +11,16 @@ import (
 )
 
 func TestIterIterator(t *testing.T) {
-	section := "Iterator"
+	section := "Iter-Iter"
 	inputs := []inputType{
-		/*   1 */ {`it=$(4); $(it) filter ${_}==100`, kern.NewListA(), nil},
-		/*   2 */ {`it=$(4); $(it, $_) filter ${_}==100`, kern.NewListA(), nil},
+		/*   1 */ {`it=$(4); $$($(it) filter ${_}==100)`, kern.NewLinkedListA(), nil},
+		/*   2 */ {`it=$(4); $$($(it, $_) filter ${_}==100)`, kern.NewLinkedListA(), 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, 4)
-	// runTestSuite(t, section, inputs)
+	// runTestSuiteSpec(t, section, inputs, 4)
+	runTestSuite(t, section, inputs)
 }
 
 // func TestNewIterIterator(t *testing.T) {

t_iter-list_test.go

@@ -92,9 +92,10 @@ func TestNewIterList5(t *testing.T) {
 }
 
 func TestNewIterList6(t *testing.T) {
+	ctx := NewSimpleStore()
 	list := kern.NewListA("a", "b", "c", "d")
-	it1, _ := NewIterator(nil, list, nil)
-	it, _ := NewIterator(nil, it1, nil)
+	it1, _ := NewIterator(ctx, list, nil)
+	it, _ := NewIterator(ctx, it1, nil)
 	if item, err := it.Next(); err != nil {
 		t.Errorf("error: %v", err)
 	} else if item != "a" {

t_iterator_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"git.portale-stac.it/go-pkg/expr/kern"
+	"git.portale-stac.it/go-pkg/expr/scan"
 )
 
 func TestIteratorParser(t *testing.T) {
@@ -35,17 +36,139 @@ 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"; fileReadIterator("test-file.txt") map ${__}`, kern.NewList([]any{int64(0), int64(1)}), nil},
-		/*  24 */ {`builtin "os.file"; #(fileReadIterator("test-file.txt") filter (#${_} == 2))`, int64(0), nil},
-		/*  25 */ {`builtin "os.file"; #(fileReadIterator("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},
+		/*  23 */ {`$$($(1,4,0))`, nil, `step cannot be zero`},
+		/*  24 */ {`$$($(1,4,-1))`, nil, `step cannot be negative when start < stop`},
+		/*  25 */ {`$$($(4,1,1))`, nil, `step cannot be positive when start > stop`},
 	}
 
-	// runTestSuiteSpec(t, section, inputs, 10)
+	// runTestSuiteSpec(t, section, inputs, 25)
+	runTestSuite(t, section, inputs)
+}
+
+func TestCallOpIntIter(t *testing.T) {
+	section := "IntIterator-CallOp"
+
+	if it, err := NewIntIteratorA(int64(1), int64(4), int64(1)); err != nil {
+		t.Errorf(`%s -- NewIntIteratorA() failed: %v`, section, err)
+	} else {
+		testIteratorCallOp(t, section, it)
+		testIterAttrs(t, section, it, "IntIterator", "$(1..4..1)")
+	}
+}
+
+func TestCallOpIterIter(t *testing.T) {
+	section := "IterIterator-CallOp"
+
+	ctx := NewSimpleStore()
+	if inner, err := NewIntIteratorA(int64(1), int64(4), int64(1)); err == nil {
+		if it, err := NewIterIter(inner, ctx, []*scan.Term{}); err != nil {
+			t.Errorf(`%s -- NewIterIter() failed: %v`, section, err)
+		} else {
+			testIteratorCallOp(t, section, it)
+			testIterAttrs(t, section, it, "IterIter", "$($(1..4..1))")
+		}
+	} else {
+		t.Errorf(`%s -- can't create inner iterator: %v`, section, err)
+	}
+}
+
+func TestCallOpDictIter(t *testing.T) {
+	section := "DictIterator-CallOp"
+
+	inner := kern.NewDict(map[any]any{"a": 1})
+	if it, err := NewDictIterator(inner, nil); err != nil {
+		t.Errorf(`%s -- NewIterIter() failed: %v`, section, err)
+	} else {
+		testIteratorCallOp(t, section, it)
+		testIterAttrs(t, section, it, "DictIterator", "$({#1})")
+	}
+}
+
+func TestCallOpLinkedListIter(t *testing.T) {
+	section := "LinkedListIterator-CallOp"
+
+	inner := kern.NewLinkedListA(1, 2, 3)
+	it := NewLinkedListIterator(inner, nil)
+	testIteratorCallOp(t, section, it)
+
+	// wanted := "$([<#3>])"
+	// got := it.String()
+	// if wanted != got {
+	// 	t.Errorf(`%s -- LinkedListIterator.String() failed: expected %q, got %q`, section, wanted, got)
+	// }
+
+	// wanted = "LinkedListIterator"
+	// got = it.TypeName()
+	// if wanted != got {
+	// 	t.Errorf(`%s -- LinkedListIterator.TypeName() failed: expected %q, got %q`, section, wanted, got)
+	// }
+	testIterAttrs(t, section, it, "LinkedListIterator", "$([<#3>])")
+}
+
+func testIterAttrs(t *testing.T, section string, it kern.Iterator, name, repr string) {
+	wanted := repr
+	got := it.String()
+	if wanted != got {
+		t.Errorf(`%s -- %s.String() failed: expected %q, got %q`, section, name, wanted, got)
+	}
+
+	wanted = name
+	got = it.TypeName()
+	if wanted != got {
+		t.Errorf(`%s -- %s.TypeName() failed: expected %q, got %q`, section, name, wanted, got)
+	}
+}
+
+func TestFilterIterator(t *testing.T) {
+	section := "Iterator-Filter"
+	inputs := []inputType{
+		/*   1 */ {`$$([1,2,3] filter $_%2==0)`, kern.NewLinkedListA(2), nil},
+		/*   2 */ {`it = [1,2,3] filter $_%2!=1; $$(it)`, kern.NewLinkedListA(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.NewLinkedListA(1), nil},
+		/*   2 */ {`$$([1] cat [2])`, kern.NewLinkedListA(1, 2), nil},
+		/*   3 */ {`$$([1] cat nil)`, kern.NewLinkedListA(1), nil},
+		/*   4 */ {`$$(nil cat [2])`, kern.NewLinkedListA(2), nil},
+		/*   5 */ {`$$(nil cat nil)`, kern.NewLinkedListA(), 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.NewLinkedListA(1, 2, 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.NewLinkedListA(0, 1), nil},
+		/*   5 */ {`$$(["1", "2", "3"] map int())`, nil, `int(): too few params -- expected 1, got 0`},
+	}
+
+	// runTestSuiteSpec(t, section, inputs, 2)
 	runTestSuite(t, section, inputs)
 }

t_list_test.go

@@ -54,10 +54,31 @@ func TestListParser(t *testing.T) {
 		/*  38 */ {`[0,1,2,3,4][3:-1]`, kern.NewListA(int64(3)), nil},
 		/*  30 */ {`[0,1,2,3,4][-3:-1]`, kern.NewListA(int64(2), int64(3)), nil},
 		/*  40 */ {`[0,1,2,3,4][0:]`, kern.NewListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil},
+		/*  41 */ {`[0] << $([1,2,3,4])`, kern.NewListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil},
+		/*  42 */ {`L=[]; [1] >> L; L`, kern.NewListA(), nil},
+		/*  43 */ {`L=[]; L << [1]; L`, kern.NewListA(), nil},
+		// /*  44 */ {`[0,1,2,3,4][2:3]`, kern.NewListA(int64(20)), nil},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")
 
-	// runTestSuiteSpec(t, section, inputs, 1)
+	// runTestSuiteSpec(t, section, inputs, 44)
+	runTestSuite(t, section, inputs)
+}
+
+func TestLinkedListParser(t *testing.T) {
+	section := "Linked-List"
+
+	inputs := []inputType{
+		/*   1 */ {`[<1,2>]`, kern.NewLinkedListA(1, 2), nil},
+		/*   2 */ {`it=$([<1,2,3>]); it++`, int64(1), nil},
+		/*   3 */ {`it=$([<1,2,3>]); #($$(it))`, int64(3), nil},
+		/*   4 */ {`[<1,2,3>][0]`, int64(1), nil},
+		/*   5 */ {`[<1,2,3>][0:2]`, kern.NewLinkedListA(1, 2), nil},
+	}
+
+	// t.Setenv("EXPR_PATH", ".")
+
+	// runTestSuiteSpec(t, section, inputs, 4)
 	runTestSuite(t, section, inputs)
 }

t_operator_test.go

@@ -35,6 +35,12 @@ func TestOperator(t *testing.T) {
 		/*  20 */ {`a=1; a^=2`, int64(3), nil},
 		/*  21 */ {`a=1; ++a`, int64(2), nil},
 		/*  22 */ {`a=1; --a`, int64(0), nil},
+		/*  23 */ {`a=1; a++`, int64(1), nil},
+		/*  24 */ {`a=1; a--`, int64(1), nil},
+		/*  25 */ {`a="1"; ++a`, nil, `[1:9] prefix/postfix operator "++" does not support operand '1' [string]`},
+		/*  26 */ {`a="1"; --a`, nil, `[1:9] prefix/postfix operator "--" does not support operand '1' [string]`},
+		/*  27 */ {`a="1"; a++`, nil, `[1:10] prefix/postfix operator "++" does not support operand '1' [string]`},
+		/*  28 */ {`a="1"; a--`, nil, `[1:10] prefix/postfix operator "--" does not support operand '1' [string]`},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")
@@ -43,49 +49,58 @@ func TestOperator(t *testing.T) {
 	runTestSuite(t, section, inputs)
 }
 
-func TestOperatorMap(t *testing.T) {
-	section := "Operator-Map"
+func TestOperatorInsert(t *testing.T) {
+	section := "Operator-Insert"
 	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},
+		/*   1 */ {`["a", "b"] << nil`, kern.NewListA("a", "b"), nil},
+		/*   2 */ {`["a", "b"] << []`, kern.NewListA("a", "b", kern.NewListA()), nil},
+		/*   3 */ {`["a", "b"] << $([])`, kern.NewListA("a", "b"), nil},
+		/*   4 */ {`["a", "b"] << 3`, kern.NewListA("a", "b", int64(3)), nil},
+		/*   5 */ {`3 << ["a", "b"]`, nil, `[1:5] left operand '3' [integer] and right operand '["a", "b"]' [list] are not compatible with operator "<<"`},
+		/*   6 */ {`nil >> ["a", "b"]`, kern.NewListA("a", "b"), nil},
+		/*   7 */ {`[] >> ["a", "b"]`, kern.NewListA(kern.NewListA(), "a", "b"), nil},
+		/*   8 */ {`$([]) >> ["a", "b"]`, kern.NewListA("a", "b"), nil},
+		/*   9 */ {`["a", "b"] << $([1,2,3])`, kern.NewListA("a", "b", int64(1), int64(2), int64(3)), nil},
+		/*  10 */ {`L=["a", "b"]; L << $([1,2,3])`, kern.NewListA("a", "b", int64(1), int64(2), int64(3)), nil},
+		/*  11 */ {`L=["a", "b"]; L << $([1,2,3]); L`, kern.NewListA("a", "b"), nil},
+		/*  12 */ {`L << $([1,2,3])`, nil, `undefined variable or function "L"`},
+		/*  13 */ {`[<>] << 1`, kern.NewLinkedListA(1), nil},
+		/*  14 */ {`[<>] << [1,2]`, kern.NewLinkedListA(kern.NewListA(int64(1), int64(2))), nil},
+		/*  15 */ {`[<>] << [<1,2>]`, kern.NewLinkedListA(kern.NewLinkedListA(1, 2)), nil},
+		/*  16 */ {`1 >> [<>]`, kern.NewLinkedListA(1), nil},
+		/*  17 */ {`[1,2] >> [<>]`, kern.NewLinkedListA(kern.NewListA(int64(1), int64(2))), nil},
+		/*  18 */ {`[<1,2>] >> [<>]`, kern.NewLinkedListA(kern.NewLinkedListA(1, 2)), nil},
+		/*  19 */ {`$([1,2]) >> [<>]`, kern.NewLinkedListA(1, 2), nil},
+		/*  20 */ {`$([<1,2>]) >> [<>]`, kern.NewLinkedListA(1, 2), nil},
 	}
 
-	// runTestSuiteSpec(t, section, inputs, 3)
+	// runTestSuiteSpec(t, section, inputs, 9)
 	runTestSuite(t, section, inputs)
 }
 
-func TestOperatorFilter(t *testing.T) {
-	section := "Operator-Filter"
+func TestOperatorDeepAssign(t *testing.T) {
+	section := "Operator-DeepAssign"
 	inputs := []inputType{
-		/*   1 */ {`[1,2,3,4] filter ($_ % 2 == 0)`, kern.NewList([]any{int64(2), int64(4)}), nil},
+		/*   1 */ {`DD={"uno": 1, "due": 2}; D=DD; D["uno"]=11; DD`, kern.NewDict(map[any]any{"uno": int64(11), "due": int64(2)}), nil},
+		/*   2 */ {`DD={"uno": 1, "due": 2}; D:=DD; D["uno"]=11; DD`, kern.NewDict(map[any]any{"uno": int64(1), "due": int64(2)}), nil},
+		/*   3 */ {`LL=["a", "b"]; L=LL; L[0]="x"; LL`, kern.NewListA("x", "b"), nil},
+		/*   4 */ {`LL=["a", "b"]; L:=LL; L[0]="x"; LL`, kern.NewListA("a", "b"), nil},
 	}
 
-	// runTestSuiteSpec(t, section, inputs, 1)
+	// runTestSuiteSpec(t, section, inputs, 4)
 	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 TestOperatorJoin(t *testing.T) {
-	section := "Operator-Join"
-	inputs := []inputType{
-		/*   1 */ {`["a","b"] join ["x"]`, kern.NewList([]any{"a", "b", "x"}), nil},
-		/*   2 */ {`["a","b"] join ["x"-true]`, nil, `[1:21] 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{
@@ -113,6 +128,6 @@ func TestOperatorGroupBy(t *testing.T) {
 			nil},
 	}
 
-	runTestSuiteSpec(t, section, inputs, 3)
-	// runTestSuite(t, section, inputs)
+	// runTestSuiteSpec(t, section, inputs, 3)
+	runTestSuite(t, section, inputs)
 }

t_symbol_test.go

@@ -32,15 +32,15 @@ func testStringEndingWithOperator(source string) bool {
 	return scan.StringEndsWithOperator(source)
 }
 
-func testStringArrayEndingWithOperatorSpec(t *testing.T, section string, inputs []inputType, spec ...int) {
-	for i := range spec {
-		if spec[i] < 1 || spec[i] > len(inputs) {
-			t.Errorf("Invalid test spec index: %d (must be between 1 and %d)", spec[i], len(inputs))
-			continue
-		}
-		doEndingTest(t, section, inputs[spec[i]-1], spec[i]-1)
-	}
-}
+// func testStringArrayEndingWithOperatorSpec(t *testing.T, section string, inputs []inputType, spec ...int) {
+// 	for i := range spec {
+// 		if spec[i] < 1 || spec[i] > len(inputs) {
+// 			t.Errorf("Invalid test spec index: %d (must be between 1 and %d)", spec[i], len(inputs))
+// 			continue
+// 		}
+// 		doEndingTest(t, section, inputs[spec[i]-1], spec[i]-1)
+// 	}
+// }
 
 func testStringArrayEndingWithOperator(t *testing.T, section string, inputs []inputType) {
 	for i, input := range inputs {

util/utils.go

@@ -77,3 +77,10 @@ func ForAll[T, V any](ts []T, fn func(T) V) []V {
 	}
 	return result
 }
+
+func UnquoteString(src string) string {
+	if len(src) > 1 && src[0] == '"' && src[len(src)-1] == '"' {
+		src = src[1 : len(src)-1]
+	}
+	return src
+}