Unifying with partially ground terms without unifying with completely unground terms?

I have a program where I want to take certain action on various list items,
if certain elements match a certain predicate name only.

For example, given the list:

[Var1, op(SubVar1), Var2, ...]

I have a predicate that 'walks' the list and only manipulates the term if it
is a op() predicate element.  To do this I wrote the following predicate:

% Determine if an element is an op() predicate without unifying with
unground variables.
is_op_term(OpTerm, Innards):-
OpTerm =.. [X | Args],
ground(X),
X = op,
Innards =.. Args,
!.

This works fine but it I wonder if there is a more elegant way to do this.
The problem with attempting to handle the op() predicate elements with a
clause like:

do_op([op(X) | T]):- % etc.

Is that the head of the list in the clause will unify with completely
unground variables, which is what I don't want. I only want grounded or
partially grounded variables that are currently instantiated to an op()
term.

I tried using 'not', hoping to test the element without unifying with it,
but ended up with a control error:

do_op([H | T]):-
not (H = op(X)),
!,
.. % etc.

So what's a better way to do this?

Thanks,
Robert.

--
Robert Oschler
http://www.robotsrule.com/phpBB2/
Robot & Android Discussion Forum

"Bart Demoen" <bmd@cs.kuleuven.ac.be> wrote in message
news:1098381980.720320@seven.kulnet.kuleuven.ac.be...
>
> Maybe something like
>
> is_op_term(OpTerm,Innards) :-
> nonvar(OpTerm),
> OpTerm = op(Innards).
>
> is what you need.
>
> Cheers
>
> Bart Demoen

Bart,

Thanks!