`copy_term/[2,3]`

[ISO]`copy_term(`

`+Term``, `

`-Copy``)`

Makes a copy of `Term`
in which all variables have been replaced by new variables
that occur nowhere outside the newly created term.

`copy_term(`

`+Term``, `

`-Copy``, `

`-Body``)`

Furthermore, if `Term` contains attributed variables,
unifies `Body` with a term such that executing `Body`
will reinstate equivalent attributes on the variables in `Copy`.
Otherwise, `Body` is unified with `true`

.

`Term`- term
`Copy`- term
`Body`- callable

Independent copies are substituted for any mutable terms in
`term`. It behaves as if defined by:

copy_term(X, Y) :- assert('copy of'(X)), retract('copy of'(Y)).

The implementation of `copy_term/2`

conserves space by not copying
ground subterms.

When you call `clause/[2,3]`

or `instance/2`

, you get a new copy
of the term stored in the database, in precisely
the same sense that `copy_term/2`

gives you a new copy.

- A naive way to attempt to find out whether one term is a copy of another:
identical_but_for_variables(X, Y) :- \+ \+ ( numbervars(X, 0, N), numbervars(Y, 0, N), X = Y ).

This solution is sometimes sufficient, but will not work if the two terms have any variables in common.

- If you want the test to succeed even when the two terms do have
some variables in common, you need to copy one of them; for example,
identical_but_for_variables(X, Y) :- \+ \+ ( copy_term(X, Z), numbervars(Z, 0, N), numbervars(Y, 0, N), Z = Y ).

Send feedback on this subject.