Module lillib:lists

This module provides various predicates for manipulating lists, such as append and reverse.

Version

April 07, 1999

Since

July 09, 1998

Author

MITSUISHI Yutaka (mitsuisi@is.s.u-tokyo.ac.jp)

Predicate

append/3: concatenation of two lists
revappend/3: Concatenation of reversed and original ordered lists
append_list/2: Concatenation of lists
delete/3: remove specified elements from a list
reverse/2: Reverse of a list
last/2: Get the last element of a list
member/2: Get an element of a list
member_e/2: 'equivalent' version of 'member/2'
member_i/2: 'identical' version of 'member/2'
member_s/2: 'subsume' version of 'member/2'
member_sd/2: 'subsumed' version of 'member/2'
memberchk/2: check an item is an element of a list
memberchk_e/2: 'equivalent' version of 'memberchk/2'
memberchk_i/2: 'identical' version of 'memberchk/2'
memberchk_s/2: 'subsume' version of 'memberchk/2'
memberchk_sd/2: 'subsumed' version of 'memberchk/2'
member_2/4: Get the corresponding elements from two lists
fast_member/2: fast version of 'member/2'
fast_member_2/4: fast version of 'member_2/4'
assoc/3: association list
assoc_e/3: 'equivalent' version of 'assoc/3'
assoc_i/3: 'identical' version of 'assoc/3'
remove_duplicates/2: remove duplicated elements from a list
listcommon/3: common part of two lists
flatten_list/2: flatten a list
make_n_list/3: make an n-length list
make_num_list/3: make a list of integers
length/2: length of a list
nth_elem/3: get an n-th element of a list
set_difference/3: get the difference of two sets
set_difference_e/3: 'equivalent' version of 'set_difference/3'
set_difference_i/3: 'identical' version of 'set_difference/3'
input_list/2: convert a lisp list into a lilfes list
output_list/2: convert a lilfes list into a string
dlength/3: length of a difference list
dmember/3: member of a difference list
dmember_2/5: member_2 of a difference list

Top of this page Contents Index of this package LiLFeS Documents LiLFeS Home Page Tsujii laboratory

Predicate

append/3

Format append(?$L1, ?$L2, ?$L3)

Arguments

`?$L1`	list	List 1
`?$L2`	list	List 2
`?$L3`	list	Concatenation of List 1 and List 2

This is true when $L3 is the combined list of the elements in $L1 and $L2 in the original orders.

 > ?- append([1, 2, 3], [4, 5], X).
  X: < 1, 2, 3, 4, 5 >

revappend/3

Format revappend(?$L1, ?$L2, ?$L3)

Arguments

`?$L1`	list	Reversed list
`?$L2`	list	List
`?$L3`	list	Concatenation

This is true when $L3 is the combined list of the elements in $L1 and $L2, in the reversed order as to $L1 and in the original order as to $L2.

 > ?- revappend([1, 2, 3], [4, 5], X).
  X: < 3, 2, 1, 4, 5 >

append_list/2

Format append_list(+$LL, -$L)

Arguments

`+$LL`	list of list	Input lists
`-$L`	list	Concatenation of the lists

This lets $L3 be the combined list of the elements in the elements in $LL.

 > ?- append_list([[1, 2], [3], [4, 5]],X).
  X: < 1, 2, 3, 4, 5 >

delete/3

Format delete(+$List1, +$Elem, -$List2)

Arguments

`+$List1`	list	input list
`+$Elem`	bot	an element to be removed
`-$List2`	list	output

This removes elements $Elem from $List and returns to $List2.

 > ?- delete([1, 2, 2, 4, 5], 2, X).
  X: < 1, 4, 5 >

reverse/2

Format reverse(?$L1, ?$L2)

Arguments

`?$L1`	list	Original ordered list
`?$L2`	list	Reversed ordered list

This is true when $L1 and $L2 have the same elements but in reversed orders each other.

 > ?- reverse([1, 2, 3, 4], X).
  X: < 4, 3, 2, 1 >

last/2

Format last(?$L, ?$X)

Arguments

`?$L`	list	Input list
`?$X`	bot	The last element of the list

This lets $X be the last element in $L.

 > ?- last([1, 2, 3, 4], X).
  X: 4

member/2

Format member(?$X, +$L)

Arguments

`?$X`	bot	a list element
`+$L`	list	a list

This is true when $X is unified with an element in $L.

 > ?- member(X, [1, 2, 3]).
  X: 1
  Enter ';' for more choices, otherwise press ENTER --> ;
  X: 2
  Enter ';' for more choices, otherwise press ENTER --> ;
  X: 3
  Enter ';' for more choices, otherwise press ENTER --> ;
  no

