splitted go and expr function bindings in dedicated source files

Also changed and exported some identiefier relatet to the builtin feature

bind-expr-functions.go

@@ -0,0 +1,44 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// function.go
+package expr
+
+// ---- Linking with Expr functions
+type exprFunctor struct {
+	baseFunctor
+	params []ExprFuncParam
+	expr   Expr
+	defCtx ExprContext
+}
+
+// func newExprFunctor(e Expr, params []string, ctx ExprContext) *exprFunctor {
+// 	return &exprFunctor{expr: e, params: params, defCtx: ctx}
+// }
+
+func newExprFunctor(e Expr, params []ExprFuncParam, ctx ExprContext) *exprFunctor {
+	return &exprFunctor{expr: e, params: params, defCtx: ctx}
+}
+
+func (functor *exprFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
+	if functor.defCtx != nil {
+		ctx.Merge(functor.defCtx)
+	}
+
+	for i, p := range functor.params {
+		if i < len(args) {
+			arg := args[i]
+			if funcArg, ok := arg.(Functor); ok {
+				// ctx.RegisterFunc(p, functor, 0, -1)
+				paramSpecs := funcArg.GetParams()
+				ctx.RegisterFunc(p.Name(), funcArg, TypeAny, paramSpecs)
+			} else {
+				ctx.UnsafeSetVar(p.Name(), arg)
+			}
+		} else {
+			ctx.UnsafeSetVar(p.Name(), nil)
+		}
+	}
+	result, err = functor.expr.Eval(ctx)
+	return
+}

bind-go-functions.go

@@ -0,0 +1,19 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// bind-go-function.go
+package expr
+
+// ---- Linking with Go functions
+type golangFunctor struct {
+	baseFunctor
+	f FuncTemplate
+}
+
+func NewGolangFunctor(f FuncTemplate) *golangFunctor {
+	return &golangFunctor{f: f}
+}
+
+func (functor *golangFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
+	return functor.f(ctx, name, args)
+}

