implemented if expression parser

Numscript.g4

@@ -18,6 +18,8 @@ REMAINING: 'remaining';
 ALLOWING: 'allowing';
 UNBOUNDED: 'unbounded';
 OVERDRAFT: 'overdraft';
+IF: 'if';
+ELSE: 'else';
 KEPT: 'kept';
 SAVE: 'save';
 LPARENS: '(';
@@ -50,14 +52,20 @@ portion:
 	| PERCENTAGE_PORTION_LITERAL	# percentage;
 
 valueExpr:
-	VARIABLE_NAME											# variableExpr
-	| ASSET													# assetLiteral
-	| STRING												# stringLiteral
-	| ACCOUNT												# accountLiteral
-	| NUMBER												# numberLiteral
-	| monetaryLit											# monetaryLiteral
-	| portion												# portionLiteral
-	| left = valueExpr op = ('+' | '-') right = valueExpr	# infixExpr;
+	VARIABLE_NAME														# variableExpr
+	| ASSET																# assetLiteral
+	| STRING															# stringLiteral
+	| ACCOUNT															# accountLiteral
+	| NUMBER															# numberLiteral
+	| monetaryLit														# monetaryLiteral
+	| portion															# portionLiteral
+	| '!' valueExpr														# notExpr
+	| left = valueExpr op = ('+' | '-') right = valueExpr				# infixAddSubExpr
+	| left = valueExpr op = ('==' | '!=') right = valueExpr				# infixEqExpr
+	| left = valueExpr op = ('<' | '<=' | '>' | '>=') right = valueExpr	# infixCompExpr
+	| left = valueExpr op = '||' right = valueExpr						# infixOrExpr
+	| left = valueExpr op = '&&' right = valueExpr						# infixAndExpr
+	| '(' valueExpr ')'													# parensExpr;
 
 functionCallArgs: valueExpr ( COMMA valueExpr)*;
 functionCall:
@@ -79,6 +87,7 @@ allotment:
 
 source:
 	address = valueExpr ALLOWING UNBOUNDED OVERDRAFT						# srcAccountUnboundedOverdraft
+	| ifBranch = source IF valueExpr ELSE elseBranch = source				# sourceIf
 	| address = valueExpr ALLOWING OVERDRAFT UP TO maxOvedraft = valueExpr	#
 		srcAccountBoundedOverdraft
 	| valueExpr							# srcAccount
@@ -94,6 +103,7 @@ destinationInOrderClause: MAX valueExpr keptOrDestination;
 
 destination:
 	valueExpr																# destAccount
+	| ifBranch = destination IF valueExpr ELSE elseBranch = destination		# destIf
 	| LBRACE allotmentClauseDest+ RBRACE									# destAllotment
 	| LBRACE destinationInOrderClause* REMAINING keptOrDestination RBRACE	# destInorder;
 allotmentClauseDest: allotment keptOrDestination;

internal/analysis/check.go

@@ -11,6 +11,7 @@ import (
 const TypeMonetary = "monetary"
 const TypeAccount = "account"
 const TypePortion = "portion"
+const TypeBool = "bool"
 const TypeAsset = "asset"
 const TypeNumber = "number"
 const TypeString = "string"

internal/interpreter/batch_balances_query.go

@@ -141,6 +141,19 @@
 		}
 		return nil
 
+	case *parser.IfExpr[parser.Source]:
+		err := st.findBalancesQueries(source.IfBranch)
+		if err != nil {
+			return err
+		}
+
+		err = st.findBalancesQueries(source.ElseBranch)
+		if err != nil {
+			return err
+		}
+
+		return nil
+
 	default:
 		utils.NonExhaustiveMatchPanic[error](source)
 		return nil

internal/interpreter/evaluate_expr.go

@@ -2,6 +2,7 @@
 
 import (
 	"math/big"
+	"reflect"
 
 	"github.com/formancehq/numscript/internal/parser"
 	"github.com/formancehq/numscript/internal/utils"
@@ -42,16 +43,38 @@
 		}
 		return value, nil
 
