introduce identical?

Author: xrstf

pkg/eval/builtin/comparisons.go

@@ -14,50 +14,24 @@ import (
 	"go.xrstf.de/rudi/pkg/lang/ast"
 )
 
-func eqFunction(ctx types.Context, args []ast.Expression) (any, error) {
-	if size := len(args); size != 2 {
-		return nil, fmt.Errorf("expected exactly 2 arguments, got %d", size)
-	}
-
-	_, leftData, err := eval.EvalExpression(ctx, args[0])
-	if err != nil {
-		return nil, fmt.Errorf("argument #0: %w", err)
-	}
-
-	_, rightData, err := eval.EvalExpression(ctx, args[1])
-	if err != nil {
-		return nil, fmt.Errorf("argument #1: %w", err)
-	}
-
-	equal, err := equality.EqualCoalesced(ctx.Coalesce(), leftData, rightData)
-	if err != nil {
-		return nil, err
-	}
-
-	return equal, nil
-}
-
-func likeFunction(ctx types.Context, args []ast.Expression) (any, error) {
-	if size := len(args); size != 2 {
-		return nil, fmt.Errorf("expected exactly 2 arguments, got %d", size)
-	}
-
-	_, leftData, err := eval.EvalExpression(ctx, args[0])
-	if err != nil {
-		return nil, fmt.Errorf("argument #0: %w", err)
-	}
+func makeEqualityFunc(coalescerGetter func(ctx types.Context) coalescing.Coalescer, desc string) types.Function {
+	return types.BasicFunction(func(ctx types.Context, args []ast.Expression) (any, error) {
+		if size := len(args); size != 2 {
+			return nil, fmt.Errorf("expected exactly 2 arguments, got %d", size)
+		}
 
-	_, rightData, err := eval.EvalExpression(ctx, args[1])
-	if err != nil {
-		return nil, fmt.Errorf("argument #1: %w", err)
-	}
+		_, leftData, err := eval.EvalExpression(ctx, args[0])
+		if err != nil {
+			return nil, fmt.Errorf("argument #0: %w", err)
+		}
 
-	equal, err := equality.EqualCoalesced(coalescing.NewHumane(), leftData, rightData)
-	if err != nil {
-		return nil, err
-	}
+		_, rightData, err := eval.EvalExpression(ctx, args[1])
+		if err != nil {
+			return nil, fmt.Errorf("argument #1: %w", err)
+		}
 
-	return equal, nil
+		return equality.EqualCoalesced(coalescerGetter(ctx), leftData, rightData)
+	}, desc)
 }
 
 type intProcessor func(left, right int64) (bool, error)

pkg/eval/builtin/funcs.go

@@ -4,6 +4,7 @@
 package builtin
 
 import (
+	"go.xrstf.de/rudi/pkg/coalescing"
 	"go.xrstf.de/rudi/pkg/eval/types"
 )
 
@@ -59,8 +60,15 @@ var Functions = types.Functions{
 	"not": types.BasicFunction(notFunction, "negates the given argument"),
 
 	// comparisons
-	"eq?":   types.BasicFunction(eqFunction, "equality check: return true if both arguments are the same"),
-	"like?": types.BasicFunction(likeFunction, `like eq?, but does lossless type conversions so 1 == "1"`),
+	"eq?": makeEqualityFunc(func(ctx types.Context) coalescing.Coalescer {
+		return ctx.Coalesce()
+	}, "equality check: return true if both arguments are the same"),
+	"identical?": makeEqualityFunc(func(ctx types.Context) coalescing.Coalescer {
+		return coalescing.NewStrict()
+	}, "like eq?, but always uses strict coalecsing"),
+	"like?": makeEqualityFunc(func(ctx types.Context) coalescing.Coalescer {
+		return coalescing.NewHumane()
+	}, "like eq?, but always uses humane coalecsing"),
 
 	"lt?": makeNumberComparatorFunc(
 		func(a, b int64) (bool, error) { return a < b, nil },