Question

Another problem, I have a good working “function” for deleting:

remove([],X,[]) :- !. 
remove([X|T],X,L1) :- !, remove(T,X,L1).         
remove([H|T],X,[H|L1]) :- remove(T,X,L1). 

But it doesn’t work like I want it to work.
It removes element or even list…

…but doesn’t remove all appearances. This is goal:

remove([A,B,[C],[A,[B]],[[A,[B]]]],[A,[B]],X).
X=[A,B,[C],[]]

Any ideas?

Answer 1

If you would like to remove all appearances e.g., to let remove([1,2,3,1],1,X) calculate X=[2,3] just replace the second clause with

 remove([X|T],X,L1) :- remove(T,X,L1), !.  

However, it seems that you would like a) to work with variables that should be kept as variables and b) to remove lists from sublists.

We will start with solving the b) issue first.

remove([],_,[]) :- !. 
remove(A,_,A) :- \+ (A = [_|_]), !.
remove([X|T],X,L1) :- remove(T,X,L1), !.        
remove([H|T],X,[G|L1]) :- remove(H,X,G), remove(T,X,L1).

As you see we add a second recursive call to the last clause to take care of the internal list. Moreover, we had to add a special case (the second clause) since the first argument is not necessarily a list.

Finally, to solve a) you need to use the “freeze” / “melt” predicates of Sterling and Shapiro. freeze replaces variables with expressions #VAR(0), #VAR(1), … and melt does the opposite. Melt is traditionally known as melt_new

numvars('#VAR'(N),N,N1) :- N1 is N+1.
numvars(Term,N1,N2) :- nonvar(Term), functor(Term,_,N),
                          numvars(0,N,Term,N1,N2).

numvars(N,N,_,N1,N1).
numvars(I,N,Term,N1,N3) :- I<N, I1 is I+1,
          arg(I1,Term,Arg), numvars(Arg,N1,N2),
          numvars(I1,N,Term,N2,N3).

frz(A,B) :- frz(A,B,0).
frz(A,B,Min) :- copy_term(A,B), numvars(B,Min,_),!.


melt_new(A,B) :-
   melt(A,B,Dictionary), !.

melt('$VAR'(N),X,Dictionary) :-
    lookup(N,Dictionary,X).
melt(X,X,Dictionary) :-
    constant(X).
melt(X,Y,Dictionary) :-
    compound(X),
    functor(X,F,N),
    functor(Y,F,N),
    melt(N,X,Y,Dictionary).

melt(N,X,Y,Dictionary) :-
    N > 0, 
    arg(N,X,ArgX), 
    melt(ArgX,ArgY,Dictionary),
    arg(N,Y,ArgY), 
    N1 is N-1, 
    melt(N1,X,Y,Dictionary).
melt(0,X,Y,Dictionary).

/*  
    lookup(Key,Dictionary,Value) :-
    Dictionary contains the value indexed under Key.
    Dictionary is represented as an ordered binary tree.

*/

    lookup(Key,dict(Key,X,Left,Right),Value) :-
        !, X = Value.
    lookup(Key,dict(Key1,X,Left,Right),Value) :-
        Key < Key1 , lookup(Key,Left,Value).
    lookup(Key,dict(Key1,X,Left,Right),Value) :-
        Key > Key1, lookup(Key,Right,Value).

By the way, I really recommend the book of Sterling and Shapiro “The Art of Prolog”.
Melting and freezing are discussed in Chapter 15.