add logical operators "And", &&, "Or", ||

Author: seborama

README.md

@@ -12,7 +12,7 @@
 
 A simple but powerful expression parser and evaluator in Go.
 
-This is a research project.
+This project started as a personal research.
 
 ## Examples
 
@@ -86,34 +86,65 @@ func main() {
 }
 ```
 
+## Type interfaces
+
+`gal` comes with  pre-defined type interfaces: Numberer, Booler, Stringer (and maybe more in the future).
+
+They allow the general use of types. For instance, the String `"123"` can be converted to the Number `123`.
+With `Numberer`, a user-defined function can transparently use String and Number when both hold a number representation.
+
+A user-defined function can do this:
+
+```go
+n := args[0].(gal.Numberer).Number()
+```
+
+or, for additional type safety:
+
+```go
+if value, ok := args[0].(gal.Numberer); !ok {
+    return gal.NewUndefinedWithReasonf("NaN '%s'", args[0])
+}
+n := value.Number()
+/* ... */
+```
+
+Both examples will happily accept a `Value` of type `String` or `Number` and process it as if it were a `Number`.
+
 ## Numbers
 
 Numbers implement arbitrary precision fixed-point decimal arithmetic with [shopspring/decimal](https://github.com/shopspring/decimal).
 
 ## Supported operations
 
-* Operators: `+` `-` `*` `/` `%` `**` `<<` `>>` `<` `<=` `==` `!=` `>` `>=`
+* Operators: `+` `-` `*` `/` `%` `**` `<<` `>>` `<` `<=` `==` `!=` `>` `>=` `And` `&&` `Or` `||`
     * [Precedence](https://en.wikipedia.org/wiki/Order_of_operations#Programming_languages), highest to lowest:
         * `**`
         * `*` `/` `%`
         * `+` `-`
         * `<<` `>>`
         * `<` `<=` `==` `!=` `>` `>=`
-    * Note: Go classifies bit shift operators with the higher `*`.
+        * `And` `&&` `Or` `||`
+    * Notes:
+        * Go classifies bit shift operators with the higher `*`.
+        * `&&` is synonymous of `And`.
+        * `||` is synonymous of `Or`.
 * Types: String, Number, Bool
-* Associativity with parentheses
+* Associativity with parentheses: `(` and `)`
 * Functions:
     * Built-in: pi, cos, floor, sin, sqrt, trunc, and more (see `function.go`: `Eval()`)
     * User-defined, injected via `WithFunctions()`
 * Variables, defined as `:variable_name:` and injected via `WithVariables()`
 
 ## Functions
 
+A function is defined as a Go type: `type FunctionalValue func(...Value) Value`
+
 Function names are case-insensitive.
 
 A function can optionally accept one or more **space-separated** arguments, but it must return a single `Value`.
 
-It should be noted that a `MultiValue` type is available that can hold multiple `Value`. A function can use `MultiValue` as its return type to effectively return multiple `Value`'s. Of course, as `MultiValue` is a `Value` type, functions can also accept it as part of their argument(s). Refer to the tests (`TestMultiValueFunctions`) for such examples.
+It should be noted that a `MultiValue` type is available that can hold multiple `Value` elements. A function can use `MultiValue` as its return type to effectively return multiple `Value`'s. Of course, as `MultiValue` is a `Value` type, functions can also accept it as part of their argument(s). Refer to the test `TestMultiValueFunctions`, for an example.
 
 User function definitions are passed as a `map[string]FunctionalValue` using `WithFunctions` when calling `Eval` from `Tree`.
 

gal.go

@@ -13,6 +13,7 @@ const (
 )
 
 type Value interface {
+	// Calculation
 	Add(Value) Value
 	Sub(Value) Value
 	Multiply(Value) Value
@@ -21,12 +22,16 @@ type Value interface {
 	Mod(Value) Value
 	LShift(Value) Value
 	RShift(Value) Value
+	// Logical
 	LessThan(Value) Bool
 	LessThanOrEqual(Value) Bool
 	EqualTo(Value) Bool
 	NotEqualTo(Value) Bool
 	GreaterThan(Value) Bool
 	GreaterThanOrEqual(Value) Bool
+	And(Value) Bool
+	Or(Value) Bool
+	// Helpers
 	Stringer
 	entry
 }

gal_test.go

@@ -114,6 +114,22 @@ func TestEval_Boolean(t *testing.T) {
 	expr = `3 == 2`
 	val = gal.Parse(expr).Eval()
 	assert.Equal(t, gal.False.String(), val.String())
+
+	expr = `( 123 == 123 && 12 <= 45 ) Or ( "a" != "b" )`
+	val = gal.Parse(expr).Eval()
+	assert.Equal(t, gal.True.String(), val.String())
+
+	expr = `( 123 == 123 && 12 <= 45 ) Or ( "b" != "b" )`
+	val = gal.Parse(expr).Eval()
+	assert.Equal(t, gal.True.String(), val.String())
+
+	expr = `( 123 == 123 && 12 > 45 ) Or ( "b" == "b" )`
+	val = gal.Parse(expr).Eval()
+	assert.Equal(t, gal.True.String(), val.String())
+
+	expr = `( 123 == 123 And 12 > 45 ) Or ( "b" != "b" )`
+	val = gal.Parse(expr).Eval()
+	assert.Equal(t, gal.False.String(), val.String())
 }
 
 func TestWithVariablesAndFunctions(t *testing.T) {

operator.go

@@ -26,6 +26,10 @@ const (
 	NotEqualTo         Operator = "!="
 	GreaterThan        Operator = ">"
 	GreaterThanOrEqual Operator = ">="
+	And                Operator = "And" // TODO: case sentive for now
+	And2               Operator = "&&"
+	Or                 Operator = "Or" // TODO: case sentive for now
+	Or2                Operator = "||"
 )
 
 func powerOperators(o Operator) bool {
@@ -49,3 +53,8 @@ func comparativeOperators(o Operator) bool {
 		o == LessThan || o == LessThanOrEqual ||
 		o == EqualTo || o == NotEqualTo
 }
+
+func logicalOperators(o Operator) bool {
+	return o == And || o == And2 ||
+		o == Or || o == Or2
+}

tree.go

@@ -106,7 +106,8 @@ func (tree Tree) Eval(opts ...treeOption) Value {
 		Calc(multiplicativeOperators, cfg).
 		Calc(additiveOperators, cfg).
 		Calc(bitwiseShiftOperators, cfg).
-		Calc(comparativeOperators, cfg)
+		Calc(comparativeOperators, cfg).
+		Calc(logicalOperators, cfg)
 
 	// TODO: refactor this
 	// perhaps add Tree.Value() which tests that only one entry is left and that it is a Value
@@ -187,6 +188,7 @@ func (tree Tree) Calc(isOperatorInPrecedenceGroup func(Operator) bool, cfg *tree
 		case operatorEntryKind:
 			op = e.(Operator)
 			if isOperatorInPrecedenceGroup(op) {
+				// same operator precedence: keep operating linearly, do not build a tree
 				continue
 			}
 			if val != nil {
@@ -318,6 +320,12 @@ func calculate(lhs Value, op Operator, rhs Value) Value {
 	case GreaterThanOrEqual:
 		outVal = lhs.GreaterThanOrEqual(rhs)
 
+	case And, And2:
+		outVal = lhs.And(rhs)
+
+	case Or, Or2:
+		outVal = lhs.Or(rhs)
+
 	default:
 		return NewUndefinedWithReasonf("unimplemented operator: '%s'", op.String())
 	}

tree_builder.go

@@ -63,12 +63,20 @@ func (tb TreeBuilder) FromExpr(expr string) (Tree, error) {
 				tree = append(tree, LShift)
 			case RShift.String():
 				tree = append(tree, RShift)
+			case And.String():
+				tree = append(tree, And)
+			case And2.String():
+				tree = append(tree, And2) // NOTE: re-route to And?
+			case Or.String():
+				tree = append(tree, Or)
+			case Or2.String():
+				tree = append(tree, Or2) // NOTE: re-route to Or?
 			default:
 				return nil, errors.Errorf("unknown operator: '%s'", part)
 			}
 
 		case functionType:
-			fname, l, _ := readFunctionName(part)
+			fname, l, _ := readFunctionName(part)          // ignore err: we already parsed the function name when in extractPart()
 			v, err := tb.FromExpr(part[l+1 : len(part)-1]) // exclude leading '(' and trailing ')'
 			if err != nil {
 				return nil, err
@@ -97,7 +105,7 @@ func (tb TreeBuilder) FromExpr(expr string) (Tree, error) {
 		idx += length
 	}
 
-	// adjust trees that start with "Plus" or "Minus" followed by a "numberer"
+	// adjust trees that start with "Plus" or "Minus" followed by a "Numberer"
 	if tree.TrunkLen() >= 2 {
 		switch tree[0] {
 		case Plus:
@@ -149,14 +157,18 @@ func extractPart(expr string) (string, exprType, int, error) {
 	// conceptually, parenthesis grouping is a special case of anonymous identity function
 	if expr[pos] == '(' || (expr[pos] >= 'a' && expr[pos] <= 'z') || (expr[pos] >= 'A' && expr[pos] <= 'Z') {
 		fname, lf, err := readFunctionName(expr[pos:])
-		if err != nil {
-			return "", unknownType, 0, err
-		}
-		fargs, la, err := readFunctionArguments(expr[pos+lf:])
-		if err != nil {
+		switch {
+		case errors.Is(err, errFunctionNameWithoutParens):
+			// allow to continue so we can check alphanumerical operator names such as "And", "Or", etc
+		case err != nil:
 			return "", unknownType, 0, err
+		default:
+			fargs, la, err := readFunctionArguments(expr[pos+lf:])
+			if err != nil {
+				return "", unknownType, 0, err
+			}
+			return fname + fargs, functionType, pos + lf + la, nil
 		}
-		return fname + fargs, functionType, pos + lf + la, nil
 	}
 
 	// read part - operator
@@ -220,6 +232,8 @@ func readVariable(expr string) (string, int, error) {
 	return expr[:to], to, nil
 }
 
+var errFunctionNameWithoutParens = errors.New("function with Parenthesis")
+
 func readFunctionName(expr string) (string, int, error) {
 	to := 0 // this could be an anonymous identity function (i.e. simple case of parenthesis grouping)
 
@@ -228,7 +242,7 @@ func readFunctionName(expr string) (string, int, error) {
 			return expr[:to], to, nil
 		}
 		if isBlankSpace(r) {
-			return "", 0, errors.Errorf("syntax error: invalid character '%c' for function name '%s'", r, expr[:to])
+			return expr[:to], to, errFunctionNameWithoutParens
 		}
 		to += 1
 	}
@@ -324,28 +338,35 @@ func isBlankSpace(r rune) bool {
 }
 
 func readOperator(s string) (string, int) {
-	if strings.HasPrefix(s, Power.String()) ||
-		strings.HasPrefix(s, LShift.String()) ||
-		strings.HasPrefix(s, RShift.String()) ||
-		strings.HasPrefix(s, EqualTo.String()) ||
-		strings.HasPrefix(s, NotEqualTo.String()) ||
-		strings.HasPrefix(s, GreaterThanOrEqual.String()) ||
-		strings.HasPrefix(s, LessThanOrEqual.String()) {
+	switch {
+	case strings.HasPrefix(s, And.String()):
+		return s[:3], 3
+
+	case strings.HasPrefix(s, Power.String()),
+		strings.HasPrefix(s, LShift.String()),
+		strings.HasPrefix(s, RShift.String()),
+		strings.HasPrefix(s, EqualTo.String()),
+		strings.HasPrefix(s, NotEqualTo.String()),
+		strings.HasPrefix(s, GreaterThanOrEqual.String()),
+		strings.HasPrefix(s, LessThanOrEqual.String()),
+		strings.HasPrefix(s, And2.String()),
+		strings.HasPrefix(s, Or.String()),
+		strings.HasPrefix(s, Or2.String()):
 		return s[:2], 2
-	}
 
-	if strings.HasPrefix(s, Plus.String()) ||
-		strings.HasPrefix(s, Minus.String()) ||
-		strings.HasPrefix(s, Divide.String()) ||
-		strings.HasPrefix(s, Multiply.String()) ||
-		strings.HasPrefix(s, Power.String()) ||
-		strings.HasPrefix(s, Modulus.String()) ||
-		strings.HasPrefix(s, GreaterThan.String()) ||
-		strings.HasPrefix(s, LessThan.String()) {
+	case strings.HasPrefix(s, Plus.String()),
+		strings.HasPrefix(s, Minus.String()),
+		strings.HasPrefix(s, Divide.String()),
+		strings.HasPrefix(s, Multiply.String()),
+		strings.HasPrefix(s, Power.String()),
+		strings.HasPrefix(s, Modulus.String()),
+		strings.HasPrefix(s, GreaterThan.String()),
+		strings.HasPrefix(s, LessThan.String()):
 		return s[:1], 1
-	}
 
-	return "", 0
+	default:
+		return "", 0
+	}
 }
 
 func isOperator(s string) bool {

value.go

@@ -482,6 +482,24 @@ func (b Bool) Not() Bool {
 	return NewBool(!b.value)
 }
 
+func (b Bool) And(other Value) Bool {
+	if v, ok := other.(Booler); ok {
+		return NewBool(b.value && v.Bool().value)
+	}
+	return False // TODO: should Bool be a Maybe?
+}
+
+func (b Bool) Or(other Value) Bool {
+	if v, ok := other.(Booler); ok {
+		return NewBool(b.value || v.Bool().value)
+	}
+	return False // TODO: should Bool be a Maybe?
+}
+
+func (b Bool) Bool() Bool {
+	return b
+}
+
 func (b Bool) String() string { // TODO: return String rather than string?
 	if b.value {
 		return "true"
@@ -571,6 +589,16 @@ func (Undefined) RShift(Value) Value {
 	return Undefined{}
 }
 
+func (Undefined) And(other Value) Bool {
+	// perhaps this should be a panic... Or else Bool should be a Maybe?
+	return False
+}
+
+func (Undefined) Or(other Value) Bool {
+	// perhaps this should be a panic... Or else Bool should be a Maybe?
+	return False
+}
+
 func (u Undefined) String() string {
 	if u.reason == "" {
 		return "undefined"