Normal pred and delta pred are now treated as different types of rule.

bin/inlining.ml

@@ -1,5 +1,13 @@
 open Birds
 
+let parse_inlining_mode arg =
+  if String.starts_with ~prefix:"+" arg then
+    Inlining.InliningPredType.Deltainsert, String.sub arg 1 (String.length arg - 1)
+  else if String.starts_with ~prefix:"-" arg then
+    Inlining.InliningPredType.Deltadelete, String.sub arg 1 (String.length arg - 1)
+  else
+    Inlining.InliningPredType.Pred, arg
+
 let _ =
   if Array.length Sys.argv < 2 then
     print_endline "Invalid arguments. File name must be passed."
@@ -13,7 +21,11 @@ let _ =
       if Array.length Sys.argv < 3 then
         Inlining.All
       else
-        let target = Inlining.TableNameSet.singleton Sys.argv.(2) in
+        let target =
+          Sys.argv.(2)
+          |> parse_inlining_mode
+          |> Inlining.TableNameSet.singleton
+        in
         Inlining.Just target
     in
     match Inlining.inline_rules mode rules with

examples/inlining5.dl

@@ -0,0 +1,6 @@
+a(X) :- X = 1.
+a(X) :- X = 2.
++a(X) :- a(X), X = 1.
++a(X) :- a(X), X = 2.
+
++f(X) :- +a(X).

src/inlining.ml

@@ -2,7 +2,31 @@
 open Expr
 open Utils
 
-module TableNameSet = Set.Make(String)
+module InliningPredType = struct
+  type t =
+    | Pred
+    | Deltainsert
+    | Deltadelete
+
+  let compare (type1 : t) (type2 : t) : int =
+    match (type1, type2) with
+    | (Pred, Pred)               -> 0
+    | (Pred, _)                  -> 1
+    | (_, Pred)                  -> -1
+    | (Deltainsert, Deltainsert) -> 0
+    | (Deltainsert, _)           -> 1
+    | (_, Deltainsert)           -> -1
+    | (Deltadelete, Deltadelete) -> 0
+end
+
+module TableNameSet = Set.Make(struct
+  type t = InliningPredType.t * string
+
+  let compare (type1, name1) (type2, name2) =
+    match InliningPredType.compare type1 type2 with
+    | 0 -> String.compare name1 name2
+    | c -> c
+end)
 
 (** Select whether all predicates should be inlining or only certain predicates should be inlining. *)
 type inlining_mode =
@@ -450,9 +474,9 @@ let is_inlined (mode : inlining_mode) (pred : intermediate_predicate) : bool =
   | All -> true
   | Just tables -> tables |> TableNameSet.mem (
     match pred with
-    | ImPred table -> table
-    | ImDeltaInsert table -> table
-    | ImDeltaDelete table -> table
+    | ImPred table -> InliningPredType.Pred, table
+    | ImDeltaInsert table -> InliningPredType.Deltainsert, table
+    | ImDeltaDelete table -> InliningPredType.Deltadelete, table
   )
 
 (** `inline_rule_abstraction state improg_inlined ruleabs` performs inlining of `ruleabs`

test/inlining_test.ml

@@ -237,7 +237,7 @@ let main () =
         *
         *    f(X) :- a(X), NOT b(X).
         *)
-        mode = Inlining.Just (Inlining.TableNameSet.singleton "a");
+        mode = Inlining.Just (Inlining.TableNameSet.singleton (Inlining.InliningPredType.Pred, "a"));
         expected = make_lines [
           "a(X) :- X = 1.";
           "a(X) :- X = 2.";
@@ -265,14 +265,96 @@ let main () =
         *
         *    f(X) :- a(X), NOT b(X).
         *)
-        mode = Inlining.Just (Inlining.TableNameSet.singleton "b");
+        mode = Inlining.Just (Inlining.TableNameSet.singleton (Inlining.InliningPredType.Pred, "b"));
         expected = make_lines [
           "a(X) :- X = 1.";
           "a(X) :- X = 2.";
           "b(X) :- X = 1.";
           "b(X) :- X = 2.";
           "f(X) :- a(X) , not b(X).";
         ]
