View source with raw comments or as raw
    1/*  Part of SWI-Prolog
    2
    3    Author:        Jan Wielemaker and Richard O'Keefe
    4    E-mail:        J.Wielemaker@cs.vu.nl
    5    WWW:           http://www.swi-prolog.org
    6    Copyright (c)  2002-2022, University of Amsterdam
    7                              VU University Amsterdam
    8                              SWI-Prolog Solutions b.v.
    9    All rights reserved.
   10
   11    Redistribution and use in source and binary forms, with or without
   12    modification, are permitted provided that the following conditions
   13    are met:
   14
   15    1. Redistributions of source code must retain the above copyright
   16       notice, this list of conditions and the following disclaimer.
   17
   18    2. Redistributions in binary form must reproduce the above copyright
   19       notice, this list of conditions and the following disclaimer in
   20       the documentation and/or other materials provided with the
   21       distribution.
   22
   23    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   24    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   25    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
   26    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
   27    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   28    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
   29    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   30    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   31    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   32    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   33    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   34    POSSIBILITY OF SUCH DAMAGE.
   35*/
   36
   37:- module(lists,
   38        [ member/2,                     % ?X, ?List
   39          memberchk/2,                  % ?X, ?List
   40          append/2,                     % +ListOfLists, -List
   41          append/3,                     % ?A, ?B, ?AB
   42          prefix/2,                     % ?Part, ?Whole
   43          select/3,                     % ?X, ?List, ?Rest
   44          selectchk/3,                  % ?X, ?List, ?Rest
   45          select/4,                     % ?X, ?XList, ?Y, ?YList
   46          selectchk/4,                  % ?X, ?XList, ?Y, ?YList
   47          nextto/3,                     % ?X, ?Y, ?List
   48          delete/3,                     % ?List, ?X, ?Rest
   49          nth0/3,                       % ?N, ?List, ?Elem
   50          nth1/3,                       % ?N, ?List, ?Elem
   51          nth0/4,                       % ?N, ?List, ?Elem, ?Rest
   52          nth1/4,                       % ?N, ?List, ?Elem, ?Rest
   53          last/2,                       % +List, -Element
   54          proper_length/2,              % @List, -Length
   55          same_length/2,                % ?List1, ?List2
   56          reverse/2,                    % +List, -Reversed
   57          permutation/2,                % ?List, ?Permutation
   58          flatten/2,                    % +Nested, -Flat
   59          clumped/2,                    % +Items,-Pairs
   60
   61                                        % Ordered operations
   62          max_member/2,                 % -Max, +List
   63          min_member/2,                 % -Min, +List
   64          max_member/3,                 % :Pred, -Max, +List
   65          min_member/3,                 % :Pred, -Min, +List
   66
   67                                        % Lists of numbers
   68          sum_list/2,                   % +List, -Sum
   69          max_list/2,                   % +List, -Max
   70          min_list/2,                   % +List, -Min
   71          numlist/3,                    % +Low, +High, -List
   72
   73                                        % set manipulation
   74          is_set/1,                     % +List
   75          list_to_set/2,                % +List, -Set
   76          intersection/3,               % +List1, +List2, -Intersection
   77          union/3,                      % +List1, +List2, -Union
   78          subset/2,                     % +SubSet, +Set
   79          subtract/3                    % +Set, +Delete, -Remaining
   80        ]).   81:- autoload(library(error),[must_be/2]).   82:- autoload(library(pairs),[pairs_keys/2]).   83
   84:- meta_predicate
   85    max_member(2, -, +),
   86    min_member(2, -, +).   87
   88:- set_prolog_flag(generate_debug_info, false).

List Manipulation

This library provides commonly accepted basic predicates for list manipulation in the Prolog community. Some additional list manipulations are built-in. See e.g., memberchk/2, length/2.

The implementation of this library is copied from many places. These include: "The Craft of Prolog", the DEC-10 Prolog library (LISTRO.PL) and the YAP lists library. Some predicates are reimplemented based on their specification by Quintus and SICStus.

Compatibility
- Virtually every Prolog system has library(lists), but the set of provided predicates is diverse. There is a fair agreement on the semantics of most of these predicates, although error handling may vary. */
 member(?Elem, ?List)
True if Elem is a member of List. The SWI-Prolog definition differs from the classical one. Our definition avoids unpacking each list element twice and provides determinism on the last element. E.g. this is deterministic:
    member(X, [One]).
