diff --git a/common-params.go b/common-params.go
index 2eb0bf5..ed7519a 100644
--- a/common-params.go
+++ b/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"
 )
diff --git a/func-base.go b/func-base.go
index 6bb067e..cd84923 100644
--- a/func-base.go
+++ b/func-base.go
@@ -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.")
+	RegisterImport("base", ImportBuiltinsFuncs, "Base expression tools like isNil(), int(), etc.")
 }
diff --git a/func-import.go b/func-import.go
index 48c5f93..0422ea5 100644
--- a/func-import.go
+++ b/func-import.go
@@ -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()")
+	RegisterImport("import", ImportImportFuncs, "Functions import() and include()")
 }
diff --git a/func-math.go b/func-math.go
index aa06c93..fd0ca8e 100644
--- a/func-math.go
+++ b/func-math.go
@@ -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()")
+	RegisterImport("math.arith", ImportMathFuncs, "Functions add() and mul()")
 }
diff --git a/func-os.go b/func-os.go
index d0b1616..f13833d 100644
--- a/func-os.go
+++ b/func-os.go
@@ -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")
+	RegisterImport("os.file", ImportOsFuncs, "Operating system file functions")
 }
diff --git a/func-string.go b/func-string.go
index 90719f7..22c8f5d 100644
--- a/func-string.go
+++ b/func-string.go
@@ -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")
+	RegisterImport("string", ImportStringFuncs, "string utilities")
 }
diff --git a/helpers.go b/helpers.go
index 671f240..f25fa10 100644
--- a/helpers.go
+++ b/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)
diff --git a/module-register.go b/module-register.go
index d583882..23de228 100644
--- a/module-register.go
+++ b/module-register.go
@@ -20,7 +20,7 @@ func newModule(importFunc func(ExprContext), description string) *module {
 
 var moduleRegister map[string]*module
 
-func registerImport(name string, importFunc func(ExprContext), description string) {
+func RegisterImport(name string, importFunc func(ExprContext), description string) {
 	if moduleRegister == nil {
 		moduleRegister = make(map[string]*module)
 	}
diff --git a/operator-coalesce.go b/operator-coalesce.go
index 3f32ea1..e811605 100644
--- a/operator-coalesce.go
+++ b/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