duplicate_term is now copy_term

diff --git a/README.md b/README.md
index 1339b10ec6bdfe7d32aaf0fde76ae9d37271be5d..59a1f09eb2df410f9c2514774b4b0bacc97af5a3 100644 (file)
--- a/README.md
+++ b/README.md
@@ -138,8 +138,8 @@ The following predicates are built-in to rusty-wam.
 * `catch/3`
 * `compare/3`
 * `compound/1`
+* `copy_term/2`
 * `cyclic_term/1`
-* `duplicate_term/2`
 * `false/0`
 * `float/1`
 * `functor/3`

diff --git a/src/prolog/instructions.rs b/src/prolog/instructions.rs
index eff385ab0043cb2605132fb04be1f8de46c5b83b..b43671a33fd63ef96601b513a49c284540a17b24 100644 (file)
--- a/src/prolog/instructions.rs
+++ b/src/prolog/instructions.rs
@@ -325,7 +325,7 @@ pub enum BuiltInClauseType {
     CompareTerm(CompareTermQT),
     CyclicTerm,
     Writeq,
-    DuplicateTerm,
+    CopyTerm,
     Eq,
     Functor,
     Ground,
@@ -377,7 +377,7 @@ impl BuiltInClauseType {
             &BuiltInClauseType::CompareTerm(qt) => clause_name!(qt.name()),
             &BuiltInClauseType::CyclicTerm => clause_name!("cyclic_term"),
             &BuiltInClauseType::Writeq => clause_name!("writeq"),
-            &BuiltInClauseType::DuplicateTerm => clause_name!("duplicate_term"),
+            &BuiltInClauseType::CopyTerm => clause_name!("copy_term"),
             &BuiltInClauseType::Eq => clause_name!("=="),
             &BuiltInClauseType::Functor => clause_name!("functor"),
             &BuiltInClauseType::Ground  => clause_name!("ground"),
@@ -398,7 +398,7 @@ impl BuiltInClauseType {
             &BuiltInClauseType::CompareTerm(_) => 2,
             &BuiltInClauseType::CyclicTerm => 1,
             &BuiltInClauseType::Writeq => 1,
-            &BuiltInClauseType::DuplicateTerm => 2,
+            &BuiltInClauseType::CopyTerm => 2,
             &BuiltInClauseType::Eq => 2,
             &BuiltInClauseType::Functor => 3,
             &BuiltInClauseType::Ground  => 1,
@@ -424,7 +424,7 @@ impl BuiltInClauseType {
             ("\\=@=", 2) => Some(BuiltInClauseType::CompareTerm(CompareTermQT::NotEqual)),
             ("=@=", 2) => Some(BuiltInClauseType::CompareTerm(CompareTermQT::Equal)),
             ("writeq", 1) => Some(BuiltInClauseType::Writeq),
-            ("duplicate_term", 2) => Some(BuiltInClauseType::DuplicateTerm),
+            ("copy_term", 2) => Some(BuiltInClauseType::CopyTerm),
             ("==", 2) => Some(BuiltInClauseType::Eq),
             ("functor", 3) => Some(BuiltInClauseType::Functor),
             ("ground", 1) => Some(BuiltInClauseType::Ground),

diff --git a/src/prolog/machine/machine_state.rs b/src/prolog/machine/machine_state.rs
index 04e67939a267f80a26cc229af0baeec643f1bc4a..0caf4785a688d280cc082380eca6fce4c85d674b 100644 (file)
--- a/src/prolog/machine/machine_state.rs
+++ b/src/prolog/machine/machine_state.rs
@@ -588,7 +588,7 @@ pub(crate) trait CallPolicy: Any {
                 println!("{}", output.result());
                 return_from_clause!(machine_st.last_call, machine_st)
             },
-            &BuiltInClauseType::DuplicateTerm => {
+            &BuiltInClauseType::CopyTerm => {
                 machine_st.duplicate_term();
                 return_from_clause!(machine_st.last_call, machine_st)
             },

diff --git a/src/tests.rs b/src/tests.rs
index 0afcd720466ee3b078c90a27d0395a9dc10606ec..d5b8eb882e9cae8bb6885e0c850beeb7cfb74837 100644 (file)
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -1477,25 +1477,25 @@ fn test_queries_on_builtins()
     assert_prolog_success!(&mut wam, "?- catch(length(a, []), error(E, _), true).",
                            [["E = type_error(integer, [])"]]);
 
-    assert_prolog_success!(&mut wam, "?- duplicate_term([1,2,3], [X,Y,Z]).",
+    assert_prolog_success!(&mut wam, "?- copy_term([1,2,3], [X,Y,Z]).",
                            [["Z = 3", "Y = 2", "X = 1"]]);
-    assert_prolog_success!(&mut wam, "?- duplicate_term(f(X, [a], Z), f(X, Y, Z)).",
+    assert_prolog_success!(&mut wam, "?- copy_term(f(X, [a], Z), f(X, Y, Z)).",
                            [["X = _3", "Y = [a]", "Z = _5"]]);
-    assert_prolog_failure!(&mut wam, "?- duplicate_term(g(X), f(X)).");
-    assert_prolog_success!(&mut wam, "?- duplicate_term(f(X), f(X)).",
+    assert_prolog_failure!(&mut wam, "?- copy_term(g(X), f(X)).");
+    assert_prolog_success!(&mut wam, "?- copy_term(f(X), f(X)).",
                            [["X = _1"]]);
-    assert_prolog_success!(&mut wam, "?- duplicate_term([[[[X, Y], Y], X]], Term).",
+    assert_prolog_success!(&mut wam, "?- copy_term([[[[X, Y], Y], X]], Term).",
                            [["Term = [[[[_22, _26], _26], _22]]", "X = _2", "Y = _0"]]);
-    assert_prolog_success!(&mut wam, "?- duplicate_term([X, [Y, [X]]], Term).",
+    assert_prolog_success!(&mut wam, "?- copy_term([X, [Y, [X]]], Term).",
                            [["Term = [_12, [_16, [_12]]]", "X = _0", "Y = _4"]]);
 
-    // test duplicate_term on cyclic terms.
-    assert_prolog_failure!(&mut wam, "?- X = g(X, Y), Y = f(X), duplicate_term(Y, g(Z)).");
-    assert_prolog_success!(&mut wam, "?- X = g(X, Y), Y = f(X), duplicate_term(Y, f(Z)).",
+    // test copy_term on cyclic terms.
+    assert_prolog_failure!(&mut wam, "?- X = g(X, Y), Y = f(X), copy_term(Y, g(Z)).");
+    assert_prolog_success!(&mut wam, "?- X = g(X, Y), Y = f(X), copy_term(Y, f(Z)).",
                            [["Y = f(g(X, Y))", "X = g(X, f(X))", "Z = g(Z, f(Z))"]]);
-    assert_prolog_success!(&mut wam, "?- X = g(X, Y), Y = f(X), duplicate_term(Y, V).",
+    assert_prolog_success!(&mut wam, "?- X = g(X, Y), Y = f(X), copy_term(Y, V).",
                            [["Y = f(g(X, Y))", "X = g(X, f(X))", "V = f(g(_9, V))"]]);
-    assert_prolog_success!(&mut wam, "?- f(Y,Y,[X,a,[],Y]) = Term, duplicate_term(Term, NewTerm).",
+    assert_prolog_success!(&mut wam, "?- f(Y,Y,[X,a,[],Y]) = Term, copy_term(Term, NewTerm).",
                            [["NewTerm = f(_16, _16, [_19, a, [], _16])",
                              "Term = f(_0, Y, [_6, a, [], Y])",
                              "X = _6", "Y = _0"]]);