author
- Gertjan van Noord
  120member(El, [H|T]) :-
  121    member_(T, El, H).
  122
  123member_(_, El, El).
  124member_([H|T], El, _) :-
  125    member_(T, El, H).
 append(?List1, ?List2, ?List1AndList2)
List1AndList2 is the concatenation of List1 and List2
  131append([], L, L).
  132append([H|T], L, [H|R]) :-
  133    append(T, L, R).
 append(+ListOfLists, ?List)
Concatenate a list of lists. Is true if ListOfLists is a list of lists, and List is the concatenation of these lists.
Arguments:
ListOfLists- must be a list of possibly partial lists
  142append(ListOfLists, List) :-
  143    must_be(list, ListOfLists),
  144    append_(ListOfLists, List).
  145
  146append_([], []).
  147append_([L|Ls], As) :-
  148    append(L, Ws, As),
  149    append_(Ls, Ws).
 prefix(?Part, ?Whole)
True iff Part is a leading substring of Whole. This is the same as append(Part, _, Whole).
  157prefix([], _).
  158prefix([E|T0], [E|T]) :-
  159    prefix(T0, T).
 select(?Elem, ?List1, ?List2)
Is true when List1, with Elem removed, results in List2. This implementation is determinsitic if the last element of List1 has been selected.
  168select(X, [Head|Tail], Rest) :-
  169    select3_(Tail, Head, X, Rest).
  170
  171select3_(Tail, Head, Head, Tail).
  172select3_([Head2|Tail], Head, X, [Head|Rest]) :-
  173    select3_(Tail, Head2, X, Rest).
 selectchk(+Elem, +List, -Rest) is semidet
Semi-deterministic removal of first element in List that unifies with Elem.
  181selectchk(Elem, List, Rest) :-
  182    select(Elem, List, Rest0),
  183    !,
  184    Rest = Rest0.
 select(?X, ?XList, ?Y, ?YList) is nondet
Select from two lists at the same position. True if XList is unifiable with YList apart a single element at the same position that is unified with X in XList and with Y in YList. A typical use for this predicate is to replace an element, as shown in the example below. All possible substitutions are performed on backtracking.
?- select(b, [a,b,c,b], 2, X).
X = [a, 2, c, b] ;
X = [a, b, c, 2] ;
false.
See also
- selectchk/4 provides a semidet version.
  205select(X, XList, Y, YList) :-
  206    select4_(XList, X, Y, YList).
  207
  208select4_([X|List], X, Y, [Y|List]).
  209select4_([X0|XList], X, Y, [X0|YList]) :-
  210    select4_(XList, X, Y, YList).
 selectchk(?X, ?XList, ?Y, ?YList) is semidet
Semi-deterministic version of select/4.
  216selectchk(X, XList, Y, YList) :-
  217    select(X, XList, Y, YList),
  218    !.
 nextto(?X, ?Y, ?List)
True if Y directly follows X in List.
  224nextto(X, Y, [X,Y|_]).
  225nextto(X, Y, [_|Zs]) :-
  226    nextto(X, Y, Zs).
 delete(+List1, @Elem, -List2) is det
Delete matching elements from a list. True when List2 is a list with all elements from List1 except for those that unify with Elem. Matching Elem with elements of List1 is uses \+ Elem \= H, which implies that Elem is not changed.
See also
- select/3, subtract/3.
deprecated
- There are too many ways in which one might want to delete elements from a list to justify the name. Think of matching (= vs. ==), delete first/all, be deterministic or not.
  241delete([], _, []).
  242delete([Elem|Tail], Del, Result) :-
  243    (   \+ Elem \= Del
  244    ->  delete(Tail, Del, Result)
  245    ;   Result = [Elem|Rest],
  246        delete(Tail, Del, Rest)
  247    ).
  248
  249
  250/*  nth0/3, nth1/3 are improved versions from
  251    Martin Jansche <martin@pc03.idf.uni-heidelberg.de>
  252*/
 nth0(?Index, ?List, ?Elem)
