diff --git a/builtin-math-arith.go b/builtin-math-arith.go
index 977bf47..53d9bb8 100644
--- a/builtin-math-arith.go
+++ b/builtin-math-arith.go
@@ -34,8 +34,8 @@ func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result
 			if v, err = doAdd(ctx, name, subIter, count, level); err != nil {
 				break
 			}
-			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(cleanName) {
-				if _, err = extIter.CallOperation(cleanName, nil); err != nil {
+			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(CleanName) {
+				if _, err = extIter.CallOperation(CleanName, nil); err != nil {
 					return
 				}
 			}
@@ -107,8 +107,8 @@ func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result
 			if v, err = doMul(ctx, name, subIter, count, level); err != nil {
 				break
 			}
-			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(cleanName) {
-				if _, err = extIter.CallOperation(cleanName, nil); err != nil {
+			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(CleanName) {
+				if _, err = extIter.CallOperation(CleanName, nil); err != nil {
 					return
 				}
 			}
diff --git a/data-cursor.go b/data-cursor.go
index a241cf5..3f94eb0 100644
--- a/data-cursor.go
+++ b/data-cursor.go
@@ -20,7 +20,7 @@ type dataCursor struct {
 	currentFunc Functor
 }
 
-func newDataCursor(ctx ExprContext, ds map[string]Functor) (dc *dataCursor) {
+func NewDataCursor(ctx ExprContext, ds map[string]Functor) (dc *dataCursor) {
 	dc = &dataCursor{
 		ds:    ds,
 		index: -1,
@@ -29,6 +29,10 @@ func newDataCursor(ctx ExprContext, ds map[string]Functor) (dc *dataCursor) {
 	return
 }
 
+func (dc *dataCursor) Context() ExprContext {
+	return dc.ctx
+}
+
 func (dc *dataCursor) TypeName() string {
 	return "DataCursor"
 }
@@ -62,7 +66,7 @@ func (dc *dataCursor) String() string {
 }
 
 func (dc *dataCursor) HasOperation(name string) (exists bool) {
-	exists = name == indexName
+	exists = name == IndexName
 	if !exists {
 		f, ok := dc.ds[name]
 		exists = ok && isFunctor(f)
@@ -71,7 +75,7 @@ func (dc *dataCursor) HasOperation(name string) (exists bool) {
 }
 
 func (dc *dataCursor) CallOperation(name string, args []any) (value any, err error) {
-	if name == indexName {
+	if name == IndexName {
 		value = int64(dc.Index())
 	} else if functor, ok := dc.ds[name]; ok && isFunctor(functor) {
 		if functor == dc.cleanFunc {
@@ -93,7 +97,7 @@ func (dc *dataCursor) Reset() (success bool, err error) {
 	if dc.resetFunc != nil {
 		if dc.resource != nil {
 			ctx := cloneContext(dc.ctx)
-			if _, err = dc.resetFunc.Invoke(ctx, resetName, []any{dc.resource}); err == nil {
+			if _, err = dc.resetFunc.Invoke(ctx, ResetName, []any{dc.resource}); err == nil {
 				dc.index = -1
 			}
 			exportObjects(dc.ctx, ctx)
@@ -101,7 +105,7 @@ func (dc *dataCursor) Reset() (success bool, err error) {
 			err = errInvalidDataSource()
 		}
 	} else {
-		err = errNoOperation(resetName)
+		err = errNoOperation(ResetName)
 	}
 	success = err == nil
 	return
@@ -111,7 +115,7 @@ func (dc *dataCursor) Clean() (success bool, err error) {
 	if dc.cleanFunc != nil {
 		if dc.resource != nil {
 			ctx := cloneContext(dc.ctx)
-			_, err = dc.cleanFunc.Invoke(ctx, cleanName, []any{dc.resource})
+			_, err = dc.cleanFunc.Invoke(ctx, CleanName, []any{dc.resource})
 			dc.resource = nil
 			exportObjects(dc.ctx, ctx)
 		} else {
@@ -126,7 +130,7 @@ func (dc *dataCursor) Clean() (success bool, err error) {
 
 func (dc *dataCursor) Current() (item any, err error) { // must return io.EOF at the last item
 	ctx := cloneContext(dc.ctx)
-	if item, err = dc.currentFunc.Invoke(ctx, currentName, []any{}); err == nil && item == nil {
+	if item, err = dc.currentFunc.Invoke(ctx, CurrentName, []any{}); err == nil && item == nil {
 		err = io.EOF
 	}
 	exportObjects(dc.ctx, ctx)
@@ -167,7 +171,7 @@ func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err
 	var v any
 	var ok bool
 	ctx := cloneContext(dc.ctx)
-	if v, err = filter.Invoke(ctx, filterName, []any{item, dc.index}); err == nil && v != nil {
+	if v, err = filter.Invoke(ctx, FilterName, []any{item, dc.index}); err == nil && v != nil {
 		if accepted, ok = v.(bool); !ok {
 			accepted = true  // NOTE: A non-boolean value that is not nil means the item has been accepted
 		} 
@@ -177,19 +181,19 @@ func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err
 }
 func (dc *dataCursor) mapItem(mapper Functor, item any) (mappedItem any, err error) {
 	ctx := cloneContext(dc.ctx)
-	mappedItem, err = mapper.Invoke(ctx, mapName, []any{item, dc.index});
+	mappedItem, err = mapper.Invoke(ctx, MapName, []any{item, dc.index});
 	return
 }
 
 func (dc *dataCursor) Next() (item any, err error) { // must return io.EOF after the last item
 	var accepted bool
 	if dc.resource != nil {
-		filter := dc.ds[filterName]
-		mapper := dc.ds[mapName]
+		filter := dc.ds[FilterName]
+		mapper := dc.ds[MapName]
 
 		for item == nil && err == nil {
 			ctx := cloneContext(dc.ctx)
-			if item, err = dc.nextFunc.Invoke(ctx, nextName, []any{dc.resource}); err == nil {
+			if item, err = dc.nextFunc.Invoke(ctx, NextName, []any{dc.resource}); err == nil {
 				if item == nil {
 					err = io.EOF
 				} else {
diff --git a/iterator.go b/iterator.go
index 6efd2ce..0c5c82f 100644
--- a/iterator.go
+++ b/iterator.go
@@ -12,15 +12,15 @@ import (
 // Operator names
 
 const (
-	initName    = "init"
-	cleanName   = "clean"
-	resetName   = "reset"
-	nextName    = "next"
-	currentName = "current"
-	indexName   = "index"
-	countName   = "count"
-	filterName  = "filter"
-	mapName     = "map"
+	InitName    = "init"
+	CleanName   = "clean"
+	ResetName   = "reset"
+	NextName    = "next"
+	CurrentName = "current"
+	IndexName   = "index"
+	CountName   = "count"
+	FilterName  = "filter"
+	MapName     = "map"
 )
 
 type Iterator interface {
diff --git a/list-iterator.go b/list-iterator.go
index babb8a9..68e8c59 100644
--- a/list-iterator.go
+++ b/list-iterator.go
@@ -90,21 +90,21 @@ func (it *ListIterator) TypeName() string {
 }
 
 func (it *ListIterator) HasOperation(name string) bool {
-	yes := name == nextName || name == resetName || name == indexName || name == countName || name == currentName
+	yes := name == NextName || name == ResetName || name == IndexName || name == CountName || name == CurrentName
 	return yes
 }
 
 func (it *ListIterator) CallOperation(name string, args []any) (v any, err error) {
 	switch name {
-	case nextName:
+	case NextName:
 		v, err = it.Next()
-	case resetName:
+	case ResetName:
 		v, err = it.Reset()
-	case indexName:
+	case IndexName:
 		v = int64(it.Index())
-	case currentName:
+	case CurrentName:
 		v, err = it.Current()
-	case countName:
+	case CountName:
 		v = it.count
 	default:
 		err = errNoOperation(name)
diff --git a/operand-iterator.go b/operand-iterator.go
index c46294c..d452cc5 100644
--- a/operand-iterator.go
+++ b/operand-iterator.go
@@ -66,7 +66,7 @@ func evalFirstChild(ctx ExprContext, iteratorTerm *term) (value any, err error)
 
 func getDataSourceDict(iteratorTerm *term, firstChildValue any) (ds map[string]Functor, err error) {
 	if dictAny, ok := firstChildValue.(*DictType); ok {
-		requiredFields := []string{currentName, nextName}
+		requiredFields := []string{CurrentName, NextName}
 		fieldsMask := 0b11
 		foundFields := 0
 		ds = make(map[string]Functor)
@@ -108,8 +108,8 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
 	}
 
 	if ds != nil {
-		dc := newDataCursor(ctx, ds)
-		if initFunc, exists := ds[initName]; exists && initFunc != nil {
+		dc := NewDataCursor(ctx, ds)
+		if initFunc, exists := ds[InitName]; exists && initFunc != nil {
 			var args []any
 			if len(opTerm.children) > 1 {
 				if args, err = evalTermArray(ctx, opTerm.children[1:]); err != nil {
@@ -120,16 +120,16 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
 			}
 
 			initCtx := dc.ctx.Clone()
-			if dc.resource, err = initFunc.Invoke(initCtx, initName, args); err != nil {
+			if dc.resource, err = initFunc.Invoke(initCtx, InitName, args); err != nil {
 				return
 			}
 			exportObjects(dc.ctx, initCtx)
 		}
 
-		dc.nextFunc = ds[nextName]
-		dc.currentFunc = ds[currentName]
-		dc.cleanFunc = ds[cleanName]
-		dc.resetFunc = ds[resetName]
+		dc.nextFunc = ds[NextName]
+		dc.currentFunc = ds[CurrentName]
+		dc.cleanFunc = ds[CleanName]
+		dc.resetFunc = ds[ResetName]
 
 		v = dc
 	} else if list, ok := firstChildValue.(*ListType); ok {
diff --git a/operator-length.go b/operator-length.go
index e3db58d..0013fb7 100644
--- a/operator-length.go
+++ b/operator-length.go
@@ -34,8 +34,8 @@ func evalLength(ctx ExprContext, opTerm *term) (v any, err error) {
 		m, _ := childValue.(*DictType)
 		v = int64(len(*m))
 	} else if it, ok := childValue.(Iterator); ok {
-		if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(countName) {
-			count, _ := extIt.CallOperation(countName, nil)
+		if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(CountName) {
+			count, _ := extIt.CallOperation(CountName, nil)
 			v, _ = ToGoInt(count, "")
 		} else {
 			v = int64(it.Index() + 1)