+      };
+      {
+        title = "inlining rules specified a target (3)";
+        input = [
+          (!: "a" ["X"], [Equat (Equation ("=", Var (NamedVar "X"), Const (Int 1)))]);
+          (!: "a" ["X"], [Equat (Equation ("=", Var (NamedVar "X"), Const (Int 2)))]);
+          (!+ "a" ["X"], [Rel (Pred ("a", [NamedVar "X"])); Equat (Equation ("=", Var (NamedVar "X"), Const (Int 1)))]);
+          (!+ "a" ["X"], [Rel (Pred ("a", [NamedVar "X"])); Equat (Equation ("=", Var (NamedVar "X"), Const (Int 2)))]);
+          (!+ "f" ["X"], [Rel (Deltainsert ("a", [NamedVar "X"]))])
+        ];
+        (* Input:
+        *    a(X) :- X = 1.
+        *    a(X) :- X = 2.
+        *    +a(X) :- a(X), X = 1.
+        *    +a(X) :- a(X), X = 2.
+        *
+        *    +f(X) :- +a(X).
+        *)
+        mode = Inlining.Just (Inlining.TableNameSet.singleton (Inlining.InliningPredType.Pred, "a"));
+        expected = make_lines [
+          "+a(X) :- X = 1 , X = 1.";
+          "+a(X) :- X = 1 , X = 2.";
+          "+a(X) :- X = 2 , X = 1.";
+          "+a(X) :- X = 2 , X = 2.";
+          "+f(X) :- +a(X).";
+          "a(X) :- X = 1.";
+          "a(X) :- X = 2.";
+        ]
+      };
+      {
+        title = "inlining rules specified a target (4)";
+        input = [
+          (!: "a" ["X"], [Equat (Equation ("=", Var (NamedVar "X"), Const (Int 1)))]);
+          (!: "a" ["X"], [Equat (Equation ("=", Var (NamedVar "X"), Const (Int 2)))]);
+          (!+ "a" ["X"], [Rel (Pred ("a", [NamedVar "X"])); Equat (Equation ("=", Var (NamedVar "X"), Const (Int 1)))]);
+          (!+ "a" ["X"], [Rel (Pred ("a", [NamedVar "X"])); Equat (Equation ("=", Var (NamedVar "X"), Const (Int 2)))]);
+          (!+ "f" ["X"], [Rel (Deltainsert ("a", [NamedVar "X"]))])
+        ];
+        (* Input:
+        *    a(X) :- X = 1.
+        *    a(X) :- X = 2.
+        *    +a(X) :- a(X), X = 1.
+        *    +a(X) :- a(X), X = 2.
+        *
+        *    +f(X) :- +a(X).
+        *)
+        mode = Inlining.Just (Inlining.TableNameSet.singleton (Inlining.InliningPredType.Deltainsert, "a"));
+        expected = make_lines [
+          "+a(X) :- a(X) , X = 1.";
+          "+a(X) :- a(X) , X = 2.";
+          "+f(X) :- a(X) , X = 1.";
+          "+f(X) :- a(X) , X = 2.";
+          "a(X) :- X = 1.";
+          "a(X) :- X = 2.";
+        ]
+      };
+      {
+        title = "inlining rules specified a target (5)";
+        input = [
+          (!: "a" ["X"], [Equat (Equation ("=", Var (NamedVar "X"), Const (Int 1)))]);
+          (!: "a" ["X"], [Equat (Equation ("=", Var (NamedVar "X"), Const (Int 2)))]);
+          (!- "a" ["X"], [Rel (Pred ("a", [NamedVar "X"])); Equat (Equation ("=", Var (NamedVar "X"), Const (Int 1)))]);
+          (!- "a" ["X"], [Rel (Pred ("a", [NamedVar "X"])); Equat (Equation ("=", Var (NamedVar "X"), Const (Int 2)))]);
+          (!+ "f" ["X"], [Rel (Deltadelete ("a", [NamedVar "X"]))])
+        ];
+        (* Input:
+        *    a(X) :- X = 1.
+        *    a(X) :- X = 2.
+        *    -a(X) :- a(X), X = 1.
+        *    -a(X) :- a(X), X = 2.
+        *
+        *    +f(X) :- -a(X).
+        *)
+        mode = Inlining.Just (Inlining.TableNameSet.singleton (Inlining.InliningPredType.Deltadelete, "a"));
+        expected = make_lines [
+          "-a(X) :- a(X) , X = 1.";
+          "-a(X) :- a(X) , X = 2.";
+          "+f(X) :- a(X) , X = 1.";
+          "+f(X) :- a(X) , X = 2.";
+          "a(X) :- X = 1.";
+          "a(X) :- X = 2.";
+        ]
       }
     ]
   in