True when Elem is the Index'th element of List. Counting starts at 0.
Errors
- type_error(integer, Index) if Index is not an integer or unbound.
See also
- nth1/3.
  263nth0(Index, List, Elem) :-
  264    (   integer(Index)
  265    ->  nth0_det(Index, List, Elem)         % take nth deterministically
  266    ;   var(Index)
  267    ->  List = [H|T],
  268        nth_gen(T, Elem, H, 0, Index)       % match
  269    ;   must_be(integer, Index)
  270    ).
  271
  272nth0_det(0, [Elem|_], Elem) :- !.
  273nth0_det(1, [_,Elem|_], Elem) :- !.
  274nth0_det(2, [_,_,Elem|_], Elem) :- !.
  275nth0_det(3, [_,_,_,Elem|_], Elem) :- !.
  276nth0_det(4, [_,_,_,_,Elem|_], Elem) :- !.
  277nth0_det(5, [_,_,_,_,_,Elem|_], Elem) :- !.
  278nth0_det(N, [_,_,_,_,_,_   |Tail], Elem) :-
  279    M is N - 6,
  280    M >= 0,
  281    nth0_det(M, Tail, Elem).
  282
  283nth_gen(_, Elem, Elem, Base, Base).
  284nth_gen([H|Tail], Elem, _, N, Base) :-
  285    succ(N, M),
  286    nth_gen(Tail, Elem, H, M, Base).
 nth1(?Index, ?List, ?Elem)
Is true when Elem is the Index'th element of List. Counting starts at 1.
See also
- nth0/3.
  296nth1(Index, List, Elem) :-
  297    (   integer(Index)
  298    ->  Index0 is Index - 1,
  299        nth0_det(Index0, List, Elem)        % take nth deterministically
  300    ;   var(Index)
  301    ->  List = [H|T],
  302        nth_gen(T, Elem, H, 1, Index)       % match
  303    ;   must_be(integer, Index)
  304    ).
 nth0(?N, ?List, ?Elem, ?Rest) is det
Select/insert element at index. True when Elem is the N'th (0-based) element of List and Rest is the remainder (as in by select/3) of List. For example:
?- nth0(I, [a,b,c], E, R).
I = 0, E = a, R = [b, c] ;
I = 1, E = b, R = [a, c] ;
I = 2, E = c, R = [a, b] ;
false.
?- nth0(1, L, a1, [a,b]).
L = [a, a1, b].
  325nth0(V, In, Element, Rest) :-
  326    var(V),
  327    !,
  328    generate_nth(0, V, In, Element, Rest).
  329nth0(V, In, Element, Rest) :-
  330    must_be(nonneg, V),
  331    find_nth0(V, In, Element, Rest).
 nth1(?N, ?List, ?Elem, ?Rest) is det
As nth0/4, but counting starts at 1.
  337nth1(V, In, Element, Rest) :-
  338    var(V),
  339    !,
  340    generate_nth(1, V, In, Element, Rest).
  341nth1(V, In, Element, Rest) :-
  342    must_be(positive_integer, V),
  343    succ(V0, V),
  344    find_nth0(V0, In, Element, Rest).
  345
  346generate_nth(I, I, [Head|Rest], Head, Rest).
  347generate_nth(I, IN, [H|List], El, [H|Rest]) :-
  348    I1 is I+1,
  349    generate_nth(I1, IN, List, El, Rest).
  350
  351find_nth0(0, [Head|Rest], Head, Rest) :- !.
  352find_nth0(N, [Head|Rest0], Elem, [Head|Rest]) :-
  353    M is N-1,
  354    find_nth0(M, Rest0, Elem, Rest).
 last(?List, ?Last)
Succeeds when Last is the last element of List. This predicate is semidet if List is a list and multi if List is a partial list.
Compatibility
- There is no de-facto standard for the argument order of last/2. Be careful when porting code or use append(_, [Last], List) as a portable alternative.
  367last([X|Xs], Last) :-
  368    last_(Xs, X, Last).
  369
  370last_([], Last, Last).
  371last_([X|Xs], _, Last) :-
  372    last_(Xs, X, Last).
 proper_length(@List, -Length) is semidet
True when Length is the number of elements in the proper list List. This is equivalent to
proper_length(List, Length) :-
      is_list(List),
      length(List, Length).
  386proper_length(List, Length) :-
  387    '$skip_list'(Length0, List, Tail),
  388    Tail == [],
  389    Length = Length0.
 same_length(?List1, ?List2)
Is true when List1 and List2 are lists with the same number of elements. The predicate is deterministic if at least one of the arguments is a proper list. It is non-deterministic if both arguments are partial lists.
See also
- length/2
  401same_length([], []).
  402same_length([_|T1], [_|T2]) :-
  403    same_length(T1, T2).
 reverse(?List1, ?List2)
