list_diff/3

Module: builtins

`append/2` — appends a list of lists together
`list_diff/3` — returns the ordered difference of two lists
`list_diffs/4` — returns both ordered differences of two lists
`symmetric_diff/3` — returns the symmetric difference of two lists
`intersect/2` — returns the intersection of a list of lists
`intersect/3` — returns the intersection of two lists
`int_diff/4` — returns the intersection and one difference of two lists
`union/3` — returns the ordered union of two lists
`sorted_merge/2` — returns the sorted union of a list of lists
`sorted_merge/3` — returns the sorted union of two lists
`subset/2` — determines if one list is a subset of another
`init_seg_list/2` — determines if one list is an initial segment of another

FORMS

`append(ListOfLists, Result)`

`list_diff(A, B, A_NotB)`

`list_diffs(A,B,A_NotB,B_NotA)`

`symmetric_diff(A,B,A_symd_B)`

`intersect(A,B,AintB)`

`int_diff(A,B,AintB,AnotB)`

`intersect(L,IntsectL)`

`union(A,B, AuB)`

`sorted_merge(List1, List2, Union)`

`sorted_merge(ListOfLists, Union)`

`subset(LeftList, RightList)`

`init_seg_list(LeftList, RightList)`

DESCRIPTION

`append/2` If ListOfLists if a list, each of whose elements is a list, Result is obtained by appending the members of ListOfLists together in order.

`list_diff/3` If A and B are lists, returns the difference A-B consisting of all items on A, but not on B.

`list_diffs/4` If A and B are lists, returns both the difference A-B together with the difference B-A.

`symmetric_diff/3` If A and B are lists, returns the symmetric difference of A and B, which is the union of A-B and B-A.

`intersect/3` If A and B are lists, returns the intersection AintB of A and B, which is the list of all items common to both lists, in order.

`int_diff/4` If A and B are lists, returns the intersection AintB of A and B, together with the difference A - B.

`intersect/2` If L is a list of lists, returns the intersection IntsectL of all of the lists appearing on L.

`union/3` If A and B are lists, returns the ordered union of A and B, consisting of all items occurring on either A or B, with all occurrences of items from A occurring before any items from B-A; equivalent to:
append(A,B-A,AuB);
If both lists have the property that each element occurs no more than once, then the union also has this property.

`sorted_merge/3` If List1 and List2 are lists of items, Union is the sorted merge (non-repetitive union) of List1 and List2.

`sorted_merge/2` If ListOfLists is a list of lists, Union is the sorted merge (non-repetitive union) of the members of ListsOfLists.

`subset/2` If LeftList and RightList are both lists, this predicate is true if and only if every element of LeftList is also an element of RightList

`init_seg_list/2` If LeftList and RightList are both lists, this predicate is true if and only if LeftList is an initial sublist of RightList.