-	// TypeError
 	case *parser.BinaryInfix:
-
 		switch expr.Operator {
 		case parser.InfixOperatorPlus:
 			return st.plusOp(expr.Left, expr.Right)
 
 		case parser.InfixOperatorMinus:
 			return st.subOp(expr.Left, expr.Right)
 
+		case parser.InfixOperatorEq:
+			return st.eqOp(expr.Left, expr.Right)
+
+		case parser.InfixOperatorNeq:
+			return st.neqOp(expr.Left, expr.Right)
+
+		case parser.InfixOperatorGt:
+			return st.gtOp(expr.Left, expr.Right)
+
+		case parser.InfixOperatorGte:
+			return st.gteOp(expr.Left, expr.Right)
+
+		case parser.InfixOperatorLt:
+			return st.ltOp(expr.Left, expr.Right)
+
+		case parser.InfixOperatorLte:
+			return st.lteOp(expr.Left, expr.Right)
+
+		case parser.InfixOperatorAnd:
+			return st.andOp(expr.Left, expr.Right)
+
+		case parser.InfixOperatorOr:
+			return st.orOp(expr.Left, expr.Right)
+
 		default:
 			utils.NonExhaustiveMatchPanic[any](expr.Operator)
 			return nil, nil
@@ -124,3 +147,147 @@
 
 	return (*leftValue).evalSub(st, right)
 }
+
+func (st *programState) eqOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
+	parsedLeft, err := evaluateExprAs(st, left, expectAnything)
+	if err != nil {
+		return nil, err
+	}
+
+	parsedRight, err := evaluateExprAs(st, right, expectAnything)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO remove reflect usage
+	return Bool(reflect.DeepEqual(parsedLeft, parsedRight)), nil
+}
+
+func (st *programState) neqOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
+	parsedLeft, err := evaluateExprAs(st, left, expectAnything)
+	if err != nil {
+		return nil, err
+	}
+
+	parsedRight, err := evaluateExprAs(st, right, expectAnything)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO remove reflect usage
+	return Bool(!(reflect.DeepEqual(parsedLeft, parsedRight))), nil
+}
+
+func (st *programState) ltOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
+	cmp, err := st.evaluateExprAsCmp(left)
+	if err != nil {
+		return nil, err
+	}
+
+	cmpResult, err := (*cmp).evalCmp(st, right)
+	if err != nil {
+		return nil, err
+	}
+
+	switch *cmpResult {
+	case -1:
+		return Bool(true), nil
+	default:
+		return Bool(false), nil
+	}
+
+}
+
+func (st *programState) gtOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
+	cmp, err := st.evaluateExprAsCmp(left)
+	if err != nil {
+		return nil, err
+	}
+
+	cmpResult, err := (*cmp).evalCmp(st, right)
+	if err != nil {
+		return nil, err
+	}
+
+	switch *cmpResult {
+	case 1:
+		return Bool(true), nil
+	default:
+		return Bool(false), nil
+	}
+}
+
+func (st *programState) lteOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
+	cmp, err := st.evaluateExprAsCmp(left)
+	if err != nil {
+		return nil, err
+	}
+
+	cmpResult, err := (*cmp).evalCmp(st, right)
+	if err != nil {
+		return nil, err
+	}
+
+	switch *cmpResult {
+	case -1, 0:
+		return Bool(true), nil
+	default:
+		return Bool(false), nil
+	}
+
+}
+
+func (st *programState) gteOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
+	cmp, err := st.evaluateExprAsCmp(left)
+	if err != nil {
+		return nil, err
+	}
+
+	cmpResult, err := (*cmp).evalCmp(st, right)
+	if err != nil {
+		return nil, err
+	}
+
+	switch *cmpResult {
+	case 1, 0:
+		return Bool(true), nil
+	default:
+		return Bool(false), nil
+	}
+}
+
+func (st *programState) andOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
+	parsedLeft, err := evaluateExprAs(st, left, expectBool)
+	if err != nil {
+		return nil, err
+	}
+
+	if !*parsedLeft {
+		return Bool(false), nil
+	}
+
+	parsedRight, err := evaluateExprAs(st, right, expectBool)
+	if err != nil {
+		return nil, err
+	}
+
+	return Bool(*parsedRight), nil
+}
+
+func (st *programState) orOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
+	parsedLeft, err := evaluateExprAs(st, left, expectBool)
+	if err != nil {
+		return nil, err
+	}
+
+	if *parsedLeft {
+		return Bool(true), nil
+	}
+
+	parsedRight, err := evaluateExprAs(st, right, expectBool)
+	if err != nil {
+		return nil, err
+	}
+
+	return Bool(*parsedRight), nil
+}