Is true when the elements of List2 are in reverse order compared to List1. This predicate is deterministic if either list is a proper list. If both lists are partial lists backtracking generates increasingly long lists.
  413reverse(Xs, Ys) :-
  414    reverse(Xs, Ys, [], Ys).
  415
  416reverse([], [], Ys, Ys).
  417reverse([X|Xs], [_|Bound], Rs, Ys) :-
  418    reverse(Xs, Bound, [X|Rs], Ys).
 permutation(?Xs, ?Ys) is nondet
True when Xs is a permutation of Ys. This can solve for Ys given Xs or Xs given Ys, or even enumerate Xs and Ys together. The predicate permutation/2 is primarily intended to generate permutations. Note that a list of length N has N! permutations, and unbounded permutation generation becomes prohibitively expensive, even for rather short lists (10! = 3,628,800).

If both Xs and Ys are provided and both lists have equal length the order is |Xs|^2. Simply testing whether Xs is a permutation of Ys can be achieved in order log(|Xs|) using msort/2 as illustrated below with the semidet predicate is_permutation/2:

is_permutation(Xs, Ys) :-
  msort(Xs, Sorted),
  msort(Ys, Sorted).

The example below illustrates that Xs and Ys being proper lists is not a sufficient condition to use the above replacement.

?- permutation([1,2], [X,Y]).
X = 1, Y = 2 ;
X = 2, Y = 1 ;
false.
Errors
- type_error(list, Arg) if either argument is not a proper or partial list.
  454permutation(Xs, Ys) :-
  455    '$skip_list'(Xlen, Xs, XTail),
  456    '$skip_list'(Ylen, Ys, YTail),
  457    (   XTail == [], YTail == []            % both proper lists
  458    ->  Xlen == Ylen
  459    ;   var(XTail), YTail == []             % partial, proper
  460    ->  length(Xs, Ylen)
  461    ;   XTail == [], var(YTail)             % proper, partial
  462    ->  length(Ys, Xlen)
  463    ;   var(XTail), var(YTail)              % partial, partial
  464    ->  length(Xs, Len),
  465        length(Ys, Len)
  466    ;   must_be(list, Xs),                  % either is not a list
  467        must_be(list, Ys)
  468    ),
  469    perm(Xs, Ys).
  470
  471perm([], []).
  472perm(List, [First|Perm]) :-
  473    select(First, List, Rest),
  474    perm(Rest, Perm).
 flatten(+NestedList, -FlatList) is det
Is true if FlatList is a non-nested version of NestedList. Note that empty lists are removed. In standard Prolog, this implies that the atom '[]' is removed too. In SWI7, [] is distinct from '[]'.

Ending up needing flatten/2 often indicates, like append/3 for appending two lists, a bad design. Efficient code that generates lists from generated small lists must use difference lists, often possible through grammar rules for optimal readability.

See also
- append/2
  490flatten(List, FlatList) :-
  491    flatten(List, [], FlatList0),
  492    !,
  493    FlatList = FlatList0.
  494
  495flatten(Var, Tl, [Var|Tl]) :-
  496    var(Var),
  497    !.
  498flatten([], Tl, Tl) :- !.
  499flatten([Hd|Tl], Tail, List) :-
  500    !,
  501    flatten(Hd, FlatHeadTail, List),
  502    flatten(Tl, Tail, FlatHeadTail).
  503flatten(NonList, Tl, [NonList|Tl]).
  504
  505
  506		 /*******************************
  507		 *            CLUMPS		*
  508		 *******************************/
 clumped(+Items, -Pairs)
Pairs is a list of Item-Count pairs that represents the run length encoding of Items. For example:
?- clumped([a,a,b,a,a,a,a,c,c,c], R).
R = [a-2, b-1, a-4, c-3].
Compatibility
- SICStus
  522clumped(Items, Counts) :-
  523    clump(Items, Counts).
  524
  525clump([], []).
  526clump([H|T0], [H-C|T]) :-
  527    ccount(T0, H, T1, 1, C),
  528    clump(T1, T).
  529
  530ccount([H|T0], E, T, C0, C) :-
  531    E == H,
  532    !,
  533    C1 is C0+1,
  534    ccount(T0, E, T, C1, C).
  535ccount(List, _, List, C, C).
  536
  537
  538                 /*******************************
  539                 *       ORDER OPERATIONS       *
  540                 *******************************/
 max_member(-Max, +List) is semidet
