From 3196510a3db4568803e37d1447832c16a40821a4 Mon Sep 17 00:00:00 2001
From: Anton Medvedev <anton@medv.io>
Date: Sun, 18 Feb 2024 09:55:10 +0100
Subject: [PATCH] Fix naming

---
 expr.go                      |  4 ++--
 patcher/operator_override.go | 26 +++++++++++++-------------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/expr.go b/expr.go
index d9f7c0dc..ba786c01 100644
--- a/expr.go
+++ b/expr.go
@@ -42,9 +42,9 @@ func AllowUndefinedVariables() Option {
 // Operator allows to replace a binary operator with a function.
 func Operator(operator string, fn ...string) Option {
 	return func(c *conf.Config) {
-		p := &patcher.OperatorOverride{
+		p := &patcher.OperatorOverloading{
 			Operator:  operator,
-			Overrides: fn,
+			Overloads: fn,
 			Types:     c.Types,
 			Functions: c.Functions,
 		}
diff --git a/patcher/operator_override.go b/patcher/operator_override.go
index 428454f5..551fe09b 100644
--- a/patcher/operator_override.go
+++ b/patcher/operator_override.go
@@ -9,15 +9,15 @@ import (
 	"github.com/expr-lang/expr/conf"
 )
 
-type OperatorOverride struct {
-	Operator  string              // Operator token to override.
-	Overrides []string            // List of function names to override operator with.
+type OperatorOverloading struct {
+	Operator  string              // Operator token to overload.
+	Overloads []string            // List of function names to replace operator with.
 	Types     conf.TypesTable     // Env types.
 	Functions conf.FunctionsTable // Env functions.
-	applied   bool                // Flag to indicate if any override was applied.
+	applied   bool                // Flag to indicate if any changes were made to the tree.
 }
 
-func (p *OperatorOverride) Visit(node *ast.Node) {
+func (p *OperatorOverloading) Visit(node *ast.Node) {
 	binaryNode, ok := (*node).(*ast.BinaryNode)
 	if !ok {
 		return
@@ -42,11 +42,11 @@ func (p *OperatorOverride) Visit(node *ast.Node) {
 	}
 }
 
-func (p *OperatorOverride) ShouldRepeat() bool {
+func (p *OperatorOverloading) ShouldRepeat() bool {
 	return p.applied
 }
 
-func (p *OperatorOverride) FindSuitableOperatorOverload(l, r reflect.Type) (reflect.Type, string, bool) {
+func (p *OperatorOverloading) FindSuitableOperatorOverload(l, r reflect.Type) (reflect.Type, string, bool) {
 	t, fn, ok := p.findSuitableOperatorOverloadInFunctions(l, r)
 	if !ok {
 		t, fn, ok = p.findSuitableOperatorOverloadInTypes(l, r)
@@ -54,8 +54,8 @@ func (p *OperatorOverride) FindSuitableOperatorOverload(l, r reflect.Type) (refl
 	return t, fn, ok
 }
 
-func (p *OperatorOverride) findSuitableOperatorOverloadInTypes(l, r reflect.Type) (reflect.Type, string, bool) {
-	for _, fn := range p.Overrides {
+func (p *OperatorOverloading) findSuitableOperatorOverloadInTypes(l, r reflect.Type) (reflect.Type, string, bool) {
+	for _, fn := range p.Overloads {
 		fnType, ok := p.Types[fn]
 		if !ok {
 			continue
@@ -72,8 +72,8 @@ func (p *OperatorOverride) findSuitableOperatorOverloadInTypes(l, r reflect.Type
 	return nil, "", false
 }
 
-func (p *OperatorOverride) findSuitableOperatorOverloadInFunctions(l, r reflect.Type) (reflect.Type, string, bool) {
-	for _, fn := range p.Overrides {
+func (p *OperatorOverloading) findSuitableOperatorOverloadInFunctions(l, r reflect.Type) (reflect.Type, string, bool) {
+	for _, fn := range p.Overloads {
 		fnType, ok := p.Functions[fn]
 		if !ok {
 			continue
@@ -101,8 +101,8 @@ func checkTypeSuits(t reflect.Type, l reflect.Type, r reflect.Type, firstInIndex
 	return nil, false
 }
 
-func (p *OperatorOverride) Check() {
-	for _, fn := range p.Overrides {
+func (p *OperatorOverloading) Check() {
+	for _, fn := range p.Overloads {
 		fnType, foundType := p.Types[fn]
 		fnFunc, foundFunc := p.Functions[fn]
 		if !foundFunc && (!foundType || fnType.Type.Kind() != reflect.Func) {