member_e/2

Format member_e(?$X, +$L)

Arguments

`?$X`	bot	a list element
`+$L`	list	a list

See also member/2

This is true when $X is equivalent to an element in $L.

member_i/2

Format member_i(?$X, +$L)

Arguments

`?$X`	bot	a list element
`+$L`	list	a list

See also member/2

This is true when $X is identical to an element in $L.

member_s/2

Format member_s(?$X, +$L)

Arguments

`?$X`	bot	a list element
`+$L`	list	a list

See also member/2

This is true when $X subsumes an element in $L.

member_sd/2

Format member_sd(?$X, +$L)

Arguments

`?$X`	bot	a list element
`+$L`	list	a list

See also member/2

This is true when $X is subsumed by an element in $L.

memberchk/2

Format memberchk(+$X, +$L)

Arguments

`+$X`	bot	a list element
`+$L`	list	a list

See also member/2

This is true when $X is unified with an element in $L. This does not succeeds more than once.

 > ?- memberchk(X, [1, 2, 3, 4]).
  X: 1

memberchk_e/2

Format memberchk_e(+$X, +$L)

Arguments

`+$X`	bot	a list element
`+$L`	list	a list

See also memberchk/2

This is true when $X is equivalent to an element in $L. This does not succeeds more than once.

memberchk_i/2

Format memberchk_i(+$X, +$L)

Arguments

`+$X`	bot	a list element
`+$L`	list	a list

See also memberchk/2

This is true when $X is identical to an element in $L. This does not succeed more than once.

memberchk_s/2

Format memberchk_s(+$X, +$L)

Arguments

`+$X`	bot	a list element
`+$L`	list	a list

See also memberchk/2

This is true when $X subsume an element in $L. This does not succeed more than once.

memberchk_sd/2

Format memberchk_sd(+$X, +$L)

Arguments

`+$X`	bot	a list element
`+$L`	list	a list

See also memberchk/2

This is true when $X is subsumed by an element in $L. This does not succeed more than once.

member_2/4

Format member_2(?$X1, +$L1, ?$X2, +$L2)

Arguments

`?$X1`	bot	a list element
`+$L1`	list	a list
`?$X2`	bot	a list element
`+$L2`	list	a list

See also member/2

This is true when $X1 and $X2 are unified with an element in $L1 and $L2 respectively. Where $X1 and $X2 are from the heads of $L1 and $L2 must be the same.

 > ?- member_2(X, [1, 2], Y, [4, 5]).
  X: 1
  Y: 4
  Enter ';' for more choices, otherwise press ENTER --> ;
  X: 2
  Y: 5
  Enter ';' for more choices, otherwise press ENTER --> ;
  no

fast_member/2

Format fast_member(+$L, ?$X)

Arguments

`+$L`	list	a list
`?$X`	bot	a list element

See also member/2

This is true when $X is unified with an element in $L. This is the same as 'member', but the order of the arguments is changed and this is faster.

 > ?- fast_member([1, 2, 3], X).
  X: 1
  Enter ';' for more choices, otherwise press ENTER --> ;
  X: 2
  Enter ';' for more choices, otherwise press ENTER --> ;
  X: 3
  Enter ';' for more choices, otherwise press ENTER --> ;
  no

fast_member_2/4

Format fast_member_2(+$L1, ?$X1, +$L2, ?$X2)

Arguments

`+$L1`	list	list
`?$X1`	bot	list element
`+$L2`	list	list
`?$X2`	bot	list element

assoc/3

Format assoc(+$X, +$L, -$Y)

Arguments

`+$X`	bot	key
`+$L`	list of ',/2'	association list
`-$Y`	bot	data

This lets $Y be the second element of the pair whose first element is unified with $X. The 2-element pair (',/2') is the first proper one in $L. This does not succeed more than once.

 > ?- assoc(1, [(1, "a"), (2, "b")], X).
  X: "a"

assoc_e/3

Format assoc_e(+$X, +$L, -$Y)

Arguments

`+$X`	bot	key
`+$L`	list of ',/2'	association list
`-$Y`	bot	data

assoc_i/3

Format assoc_i(+$X, +$L, -$Y)

Arguments

`+$X`	bot	key
`+$L`	list of ',/2'	association list
`-$Y`	bot	data

remove_duplicates/2

Format remove_duplicates(+$L1, -$L2)

Arguments

`+$L1`	list	an original list
`-$L2`	list	output list

