module datatypes

pub struct Set<T> {
mut:
	elements map[T]u8
}

// checks the element is exists.
fn (set Set<T>) exists(element T) bool {
	return element in set.elements
}

// adds the element to set, if it is not present already.
fn (mut set Set<T>) add(element T) {
	set.elements[element] = 1
}

// removes the element from set.
fn (mut set Set<T>) remove(element T) {
	set.elements.delete(element)
}

// pick returns an arbitrary element of set, if set is not empty.
fn (mut set Set<T>) pick() ?T {
	for k, _ in set.elements {
		return k
	}
	return error('Set is empty.')
}

// rest returns the set consisting of all elements except for the arbitrary element.
fn (mut set Set<T>) rest() ?[]T {
	element := set.pick()?
	return set.elements.keys().filter(it != element)
}

// pop returns an arbitrary element and deleting it from set.
fn (mut set Set<T>) pop() ?T {
	element := set.pick()?
	set.elements.delete(element)
	return element
}

// delete all elements of set.
fn (mut set Set<T>) clear() {
	set.elements = map[T]u8{}
}

// checks whether the two given sets are equal (i.e. contain all and only the same elements).
fn (mut l Set<T>) equal(r Set<T>) bool {
	if l.elements.len != r.elements.len {
		return false
	}
	for e, _ in r.elements {
		if e !in l.elements {
			return false
		}
	}
	return true
}

// checks whether the set is empty.
fn (mut set Set<T>) is_empty() bool {
	return set.size() == 0
}

// size returns the number of elements in the set.
fn (mut set Set<T>) size() int {
	return set.elements.len
}

// copy returns a copy of all the elements in the set.
fn (mut set Set<T>) copy() Set<T> {
	return Set<T>{
		elements: set.elements.clone()
	}
}

// add_all adds the whole `elements` array to the set
fn (mut set Set<T>) add_all(elements []T) {
	for element in elements {
		set.add(element)
	}
}

// @union returns the union of the two sets.
fn (mut l Set<T>) @union(r Set<T>) Set<T> {
	mut set := l
	for e, _ in r.elements {
		set.add(e)
	}
	return set
}

// intersection returns the intersection of sets.
fn (mut l Set<T>) intersection(r Set<T>) Set<T> {
	mut set := l
	for e, _ in l.elements {
		if !r.exists(e) {
			set.remove(e)
		}
	}
	for e, _ in r.elements {
		if !l.exists(e) {
			set.remove(e)
		}
	}
	return set
}

// difference returns the difference of sets.
fn (mut l Set<T>) difference(r Set<T>) Set<T> {
	mut set := l
	for e, _ in l.elements {
		if r.exists(e) {
			set.remove(e)
		}
	}
	return set
}

// subset returns true if the set `r` is a subset of the set `l`.
fn (mut l Set<T>) subset(r Set<T>) bool {
	for e, _ in r.elements {
		if e !in l.elements {
			return false
		}
	}
	return true
}