:=
Entity: predicate

has_to
Entity: predicate

Usage:
X is Y
X := Y
X has_to Y

The predicates is, := (colon equal) and has_to (unstable assignment) calculate the expression Y and bound it with the variable X. The predicates := and has_to can also be used to set the value of elements of array (example: array(N) := Y) or to set properties of OLE server (example: Server.property := Y).

Where is the difference?
The evaluation := (colon equal) is the simplest one. It simply throws out the old value of the variable X and sets its new value to the value of the expression Y. The effect of this evaluation will remain after backtracking (i.e. it is stable on backtracking). So := works in the same way as the normal evaluation which you have in common programming languages like C and Basic. This evaluation is not typical for Prolog where you usually make calculations with backtracking. Anyway, this predicate is useful because it gives you the possibility to keep some values after the backtracking (usually you keep these values in global variables or in arrays).

More typical for Prolog are the evaluations is and has_to because after the backtracking they will return the previous value of X. This will give you the possibility to make calculations with backtracking. Usually in one Prolog program you are looking for the answer by searching in the tree of all possible answers (name of this tree is the SLD tree). When you find answer in the SLD tree you will like to see only this answer and the effect of the program to be the same as if it found this answer directly without wandering in the SLD tree. So, if you make calculations you will like to see only the result of these calculations which were made on the right path. All calculations which were made on the wrong (backtracking) paths should be ignored. So this will be the effect if you use the evaluation is or has_to.

The difference between is and has_to is that is requires from X to be free variable in order to bind it with the value of Y. On the contrary, has_to does not need this because it will ignore the old value of X and will replace it with the value of Y (in the same way as := is doing). Anyway, has_to is different from := because after backtracking has_to will restore the old value of X district from :=, which will not do anything on backtracking.

How does has_to set property of OLE server. First, it calls the method GET in order to get the old value of the property. After that, it calls method SET in order to set the new value. After that, on backtracking, it calls the method SET again in order to restore the old value.

The evaluation has_to is typical for Strawberry Prolog. It is in some sense between is and :=. In some sense has_to is more powerful than is because it can change the old value of the variable X. For example, if you want to make a counter which is restored after backtracking you cannot use is because C is C+1 will fail but C has_to C+1 will work as a counter whose value is restored after backtracking. A good example of the use of has_to is the Sudoku.pro game where has_to is used in order to generate the Sudoku task.

Which one of these three evaluations to use?
If you don't know which one or if it doesn't matter which one use the predicate is. This is the most typical Prolog evaluation and very often it gives the result that the program works despite the fact that we do not know why. In other programming languages you cannot make a program which works accidentally but in Prolog it is possible and this is the main advantage of this language.
 

Example for has_to (Try to replace has_to with := and with is.)

?- s(X), X=a, s(X), X has_to b, s(X), fail.

s(X).

s(X) :- write(X), nl, fail.