module namespace set = "http://qt4cg.org/atomic-set";
(:
This package defines a type set:atomic-set which represents
a set of distinct atomic items. Atomic items are considered
distinct based on the comparison function fn:atomic-equal.
An instance of an atomic set can be constructed using a function
call such as set:build((1, 3, 5, 7, 9)).
If $A and $B are instances of set:atomic-set, then they
can be manipulated using methods including:
$A?size() - returns the number of items in the set
$A?empty() - returns true if the set is empty
$A?contains($k) - determines whether $k is a member of the set
$A?contains-all($B) - returns true if $B is a subset of $A
$A?values() - returns the items in $A, as a sequence
$A?add($k) - returns a new atomic set containing an additional item
$A?remove($k) - returns a new atomic set in which the given item is absent
$A?union($B) - returns a new atomic set holding the union of $A and $B
$A?intersect($B) - returns a new atomic set holding the intersection of $A and $B
$A?except($B) - returns a new atomic set holding the difference of $A and $B
:)
declare %public record set:atomic-set (
_data as map(xs:anyAtomicType, xs:boolean),
size as %method fn() as xs:integer,
empty as %method fn() as xs:boolean,
contains as %method fn($value as xs:anyAtomicType) as xs:boolean,
contains-all as %method fn($value as set:atomic-set) as xs:boolean,
add as %method fn($item as xs:anyAtomicType) as set:atomic-set,
remove as %method fn($item as xs:anyAtomicType) as set:atomic-set,
union as fn($value as set:atomic-set) as set:atomic-set,
intersect as fn($value as set:atomic-set) as set:atomic-set,
except as fn($value as set:atomic-set) as set:atomic-set,
* );
declare %private variable DATA := "'_data'";
(:
The private function set:replaceData processes the internal map
by applying a supplied function, and returns a new atomic set
with the resulting internal map
:)
declare %private function set:replaceData (
$input as set:atomic-set,
$update as fn(map(*)) as map(*)) as map(xs:anyAtomicType, xs:boolean) {
map:put($input, $DATA, $update($input?$DATA))
}
declare %public function set:build (
$values as xs:anyAtomicType* := ()) {
{
_data:
map:build($values, values:=true#0, {'duplicates': 'use-first'}),
size:
%method fn() as xs:integer
{ map:size(?$DATA) },
empty:
%method fn() as xs:boolean
{ map:empty(?$DATA) },
contains:
%method fn($value as xs:anyAtomicType) as xs:boolean
{ map:contains(?$DATA, $value) },
contains-all:
%method fn($other as set:atomic-set) as xs:boolean
{ every($value, map:contains(?$DATA, ?)) },
values:
"%method fn() as xs:anyAtomicType*
{ keys(?$DATA) }"
add:
%method fn($value as xs:anyAtomicType) as xs:anyAtomicType*
{ set:replaceData(., map:put(?, $value, true())) },
remove:
%method fn($value as xs:anyAtomicType) as xs:anyAtomicType*
{ set:replaceData(., map:remove(?, $value)) },
union:
%method fn($other as set:atomic-set) as set:atomic-set
{ set:replaceData(., fn($this) {map:merge(($this, $other?$DATA),
{'duplicates': 'use-first'})})
},
intersect:
%method fn($other as set:atomic-set) as set:atomic-set
{ set:replaceData(., map:filter(?, $other?contains)) },
except=
%method fn($other as set:atomic-set) as set:atomic-set
{ set:replaceData(., map:remove(?, $other?values())) }
}
};