Strange behaviour with rules that call the same function

[janmpo]

Dear team,

I'm having a look to this rule engine, and I write the below code and as you could see three rules call this function: MF.N = MF.GetMult(x);.

GetMult just multiplies the MF.N by the parameter (x).

The issue: If the three has the same number in this case 2 I got as result 4.000, instead of 8 / 16.000. if I put different numbers such MF.GetMult(3); MF.GetMult(5); and MF.GetMult(2); I got a multiplier of 30 which turns in the correct answer 60.000.

What am I doing wrongly?

Regards

Antonio

package main

import (
"fmt"

"github.com/hyperjumptech/grule-rule-engine/ast"
"github.com/hyperjumptech/grule-rule-engine/builder"
"github.com/hyperjumptech/grule-rule-engine/engine"
"github.com/hyperjumptech/grule-rule-engine/pkg"

)

type MyFact struct {
A string
B string
C string
D string
M float64
N float64
}

func main() {
kb := ast.NewKnowledgeLibrary()
rb := builder.NewRuleBuilder(kb)

drls := `
rule SetN "Sets N" salience 20 {
	when
		MF.N == 0
	then
		MF.N = MF.M;
		Retract("SetN");
		Log("Set N called");
}
rule CheckA "Check A" salience 11 {
	when
		MF.A == "A"
	then
		MF.N = MF.GetMult(2);
		Retract("CheckA");
		Log("Check A called");
}
rule CheckB "Check B" salience 12 {
	when
		MF.B == "B"
	then
		MF.N = MF.GetMult(2);
		Retract("CheckB");
		Log("Check B called");
}
rule CheckCD "Check C&D" salience 13 {
	when
		MF.C == "C" && MF.D == "D"
	then
		MF.N = MF.GetMult(2);
		Retract("CheckCD");
		Log("Check C&D called");
}`

myFact := &MyFact{
	A: "A",
	B: "B",
	C: "C",
	D: "D",
	M: 2000,
}

dataCtx := ast.NewDataContext()
err := dataCtx.Add("MF", myFact)
if err != nil {
	panic(err)
}

// Add the rule definition above into the library and name it 'TutorialRules'  version '0.0.1'
bs := pkg.NewBytesResource([]byte(drls))
err = rb.BuildRuleFromResource("TutorialRules", "0.0.1", bs)
if err != nil {
	panic(err)
}

knowledgeBase, _ := kb.NewKnowledgeBaseInstance("TutorialRules", "0.0.1")

engine := engine.NewGruleEngine()
err = engine.Execute(dataCtx, knowledgeBase)
if err != nil {
	panic(err)
}

// Expected myFact.N 2000*2*2*2 = 16000
fmt.Println(myFact.N)

}

func (mf *MyFact) GetMult(factor int64) float64 {

return float64(factor) * mf.N

}

[janmpo]

Opened Issue #419.

[ivoshm]

@janmpo

There is a simple (but not very elegant) solution: add a Forget() function after every statement that is repeated in the rule set (in your case MF.GetMult(2);)

Working example:

rule SetN "Sets N" salience 20 {
when
	MF.N == 0
then
	MF.N = MF.M;
	Retract("SetN");
	Log("Set N called");
}
rule CheckA "Check A" salience 11 {
when
	MF.A == "A"
then
	MF.N = MF.GetMult(2);
	Forget("MF.GetMult(2)"); // HERE
	Retract("CheckA");
	Log("Check A called");
}
rule CheckB "Check B" salience 12 {
when
	MF.B == "B"
then
	MF.N = MF.GetMult(2);
	Forget("MF.GetMult(2)");  // HERE
	Retract("CheckB");
	Log("Check B called");
}
rule CheckCD "Check C&D" salience 13 {
when
	MF.C == "C" && MF.D == "D"
then
	MF.N = MF.GetMult(2);
	Forget("MF.GetMult(2)");  // HERE
	Retract("CheckCD");
	Log("Check C&D called");
}

Result: 16000

This is due to overly aggressive use of caching, not only for all variables, but also for all expressions.

An elegant option would be to be able to indicate that I don't want to cache the output of the expression when calling it - for example, I would like to be able to put an exclamation mark (or any other special character like 🗑 :) ) after the expression to indicate that I don't want to cache this expression (e.g. MF.N = MF.GetMult(2)!;).

The implementation would probably not be complicated, but I don't dare to interfere with the AST parsing and processing.

[janmpo]

@ivoshm

Thanks for your explanation!

I tried it and it works! Actually, by understanding your explanation I added a random parameter to the function MF.GetMult(number, random) where random represents a way to avoid the catching you specified and works also, as the parameters are completely different. The random parameter is used for nothing else but to avoid the catching by calling same function and different parameters.