True when Max is the largest member in the standard order of terms. Fails if List is empty.
See also
- compare/3
- max_list/2 for the maximum of a list of numbers.
  550max_member(Max, [H|T]) =>
  551    max_member_(T, H, Max).
  552max_member(_, []) =>
  553    fail.
  554
  555max_member_([], Max0, Max) =>
  556    Max = Max0.
  557max_member_([H|T], Max0, Max) =>
  558    (   H @=< Max0
  559    ->  max_member_(T, Max0, Max)
  560    ;   max_member_(T, H, Max)
  561    ).
 min_member(-Min, +List) is semidet
True when Min is the smallest member in the standard order of terms. Fails if List is empty.
See also
- compare/3
- min_list/2 for the minimum of a list of numbers.
  572min_member(Min, [H|T]) =>
  573    min_member_(T, H, Min).
  574min_member(_, []) =>
  575    fail.
  576
  577min_member_([], Min0, Min) =>
  578    Min = Min0.
  579min_member_([H|T], Min0, Min) =>
  580    (   H @>= Min0
  581    ->  min_member_(T, Min0, Min)
  582    ;   min_member_(T, H, Min)
  583    ).
 max_member(:Pred, -Max, +List) is semidet
True when Max is the largest member according to Pred, which must be a 2-argument callable that behaves like (@=<)/2. Fails if List is empty. The following call is equivalent to max_member/2:
?- max_member(@=<, X, [6,1,8,4]).
X = 8.
See also
- max_list/2 for the maximum of a list of numbers.
  597max_member(Pred, Max, [H|T]) =>
  598    max_member_(T, Pred, H, Max).
  599max_member(_, _, []) =>
  600    fail.
  601
  602max_member_([], _, Max0, Max) =>
  603    Max = Max0.
  604max_member_([H|T], Pred, Max0, Max) =>
  605    (   call(Pred, H, Max0)
  606    ->  max_member_(T, Pred, Max0, Max)
  607    ;   max_member_(T, Pred, H, Max)
  608    ).
 min_member(:Pred, -Min, +List) is semidet
True when Min is the smallest member according to Pred, which must be a 2-argument callable that behaves like (@=<)/2. Fails if List is empty. The following call is equivalent to max_member/2:
?- min_member(@=<, X, [6,1,8,4]).
X = 1.
See also
- min_list/2 for the minimum of a list of numbers.
  622min_member(Pred, Min, [H|T]) =>
  623    min_member_(T, Pred, H, Min).
  624min_member(_, _, []) =>
  625    fail.
  626
  627min_member_([], _, Min0, Min) =>
  628    Min = Min0.
  629min_member_([H|T], Pred, Min0, Min) =>
  630    (   call(Pred, Min0, H)
  631    ->  min_member_(T, Pred, Min0, Min)
  632    ;   min_member_(T, Pred, H, Min)
  633    ).
  634
  635
  636                 /*******************************
  637                 *       LISTS OF NUMBERS       *
  638                 *******************************/
 sum_list(+List, -Sum) is det
Sum is the result of adding all numbers in List.
  644sum_list(Xs, Sum) :-
  645    sum_list(Xs, 0, Sum).
  646
  647sum_list([], Sum0, Sum) =>
  648    Sum = Sum0.
  649sum_list([X|Xs], Sum0, Sum) =>
  650    Sum1 is Sum0 + X,
  651    sum_list(Xs, Sum1, Sum).
 max_list(+List:list(number), -Max:number) is semidet
True if Max is the largest number in List. Fails if List is empty.
See also
- max_member/2.
  660max_list([H|T], Max) =>
  661    max_list(T, H, Max).
  662max_list([], _) => fail.
  663
  664max_list([], Max0, Max) =>
  665    Max = Max0.
  666max_list([H|T], Max0, Max) =>
  667    Max1 is max(H, Max0),
  668    max_list(T, Max1, Max).
 min_list(+List:list(number), -Min:number) is semidet
True if Min is the smallest number in List. Fails if List is empty.
See also
- min_member/2.
  678min_list([H|T], Min) =>
  679    min_list(T, H, Min).
  680min_list([], _) => fail.
  681
  682min_list([], Min0, Min) =>
  683    Min = Min0.
  684min_list([H|T], Min0, Min) =>
  685    Min1 is min(H, Min0),
  686    min_list(T, Min1, Min).
 numlist(+Low, +High, -List) is semidet