builtin-base.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// func-builtins.go
+// builtin-base.go
 package expr
 
 import (
@@ -159,7 +159,7 @@ func iteratorFunc(ctx ExprContext, name string, args []any) (result any, err err
 
 func ImportBuiltinsFuncs(ctx ExprContext) {
 	anyParams := []ExprFuncParam{
-		NewFuncParam(paramValue),
+		NewFuncParam(ParamValue),
 	}
 
 	ctx.RegisterFunc("isNil", NewGolangFunctor(isNilFunc), TypeBoolean, anyParams)
@@ -176,11 +176,11 @@ func ImportBuiltinsFuncs(ctx ExprContext) {
 	ctx.RegisterFunc("int", NewGolangFunctor(intFunc), TypeInt, anyParams)
 	ctx.RegisterFunc("dec", NewGolangFunctor(decFunc), TypeFloat, anyParams)
 	ctx.RegisterFunc("fract", NewGolangFunctor(fractFunc), TypeFraction, []ExprFuncParam{
-		NewFuncParam(paramValue),
+		NewFuncParam(ParamValue),
 		NewFuncParamFlagDef("denominator", PfDefault, 1),
 	})
 }
 
 func init() {
-	registerImport("base", ImportBuiltinsFuncs, "Base expression tools like isNil(), int(), etc.")
+	RegisterBuiltinModule("base", ImportBuiltinsFuncs, "Base expression tools like isNil(), int(), etc.")
 }

builtin-fmt.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// func-fmt.go
+// builtin-fmt.go
 package expr
 
 import "fmt"
@@ -24,13 +24,13 @@ func printLnFunc(ctx ExprContext, name string, args []any) (result any, err erro
 
 func ImportFmtFuncs(ctx ExprContext) {
 	ctx.RegisterFunc("print", NewGolangFunctor(printFunc), TypeInt, []ExprFuncParam{
-		NewFuncParamFlag(paramItem, PfRepeat),
+		NewFuncParamFlag(ParamItem, PfRepeat),
 	})
 	ctx.RegisterFunc("println", NewGolangFunctor(printLnFunc), TypeInt, []ExprFuncParam{
-		NewFuncParamFlag(paramItem, PfRepeat),
+		NewFuncParamFlag(ParamItem, PfRepeat),
 	})
 }
 
 func init() {
-	registerImport("fmt", ImportFmtFuncs, "String and console formatting functions")
+	RegisterBuiltinModule("fmt", ImportFmtFuncs, "String and console formatting functions")
 }

builtin-import.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// func-import.go
+// builtin-import.go
 package expr
 
 import (
@@ -63,13 +63,13 @@ func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (resu
 
 func ImportImportFuncs(ctx ExprContext) {
 	ctx.RegisterFunc("import", NewGolangFunctor(importFunc), TypeAny, []ExprFuncParam{
-		NewFuncParamFlag(paramFilepath, PfRepeat),
+		NewFuncParamFlag(ParamFilepath, PfRepeat),
 	})
 	ctx.RegisterFunc("importAll", NewGolangFunctor(importAllFunc), TypeAny, []ExprFuncParam{
-		NewFuncParamFlag(paramFilepath, PfRepeat),
+		NewFuncParamFlag(ParamFilepath, PfRepeat),
 	})
 }
 
 func init() {
-	registerImport("import", ImportImportFuncs, "Functions import() and include()")
+	RegisterBuiltinModule("import", ImportImportFuncs, "Functions import() and include()")
 }

builtin-math-arith.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// funcs-math.go
+// builtin-math-arith.go
 package expr
 
 import (
@@ -168,14 +168,14 @@ func mulFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 
 func ImportMathFuncs(ctx ExprContext) {
 	ctx.RegisterFunc("add", &golangFunctor{f: addFunc}, TypeNumber, []ExprFuncParam{
-		NewFuncParamFlagDef(paramValue, PfDefault|PfRepeat, int64(0)),
+		NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(0)),
 	})
 
 	ctx.RegisterFunc("mul", &golangFunctor{f: mulFunc}, TypeNumber, []ExprFuncParam{
-		NewFuncParamFlagDef(paramValue, PfDefault|PfRepeat, int64(1)),
+		NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(1)),
 	})
 }
 
 func init() {
-	registerImport("math.arith", ImportMathFuncs, "Functions add() and mul()")
+	RegisterBuiltinModule("math.arith", ImportMathFuncs, "Functions add() and mul()")
 }

builtin-os-file.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// func-os.go
+// builtin-os-file.go
 package expr
 
 import (
@@ -188,13 +188,13 @@ func readFileFunc(ctx ExprContext, name string, args []any) (result any, err err
 
 func ImportOsFuncs(ctx ExprContext) {
 	ctx.RegisterFunc("openFile", NewGolangFunctor(openFileFunc), TypeHandle, []ExprFuncParam{
-		NewFuncParam(paramFilepath),
+		NewFuncParam(ParamFilepath),
 	})
 	ctx.RegisterFunc("appendFile", NewGolangFunctor(appendFileFunc), TypeHandle, []ExprFuncParam{
-		NewFuncParam(paramFilepath),
+		NewFuncParam(ParamFilepath),
 	})
 	ctx.RegisterFunc("createFile", NewGolangFunctor(createFileFunc), TypeHandle, []ExprFuncParam{
-		NewFuncParam(paramFilepath),
+		NewFuncParam(ParamFilepath),
 	})
 	ctx.RegisterFunc("writeFile", NewGolangFunctor(writeFileFunc), TypeInt, []ExprFuncParam{
 		NewFuncParam(TypeHandle),
@@ -210,5 +210,5 @@ func ImportOsFuncs(ctx ExprContext) {
 }
 
 func init() {
-	registerImport("os.file", ImportOsFuncs, "Operating system file functions")
+	RegisterBuiltinModule("os.file", ImportOsFuncs, "Operating system file functions")
 }

builtin-string.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// func-string.go
+// builtin-string.go
 package expr
 
 import (
@@ -45,13 +45,13 @@ func joinStrFunc(ctx ExprContext, name string, args []any) (result any, err erro
 			} else if it, ok := args[1].(Iterator); ok {
 				result, err = doJoinStr(name, sep, it)
 			} else {
-				err = errInvalidParameterValue(name, paramParts, args[1])
+				err = errInvalidParameterValue(name, ParamParts, args[1])
 			}
 		} else {
 			result, err = doJoinStr(name, sep, NewArrayIterator(args[1:]))
 		}
 	} else {
-		err = errWrongParamType(name, paramSeparator, TypeString, args[0])
+		err = errWrongParamType(name, ParamSeparator, TypeString, args[0])
 	}
 	return
 }
@@ -63,7 +63,7 @@ func subStrFunc(ctx ExprContext, name string, args []any) (result any, err error
 	var ok bool
 
 	if source, ok = args[0].(string); !ok {
-		return nil, errWrongParamType(name, paramSource, TypeString, args[0])
+		return nil, errWrongParamType(name, ParamSource, TypeString, args[0])
 	}
 
 	if start, err = toInt(args[1], name+"()"); err != nil {
@@ -91,7 +91,7 @@ func trimStrFunc(ctx ExprContext, name string, args []any) (result any, err erro
 	var ok bool
 
 	if source, ok = args[0].(string); !ok {
-		return nil, errWrongParamType(name, paramSource, TypeString, args[0])
+		return nil, errWrongParamType(name, ParamSource, TypeString, args[0])
 	}
 	result = strings.TrimSpace(source)
 	return
@@ -104,7 +104,7 @@ func startsWithStrFunc(ctx ExprContext, name string, args []any) (result any, er
 	result = false
 
 	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, TypeString, args[0])
+		return result, errWrongParamType(name, ParamSource, TypeString, args[0])
 	}
 	for i, targetSpec := range args[1:] {
 		if target, ok := targetSpec.(string); ok {
@@ -127,7 +127,7 @@ func endsWithStrFunc(ctx ExprContext, name string, args []any) (result any, err
 	result = false
 
 	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, TypeString, args[0])
+		return result, errWrongParamType(name, ParamSource, TypeString, args[0])
 	}
 	for i, targetSpec := range args[1:] {
 		if target, ok := targetSpec.(string); ok {
@@ -150,7 +150,7 @@ func splitStrFunc(ctx ExprContext, name string, args []any) (result any, err err
 	var ok bool
 
 	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, TypeString, args[0])
+		return result, errWrongParamType(name, ParamSource, TypeString, args[0])
 	}
 
 	if sep, ok = args[1].(string); !ok {
@@ -183,41 +183,41 @@ func splitStrFunc(ctx ExprContext, name string, args []any) (result any, err err
 // Import above functions in the context
 func ImportStringFuncs(ctx ExprContext) {
 	ctx.RegisterFunc("joinStr", NewGolangFunctor(joinStrFunc), TypeString, []ExprFuncParam{
-		NewFuncParam(paramSeparator),
-		NewFuncParamFlag(paramItem, PfRepeat),
+		NewFuncParam(ParamSeparator),
+		NewFuncParamFlag(ParamItem, PfRepeat),
 	})
 
 	ctx.RegisterFunc("subStr", NewGolangFunctor(subStrFunc), TypeString, []ExprFuncParam{
-		NewFuncParam(paramSource),
-		NewFuncParamFlagDef(paramStart, PfDefault, int64(0)),
-		NewFuncParamFlagDef(paramCount, PfDefault, int64(-1)),
+		NewFuncParam(ParamSource),
+		NewFuncParamFlagDef(ParamStart, PfDefault, int64(0)),
+		NewFuncParamFlagDef(ParamCount, PfDefault, int64(-1)),
 	})
 
 	ctx.RegisterFunc("splitStr", NewGolangFunctor(splitStrFunc), "list of "+TypeString, []ExprFuncParam{
-		NewFuncParam(paramSource),
-		NewFuncParamFlagDef(paramSeparator, PfDefault, ""),
-		NewFuncParamFlagDef(paramCount, PfDefault, int64(-1)),
+		NewFuncParam(ParamSource),
+		NewFuncParamFlagDef(ParamSeparator, PfDefault, ""),
+		NewFuncParamFlagDef(ParamCount, PfDefault, int64(-1)),
 	})
 
 	ctx.RegisterFunc("trimStr", NewGolangFunctor(trimStrFunc), TypeString, []ExprFuncParam{
-		NewFuncParam(paramSource),
+		NewFuncParam(ParamSource),
 	})
 
 	ctx.RegisterFunc("startsWithStr", NewGolangFunctor(startsWithStrFunc), TypeBoolean, []ExprFuncParam{
-		NewFuncParam(paramSource),
-		NewFuncParam(paramPrefix),
-		NewFuncParamFlag("other "+paramPrefix, PfRepeat),
+		NewFuncParam(ParamSource),
+		NewFuncParam(ParamPrefix),
+		NewFuncParamFlag("other "+ParamPrefix, PfRepeat),
 	})
 
 	ctx.RegisterFunc("endsWithStr", NewGolangFunctor(endsWithStrFunc), TypeBoolean, []ExprFuncParam{
-		NewFuncParam(paramSource),
-		NewFuncParam(paramSuffix),
-		NewFuncParamFlag("other "+paramSuffix, PfRepeat),
+		NewFuncParam(ParamSource),
+		NewFuncParam(ParamSuffix),
+		NewFuncParamFlag("other "+ParamSuffix, PfRepeat),
 	})
 }
 
 // Register the import function in the import-register.
 // That will allow to import all function of this module by the "builtin" operator."
 func init() {
-	registerImport("string", ImportStringFuncs, "string utilities")
+	RegisterBuiltinModule("string", ImportStringFuncs, "string utilities")
 }

builtins-register.go

@@ -0,0 +1,48 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtins-register.go
+package expr
+
+import (
+	"fmt"
+)
+
+type builtinModule struct {
+	importFunc  func(ExprContext)
+	description string
+	imported    bool
+}
+
+func newBuiltinModule(importFunc func(ExprContext), description string) *builtinModule {
+	return &builtinModule{importFunc, description, false}
+}
+
+var builtinModuleRegister map[string]*builtinModule
+
+func RegisterBuiltinModule(name string, importFunc func(ExprContext), description string) {
+	if builtinModuleRegister == nil {
+		builtinModuleRegister = make(map[string]*builtinModule)
+	}
+	if _, exists := builtinModuleRegister[name]; exists {
+		panic(fmt.Errorf("module %q already registered", name))
+	}
+	builtinModuleRegister[name] = newBuiltinModule(importFunc, description)
+}
+
+func IterateBuiltinModules(op func(name, description string, imported bool) bool) {
+	if op != nil {
+		for name, mod := range builtinModuleRegister {
+			if !op(name, mod.description, mod.imported) {
+				break
+			}
+		}
+	}
+}
+
+// ----
+func init() {
+	if builtinModuleRegister == nil {
+		builtinModuleRegister = make(map[string]*builtinModule)
+	}
+}

common-params.go

@@ -5,17 +5,17 @@
 package expr
 
 const (
-	paramCount     = "count"
-	paramItem      = "item"
-	paramParts     = "parts"
-	paramSeparator = "separator"
-	paramSource    = "source"
-	paramSuffix    = "suffix"
-	paramPrefix    = "prefix"
-	paramStart     = "start"
-	paramEnd       = "end"
-	paramValue     = "value"
-	paramEllipsis  = "..."
-	paramFilepath  = "filepath"
-	paramDirpath   = "dirpath"
+	ParamCount     = "count"
+	ParamItem      = "item"
+	ParamParts     = "parts"
+	ParamSeparator = "separator"
+	ParamSource    = "source"
+	ParamSuffix    = "suffix"
+	ParamPrefix    = "prefix"
+	ParamStart     = "start"
+	ParamEnd       = "end"
+	ParamValue     = "value"
+	ParamEllipsis  = "..."
+	ParamFilepath  = "filepath"
+	ParamDirpath   = "dirpath"
 )

function.go

@@ -42,59 +42,6 @@ func (functor *baseFunctor) GetFunc() ExprFunc {
 	return functor.info
 }
 
-// ---- Linking with Go functions
-type golangFunctor struct {
-	baseFunctor
-	f FuncTemplate
-}
-
-func NewGolangFunctor(f FuncTemplate) *golangFunctor {
-	return &golangFunctor{f: f}
-}
-
-func (functor *golangFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
-	return functor.f(ctx, name, args)
-}
-
-// ---- Linking with Expr functions
-type exprFunctor struct {
-	baseFunctor
-	params []ExprFuncParam
-	expr   Expr
-	defCtx ExprContext
-}
-
-// func newExprFunctor(e Expr, params []string, ctx ExprContext) *exprFunctor {
-// 	return &exprFunctor{expr: e, params: params, defCtx: ctx}
-// }
-
-func newExprFunctor(e Expr, params []ExprFuncParam, ctx ExprContext) *exprFunctor {
-	return &exprFunctor{expr: e, params: params, defCtx: ctx}
-}
-
-func (functor *exprFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
-	if functor.defCtx != nil {
-		ctx.Merge(functor.defCtx)
-	}
-
-	for i, p := range functor.params {
-		if i < len(args) {
-			arg := args[i]
-			if funcArg, ok := arg.(Functor); ok {
-				// ctx.RegisterFunc(p, functor, 0, -1)
-				paramSpecs := funcArg.GetParams()
-				ctx.RegisterFunc(p.Name(), funcArg, TypeAny, paramSpecs)
-			} else {
-				ctx.UnsafeSetVar(p.Name(), arg)
-			}
-		} else {
-			ctx.UnsafeSetVar(p.Name(), nil)
-		}
-	}
-	result, err = functor.expr.Eval(ctx)
-	return
-}
-
 // ---- Function Parameters
 type paramFlags uint16
 

global-context.go

@@ -12,8 +12,8 @@ import (
 var globalCtx *SimpleStore
 
 func ImportInContext(name string) (exists bool) {
-	var mod *module
-	if mod, exists = moduleRegister[name]; exists {
+	var mod *builtinModule
+	if mod, exists = builtinModuleRegister[name]; exists {
 		mod.importFunc(globalCtx)
 		mod.imported = true
 	}
@@ -22,7 +22,7 @@ func ImportInContext(name string) (exists bool) {
 
 func ImportInContextByGlobPattern(pattern string) (count int, err error) {
 	var matched bool
-	for name, mod := range moduleRegister {
+	for name, mod := range builtinModuleRegister {
 		if matched, err = filepath.Match(pattern, name); err == nil {
 			if matched {
 				count++

helpers.go

@@ -41,7 +41,7 @@ func EvalStringV(source string, args []Arg) (result any, err error) {
 				functor := NewGolangFunctor(f)
 				// ctx.RegisterFunc(arg.Name, functor, 0, -1)
 				ctx.RegisterFunc(arg.Name, functor, TypeAny, []ExprFuncParam{
-					NewFuncParamFlagDef(paramValue, PfDefault|PfRepeat, 0),
+					NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, 0),
 				})
 			} else {
 				err = fmt.Errorf("invalid function specification: %q", arg.Name)

module-register.go

@@ -1,48 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// module-register.go
-package expr
-
-import (
-	"fmt"
-)
-
-type module struct {
-	importFunc  func(ExprContext)
-	description string
-	imported    bool
-}
-
-func newModule(importFunc func(ExprContext), description string) *module {
-	return &module{importFunc, description, false}
-}
-
-var moduleRegister map[string]*module
-
-func registerImport(name string, importFunc func(ExprContext), description string) {
-	if moduleRegister == nil {
-		moduleRegister = make(map[string]*module)
-	}
-	if _, exists := moduleRegister[name]; exists {
-		panic(fmt.Errorf("module %q already registered", name))
-	}
-	moduleRegister[name] = newModule(importFunc, description)
-}
-
-func IterateModules(op func(name, description string, imported bool) bool) {
-	if op != nil {
-		for name, mod := range moduleRegister {
-			if !op(name, mod.description, mod.imported) {
-				break
-			}
-		}
-	}
-}
-
-// ----
-func init() {
-	if moduleRegister == nil {
-		moduleRegister = make(map[string]*module)
-	}
-}

operator-coalesce.go

@@ -68,7 +68,7 @@ func evalAssignCoalesce(ctx ExprContext, self *term) (v any, err error) {
 		if functor, ok := rightValue.(Functor); ok {
 			//ctx.RegisterFunc(leftTerm.source(), functor, 0, -1)
 			ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, []ExprFuncParam{
-				NewFuncParamFlag(paramValue, PfDefault|PfRepeat),
+				NewFuncParamFlag(ParamValue, PfDefault|PfRepeat),
 			})
 		} else {
 			v = rightValue

t_module-register_test.go

@@ -12,7 +12,7 @@ func TestIterateModules(t *testing.T) {
 	section := "Module-Register"
 
 	mods := make([]string, 0, 100)
-	IterateModules(func(name, description string, imported bool) bool {
+	IterateBuiltinModules(func(name, description string, imported bool) bool {
 		mods = append(mods, name)
 		return true
 	})