🚀 go-pugleaf

> Saumya K. Debray writes:
> This is an excerpt from an article posted recently to another newsgroup:
>| 	increment(Variable) :-
>| 		retract(value(Variable, OldValue)),
>| 		NewValue is OldValue + 1,
>| 		assert(value(Variable, NewValue)).

> Michael Coleman writes:
>
>Every once in a while something comes along to help us remember why languages
>like COBOL, Fortran, and friends still reign supreme.
>

It's not _quite_ as bad as that.  Retract/modify/assert sequences such
as this can be optimized to destructive assignment.  A clever implementation
can turn the whole clause into an indexed increment in 68K machine language.

Prologs that don't implement such an optimization may provide a destructive
assignment operator so the user can at least avoid retract & assert. Hidden
away in ALS Prolog is such an operator, appropriately named "mangle".

Thus increment/1 could be implemented as:

increment(Variable) :-

	clause(VarList,true),
	arg(Variable,VarList,Value),
	NewValue is Value + 1,
	mangle(Variable,VarList,NewValue).

However, mangle has a clean-up cost associated with it.  The ALS
manual warns that mangle is not necessarily more efficient than
term-copying for that reason.  I suspect, though, that it is _much_ more
efficient than retract/modify/assert.