Rules

A rule in CLAIRE is made by associating an event condition to an expression. The rule is attached to a set of free variables of given types: each time that an event that matches the condition becomes occurs for a given binding of the variables (i.e., association of one value to each variable), the expression will be evaluated with this binding. The interest of rules is to attach an expression not to a functional call (as with methods) but to an event, with a binding that is more flexible (many rules can be combined for one event) and more incremental.

A novelty in CLAIRE 3.0 is the introduction of event logic. There are two events that can be matched precisely: the update of a slot or a table, and the instantiation of a class. CLAIRE 3.2 use expressions called event pattern to specify which kind of events the rule is associated with. For instance, the expression x.r := y is an event expression that says both that x.r = y and that the last event is actually the update of x.r from a previous value. More precisely, here are the events that are supported :

• x.r := y, where r is a slot of x.
• a[x] := y, where a is a.
• x.r :add y, where r is a multi-valued slot of x (with range bag).
• a[x] :add y, where a is a multi-valued table.

In addition, a new event pattern was introduced in CLAIRE 3.0 to capture the transition from an old to a new value. This is achieved with the expression x.r := (z <- y) which says that the last event is the update of x.r from z to y. For instance, here is the event expression that states that x.salary crossed the 100000 limit :

x.salary := (y <- z) & y < 100000 & z >= 100000

In CLAIRE 3.2 we introduce the notion of a "pure" event. If a property p has no restrictions, then p(x,y) represents a virtual call to p with parameters x and y. This event may be used in a rule in a way similar to x.p := y, with the difference that it does not correspond to an update. Virtual events are very generic since one of the parameter may be arbitrarily complex (a list, a set, a tuple ...). The event filter associated to a virtual event is simply the expression "p(x,y)". To create such an event, one simply calls p(x,y), once a rule using such an event has been defined. As a matter of fact, the definition of a rule using p(x,y) as an event pattern will provoke the creation of a generic method p that creates the event.

Virtual event may be used for many purposes. The creation of a virtual event requires no time nor memory; thus, it is a convenient technique to capture state transition in your object system. For instance, we can create an event signaling the instantiation of a class as follows :

instantiation :: property(domain = myClass, range = string)  [close(x:MyClass) : MyClass -> instantiation(x,date!(1)), x]  controlRule() :: rule(instantiation(x,s) => printf("--- create ~S at ~A \n",x,s))

To define a rule, we must indeed define :

• a condition, which is the combination of an event pattern and a CLAIRE Boolean expression using the same variables
• a conclusion that is preceded by =>.

For instance, let us define the following rule to fill the table fib with the Fibonacci sequence :

r3() :: rule(y := fib[x] & x % (0 .. 100)          => when z := get(fib,x - 1) in fib[x + 1] := y + z)  (fib[0] := 1, fib[1] := 1)