This lets $L2 be the result of removing all equivalent duplicate elements in $L1.

 > ?- remove_duplicates([1, 2, 3, 2, 4], X).
  X: < 1, 3, 2, 4 >

listcommon/3

Format listcommon(+$L1, +$L2, -$L3)

Arguments

`+$L1`	list	list 1
`+$L2`	list	list 2
`-$L3`	list	common part of the lists

Author NISHIDA Kenji (nishiken@is.s.u-tokyo.ac.jp)

This lets $L3 be a list of all the elements that have equivalent elements both in $L1 and in $L2.

 > ?- listcommon([1, 2, 3, 4], [5, 4, 3], X).
  X: < 3, 4 >

flatten_list/2

Format flatten_list(+$L1, -$L2)

Arguments

`+$L1`	list	input list
`-$L2`	list	output list

This lets $L2 be a flattened list of $L1.

 > ?- flatten_list([1, [2, [3, 4], 5]], X).
  X: < 1, 2, 3, 4, 5 >

make_n_list/3

Format make_n_list(+$N, +$X, -$L)

Arguments

`+$N`	integer (>= 0)	length of a list
`+$X`	bot	a list element
`-$L`	list	output

This lets $L be a list whose length is $N and all the elements are equivalent to $X.

 > ?- make_n_list(5, "hoge", X).
  X: < "hoge", "hoge", "hoge", "hoge", "hoge" >

make_num_list/3

Format make_num_list(+$FROM, +$BEFORE, -$RESULT)

Arguments

`+$FROM`	integer	a start of a list
`+$BEFORE`	integer	an end of the list
`-$RESULT`	list of integers	output

This lets $RESULT be a list whose elements are the integers from $FROM before $BEFORE.

 > ?- make_num_list(2, 5, X).
  X: < 2, 3, 4 >

length/2

Format length(+$L, -$N)

Arguments

`+$L`	list	input list
`-$N`	integer	length of the list

This lets $N be the length of $L.

 > ?- length([3, 3, 3, 3], X).
  X: 4

nth_elem/3

Format nth_elem(+$LIST, +$N, -$ELEM)

Arguments

`+$LIST`	list	a list
`+$N`	integer	index
`-$ELEM`	bot	an element of the list

This returns $Nth element of the list $LIST as $ELEM.

 > ?- nth([2, 4, 6, 8], 2, X).
  X: 6

set_difference/3

Format set_difference(+$Set1, +$Set2, -$Diff)

Arguments

`+$Set1`	list	Set 1
`+$Set2`	list	Set 2

This returns the elements of $Set1 not included in $Set2.

 > ?- set_difference([1, 2, 3, 4], [6, 4, 2], X).
  X: < 1, 3 >

set_difference_e/3

Format set_difference_e(+$Set1, +$Set2, -$Diff)

Arguments

`+$Set1`	list	Set 1
`+$Set2`	list	Set 2

set_difference_i/3

Format set_difference_i(+$Set1, +$Set2, -$Diff)

Arguments

`+$Set1`	list	Set 1
`+$Set2`	list	Set 2

input_list/2

Format input_list(+$STRING, -$LIST)

Arguments

`+$STRING`	string	a lisp list
`-$LIST`	list	a lilfes list

output_list/2

Format output_list(+$LIST, -$STRING)

Arguments

`+$LIST`	list	a lilfes list
`-$STRING`	string	a lisp list

dlength/3

Format dlength(+Head, +Tail, -N)

Arguments

`+Head`	list
`+Tail`	list
`-N`	integer

Returns the length of the difference list between Head and Tail.

dmember/3

Format dmember(+LHead, +LTail, ?E)

Arguments

`+LHead`		head of the difference list
`+LTail`		tail (end) of the difference list
`?E`		the element to search for

as with member, but searches in a difference list given by 'LHead' and 'LTail'

dmember_2/5

Format dmember_2(+L1Head, +L1Tail, ?E1, +L2, ?E2)

Arguments

`+L1Head`		head of the first list (difference list)
`+L1Tail`		tail (end) of the first list
`?E1`		the element to search for in the first list
`+L2`		second list
`?E2`		the element to search for in the second list

as 'fast_member_2', but the first list is considered a difference list It is not necessary to give the 2nd list as difference list as well, as both lists are processed in tandem.

Top of this page Contents Index of this package LiLFeS Documents LiLFeS Home Page Tsujii laboratory

Send comments to:

MITSUISHI Yutaka (mitsuisi@is.s.u-tokyo.ac.jp)

This document is automatically created by lildoc on Fri Sep 24 14:13:58 2004