internal/interpreter/interpreter.go

@@ -83,9 +83,23 @@
 	return mon, nil
 }
 
+func parseBool(source string) (Bool, InterpreterError) {
+	switch source {
+	case "true":
+		return Bool(true), nil
+	case "false":
+		return Bool(false), nil
+
+	default:
+		return Bool(false), InvalidBoolLiteral{Source: source}
+	}
+}
+
 func parseVar(type_ string, rawValue string, r parser.Range) (Value, InterpreterError) {
 	switch type_ {
 	// TODO why should the runtime depend on the static analysis module?
+	case analysis.TypeBool:
+		return parseBool(rawValue)
 	case analysis.TypeMonetary:
 		return parseMonetary(rawValue)
 	case analysis.TypeAccount:
@@ -490,6 +504,18 @@
 	case *parser.SourceAllotment:
 		return nil, InvalidAllotmentInSendAll{}
 
+	case *parser.IfExpr[parser.Source]:
+		cond, err := evaluateExprAs(s, source.Condition, expectBool)
+		if err != nil {
+			return nil, err
+		}
+
+		if *cond {
+			return s.sendAll(source.IfBranch)
+		} else {
+			return s.sendAll(source.ElseBranch)
+		}
+
 	default:
 		utils.NonExhaustiveMatchPanic[error](source)
 		return nil, nil
@@ -595,6 +621,18 @@
 		}
 		return s.trySendingUpTo(source.From, cappedAmount)
 
+	case *parser.IfExpr[parser.Source]:
+		cond, err := evaluateExprAs(s, source.Condition, expectBool)
+		if err != nil {
+			return nil, err
+		}
+
+		if *cond {
+			return s.trySendingUpTo(source.IfBranch, amount)
+		} else {
+			return s.trySendingUpTo(source.ElseBranch, amount)
+		}
+
 	default:
 		utils.NonExhaustiveMatchPanic[any](source)
 		return nil, nil
@@ -675,6 +713,18 @@
 		// passing "remainingAmount" directly breaks the code
 		return handler(destination.Remaining, remainingAmountCopy)
 
+	case *parser.IfExpr[parser.Destination]:
+		cond, err := evaluateExprAs(s, destination.Condition, expectBool)
+		if err != nil {
+			return err
+		}
+
+		if *cond {
+			return s.receiveFrom(destination.IfBranch, amount)
+		} else {
+			return s.receiveFrom(destination.ElseBranch, amount)
+		}
+
 	default:
 		utils.NonExhaustiveMatchPanic[any](destination)
 		return nil

internal/interpreter/interpreter_error.go

@@ -27,6 +27,15 @@
 	return fmt.Sprintf("invalid monetary literal: '%s'", e.Source)
 }
 
+type InvalidBoolLiteral struct {
+	parser.Range
+	Source string
+}
+
+func (e InvalidBoolLiteral) Error() string {
+	return fmt.Sprintf("invalid bool literal: '%s'", e.Source)
+}
+
 type InvalidNumberLiteral struct {
 	parser.Range
 	Source string