embrace native types: evaluate objects/vectors with native child values instead of wrapped ones

Author: xrstf

README.md

@@ -66,7 +66,7 @@ from GitHub.
     Examples:
 
     * `rudi '.foo' myfile.json`
-    * `rudi '(set .foo "bar") (set .users 42) .' myfile.json`
+    * `rudi '(set! .foo "bar") (set! .users 42) .' myfile.json`
     * `rudi --script convert.rudi myfile.json`
 
 `rudi` has extensive help built right into it, try running `rudi help` to get started.
@@ -118,7 +118,7 @@ func main() {
       // functions like "if" and "and", so running with an empty function set
       // is generally not advisable).
       rudi.NewBuiltInFunctions(),
-      // decide what kind of type strictness you would like; pedantic, strict
+      // Decide what kind of type strictness you would like; pedantic, strict
       // or humane; choose your own adventure (strict is default if you use nil
       // here; humane allows conversions like 1 == "1").
       coalescing.NewStrict(),

pkg/deepcopy/deepcopy.go

@@ -61,9 +61,9 @@ func clone(val any) (any, error) {
 	case string:
 		return asserted, nil
 	case map[string]any:
-		return cloneObject(asserted)
+		return cloneMap(asserted)
 	case []any:
-		return cloneVector(asserted)
+		return cloneSlice(asserted)
 
 	// pointer to Go types
 
@@ -129,7 +129,7 @@ func clone(val any) (any, error) {
 	}
 }
 
-func cloneVector(obj []any) ([]any, error) {
+func cloneSlice(obj []any) ([]any, error) {
 	result := make([]any, len(obj))
 	for i, item := range obj {
 		cloned, err := clone(item)
@@ -143,7 +143,7 @@ func cloneVector(obj []any) ([]any, error) {
 	return result, nil
 }
 
-func cloneObject(obj map[string]any) (map[string]any, error) {
+func cloneMap(obj map[string]any) (map[string]any, error) {
 	result := map[string]any{}
 	for key, value := range obj {
 		cloned, err := clone(value)

pkg/eval/builtin/comparisons.go

@@ -23,6 +23,11 @@ func eqFunction(ctx types.Context, args []ast.Expression) (any, error) {
 		return nil, fmt.Errorf("argument #0: %w", err)
 	}
 
+	leftData, err = types.WrapNative(leftData)
+	if err != nil {
+		return nil, fmt.Errorf("argument #0: %w", err)
+	}
+
 	leftValue, ok := leftData.(ast.Literal)
 	if !ok {
 		return nil, fmt.Errorf("argument #0 is not a literal, but %T", leftData)
@@ -33,6 +38,11 @@ func eqFunction(ctx types.Context, args []ast.Expression) (any, error) {
 		return nil, fmt.Errorf("argument #1: %w", err)
 	}
 
+	rightData, err = types.WrapNative(rightData)
+	if err != nil {
+		return nil, fmt.Errorf("argument #1: %w", err)
+	}
+
 	rightValue, ok := rightData.(ast.Literal)
 	if !ok {
 		return nil, fmt.Errorf("argument #1 is not a literal, but %T", rightData)
@@ -43,7 +53,7 @@ func eqFunction(ctx types.Context, args []ast.Expression) (any, error) {
 		return nil, err
 	}
 
-	return ast.Bool(equal), nil
+	return equal, nil
 }
 
 func likeFunction(ctx types.Context, args []ast.Expression) (any, error) {
@@ -56,6 +66,11 @@ func likeFunction(ctx types.Context, args []ast.Expression) (any, error) {
 		return nil, fmt.Errorf("argument #0: %w", err)
 	}
 
+	leftData, err = types.WrapNative(leftData)
+	if err != nil {
+		return nil, fmt.Errorf("argument #0: %w", err)
+	}
+
 	leftValue, ok := leftData.(ast.Literal)
 	if !ok {
 		return nil, fmt.Errorf("argument #0 is not a literal, but %T", leftData)
@@ -66,6 +81,11 @@ func likeFunction(ctx types.Context, args []ast.Expression) (any, error) {
 		return nil, fmt.Errorf("argument #1: %w", err)
 	}
 
+	rightData, err = types.WrapNative(rightData)
+	if err != nil {
+		return nil, fmt.Errorf("argument #1: %w", err)
+	}
+
 	rightValue, ok := rightData.(ast.Literal)
 	if !ok {
 		return nil, fmt.Errorf("argument #1 is not a literal, but %T", rightData)
@@ -76,11 +96,11 @@ func likeFunction(ctx types.Context, args []ast.Expression) (any, error) {
 		return nil, err
 	}
 
-	return ast.Bool(equal), nil
+	return equal, nil
 }
 
-type intProcessor func(left, right int64) (ast.Bool, error)
-type floatProcessor func(left, right float64) (ast.Bool, error)
+type intProcessor func(left, right int64) (bool, error)
+type floatProcessor func(left, right float64) (bool, error)
 
 func makeNumberComparatorFunc(inter intProcessor, floater floatProcessor, desc string) types.Function {
 	return types.BasicFunction(func(ctx types.Context, args []ast.Expression) (any, error) {