Copilot commented on code in PR #4604:
URL:
https://github.com/apache/incubator-kie-docs/pull/4604#discussion_r4376246569
##########
drools-docs/src/modules/ROOT/pages/rule-engine/_phreak-sequential-mode-con.adoc:
##########
@@ -60,3 +60,11 @@ When you enable sequential mode, the {RULE_ENGINE} evaluates
rules in the follow
Because the left-input tuple memory is disabled, the tuples propagate down the
network and are joined with the right-input objects, but they are not retained
in the left input.
The right-input node memories are the same as in the default mode: Phreak uses
indexed memories when the constraints can be indexed, and an object list
otherwise.
+
+== Behavior of `modify`, `update`, `insert`, and `delete` in sequential mode
+
+In the typical use of sequential mode, rules only read facts and do not use
`modify`, `update`, `insert`, or `delete` in their consequences (right-hand
side). In this case, all rules see the facts exactly as they were at initial
insert time.
Review Comment:
“At initial insert time” is a bit ambiguous (e.g., insert time per fact vs.
start of rule execution). Consider clarifying the point in time more explicitly
(for example, “as they were when rule execution starts / before any rule
consequences run”) to make the semantics unambiguous.
##########
drools-docs/src/modules/ROOT/pages/rule-engine/_phreak-sequential-mode-con.adoc:
##########
@@ -21,9 +21,9 @@ with the License. You may obtain a copy of the License at
= Sequential mode in Phreak
-Sequential mode is an advanced rule base configuration in the {RULE_ENGINE},
supported by Phreak, that enables the {RULE_ENGINE} to evaluate rules one time
in the order that they are listed in the {RULE_ENGINE} agenda without regard to
changes in the working memory. In sequential mode, the {RULE_ENGINE} ignores
any `insert`, `modify`, or `update` statements in rules and executes rules in a
single sequence. As a result, rule execution may be faster in sequential mode,
but important updates may not be applied to your rules.
+Sequential mode is an advanced rule base configuration in the {RULE_ENGINE},
supported by Phreak, that enables the {RULE_ENGINE} to evaluate each rule
exactly once, in salience order. Because each rule is evaluated only once
without re-evaluation, rule execution may be faster in sequential mode, but the
{RULE_ENGINE} does not perform inference (iterative re-evaluation of rules
based on changes).
Review Comment:
“Evaluate each rule exactly once” can be read as “each rule fires once”,
which is typically not true for rules with multiple matches. Consider
rephrasing to explicitly distinguish LHS evaluation (no
re-evaluation/inference) from firing (which may still occur multiple times for
different tuples) to avoid misleading readers.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