List is a list [Low, Low+1, ... High]. Fails if High < Low.
Errors
- type_error(integer, Low)
- type_error(integer, High)
  696numlist(L, U, Ns) :-
  697    must_be(integer, L),
  698    must_be(integer, U),
  699    L =< U,
  700    numlist_(L, U, Ns).
  701
  702numlist_(U, U, List) :-
  703    !,
  704    List = [U].
  705numlist_(L, U, [L|Ns]) :-
  706    L2 is L+1,
  707    numlist_(L2, U, Ns).
  708
  709
  710                /********************************
  711                *       SET MANIPULATION        *
  712                *********************************/
 is_set(@Set) is semidet
True if Set is a proper list without duplicates. Equivalence is based on ==/2. The implementation uses sort/2, which implies that the complexity is N*log(N) and the predicate may cause a resource-error. There are no other error conditions.
  721is_set(Set) :-
  722    '$skip_list'(Len, Set, Tail),
  723    Tail == [],                             % Proper list
  724    sort(Set, Sorted),
  725    length(Sorted, Len).
 list_to_set(+List, ?Set) is det
True when Set has the same elements as List in the same order. The left-most copy of duplicate elements is retained. List may contain variables. Elements E1 and E2 are considered duplicates iff E1 == E2 holds. The complexity of the implementation is N*log(N).
Errors
- List is type-checked.
See also
- sort/2 can be used to create an ordered set. Many set operations on ordered sets are order N rather than order N**2. The list_to_set/2 predicate is more expensive than sort/2 because it involves, two sorts and a linear scan.
Compatibility
- Up to version 6.3.11, list_to_set/2 had complexity N**2 and equality was tested using =/2.
  745list_to_set(List, Set) :-
  746    must_be(list, List),
  747    number_list(List, 1, Numbered),
  748    sort(1, @=<, Numbered, ONum),
  749    remove_dup_keys(ONum, NumSet),
  750    sort(2, @=<, NumSet, ONumSet),
  751    pairs_keys(ONumSet, Set).
  752
  753number_list([], _, []).
  754number_list([H|T0], N, [H-N|T]) :-
  755    N1 is N+1,
  756    number_list(T0, N1, T).
  757
  758remove_dup_keys([], []).
  759remove_dup_keys([H|T0], [H|T]) :-
  760    H = V-_,
  761    remove_same_key(T0, V, T1),
  762    remove_dup_keys(T1, T).
  763
  764remove_same_key([V1-_|T0], V, T) :-
  765    V1 == V,
  766    !,
  767    remove_same_key(T0, V, T).
  768remove_same_key(L, _, L).
 intersection(+Set1, +Set2, -Set3) is det
True if Set3 unifies with the intersection of Set1 and Set2. The complexity of this predicate is |Set1|*|Set2|. A set is defined to be an unordered list without duplicates. Elements are considered duplicates if they can be unified.
See also
- ord_intersection/3.
  780intersection([], _, Set) =>
  781    Set = [].
  782intersection([X|T], L, Intersect) =>
  783    (   memberchk(X, L)
  784    ->  Intersect = [X|R],
  785        intersection(T, L, R)
  786    ;   intersection(T, L, Intersect)
  787    ).
 union(+Set1, +Set2, -Set3) is det
True if Set3 unifies with the union of the lists Set1 and Set2. The complexity of this predicate is |Set1|*|Set2|. A set is defined to be an unordered list without duplicates. Elements are considered duplicates if they can be unified.
See also
- ord_union/3
  798union([], L0, L) =>
  799    L = L0.
  800union([H|T], L, Union) =>
  801    (   memberchk(H, L)
  802    ->  union(T, L, Union)
  803    ;   Union = [H|R],
  804        union(T, L, R)
  805    ).
 subset(+SubSet, +Set) is semidet
True if all elements of SubSet belong to Set as well. Membership test is based on memberchk/2. The complexity is |SubSet|*|Set|. A set is defined to be an unordered list without duplicates. Elements are considered duplicates if they can be unified.
See also
- ord_subset/2.
  816subset([], _) => true.
  817subset([E|R], Set) =>
  818    memberchk(E, Set),
  819    subset(R, Set).
 subtract(+Set, +Delete, -Result) is det
Delete all elements in Delete from Set. Deletion is based on unification using memberchk/2. The complexity is |Delete|*|Set|. A set is defined to be an unordered list without duplicates. Elements are considered duplicates if they can be unified.
See also
- ord_subtract/3.
  831subtract([], _, R) =>
  832    R = [].
  833subtract([E|T], D, R) =>
  834    (   memberchk(E, D)
  835    ->  subtract(T, D, R)
  836    ;   R = [E|R1],
  837        subtract(T, D, R1)
  838    )