Concurrent constraint logic programming

This is the most evident effect of an intended directionality of the interpreter, which never revise a choice it has previously taken.

This difference affects whether choices can be undone, whether processes are allowed not to terminate, and how goals and clause heads are equated.

The first semantical difference between regular and concurrent constraint logic programming is about the condition when more than one clause can be used for proving a goal.

The concurrent version of constraint logic programming implements processes by allowing them to take choices, but committing to them once they have been taken.

If a goal cannot be rewritten because all clauses that could be used have a guard that is not entailed by the constraint store, the process solving this goal is blocked until the other processes add the constraints that are necessary to entail the guard of at least one of the applicable clauses.

A third effect of the difference between concurrent and non-concurrent logic programming is in the way a goal is equated to the head of a fresh variant of a clause.

given the current constraint store; contrary to regular logic programming, this is done under one-sided unification, which only allows a variable of the head to be equal to a term.

This method for deciding the applicability of a fresh variant of a clause for replacing a goal can be compactly expressed as follows: the current constraint store entails that there exists an evaluation of the variables of the head and the guard such that the head is equal to the goal and the guard is entailed.

An extension to the syntax and semantics of concurrent logic programming is the atomic tell.

Due to commitment to this clause, the interpreter does not backtrack if the constraints of the body are inconsistent with the store.

This condition can be avoided by the use of atomic tell, which is a variant in which the clause contain a sort of "second guard" that is only checked for consistency.

The theoretical properties of concurrent constraint logic programming were later studied by various authors, including Martin Rinard and Vijay A.