11.7.2 Set

union(s : Set(T)) : Set(T)

self和s的并集。

post: result->forAll(elem | self->includes(elem) or s->includes(elem))
post: self ->forAll(elem | result->includes(elem))
post: s ->forAll(elem | result->includes(elem))

union(bag : Bag(T)) : Bag(T)

self和bag的并包。

post: result->forAll(elem | result->count(elem) = self->count(elem) + bag->count(elem))
post: self->forAll(elem | result->includes(elem))
post: bag ->forAll(elem | result->includes(elem))

= (s : Set(T)) : Boolean

如果self和s包含相同的元素，则为真。

post: result = (self->forAll(elem | s->includes(elem)) and
                s->forAll(elem | self->includes(elem)) )

intersection(s : Set(T)) : Set(T)

self和s的交集（即既属于self又属于s的元素构成的集合）。

post: result->forAll(elem | self->includes(elem) and s->includes(elem))
post: self->forAll(elem | s ->includes(elem) = result->includes(elem))
post: s ->forAll(elem | self->includes(elem) = result->includes(elem))

intersection(bag : Bag(T)) : Set(T)

self和s的交集。

post: result = self->intersection( bag->asSet )

- (s : Set(T)) : Set(T)

self中不属于s的元素构成的集合。

post: result->forAll(elem | self->includes(elem) and s->excludes(elem))
post: self ->forAll(elem | result->includes(elem) = s->excludes(elem))

including(object : T) : Set(T)

包含self的所有元素以及object的集合。

post: result->forAll(elem | self->includes(elem) or (elem = object))
post: self- >forAll(elem | result->includes(elem))
post: result->includes(object)

excluding(object : T) : Set(T)

包含除object外self的所有元素的集合。

post: result->forAll(elem | self->includes(elem) and (elem <> object))
post: self- >forAll(elem | result->includes(elem) = (object <> elem))
post: result->excludes(object)

symmetricDifference(s : Set(T)) : Set(T)

不在self或s（但不能都不属于二者）的元素组成的集合。

post: result->forAll(elem | self->includes(elem) xor s->includes(elem))
post: self->forAll(elem | result->includes(elem) = s ->excludes(elem))
post: s ->forAll(elem | result->includes(elem) = self->excludes(elem))

count(object : T) : Integer

object在self中出现的次数。

post: result <= 1

flatten() : Set(T2)

重定义Collection的操作。如果元素类型不是一个集合类型，那么结果是一个与self相同的集合。如果元素类型是一个集合类型，结果是包含所有self的元素递归展开后的元素的集合。

post: result = if self.oclType().elementType.oclIsKindOf(CollectionType) then
                   self->iterate(c; acc : Set(T2) = Set{} | acc->union(c->flatten()->asSet() ) )
               else
                   self
               endif

selectByKind(type : Classifier) : Set(T)

返回self中所有类型是type或其子类型的元素集合。返回集合的元素类型T是给定的type。

selectByType(type : Classifier) : OrderedSet(T)

返回self中所有类型是type而非其子类的元素集合。返回集合的元素类型T是给定的type。

asSet() : Set(T)

重定义Collection的操作，从self获得一个相同的Set，该操作存在是出于方便的原因。

post: result = self

asOrderedSet() : OrderedSet(T)

重定义Collection的操作。从self获得一个包含所有元素的OrderedSet。元素次序未定义。

post: result->forAll(elem | self->includes(elem))

asSequence() : Sequence(T)

重定义Collection的操作。从self获得一个包含所有元素的Sequence，元素次序未定义。

post: result->forAll(elem | self->includes(elem))
post: self->forAll(elem | result->count(elem) = 1)

asBag() : Bag(T)

重定义Collection的操作。从self获得一个包含所有元素的Bag。

post: result->forAll(elem | self->includes(elem))
post: self->forAll(elem | result->count(elem) = 1)