HashSetImplementation() {
  _backingMap = new HashMapImplementation<E, E>();
}

factory HashSetImplementation.from(Iterable<E> other) {
  Set<E> set = new HashSetImplementation<E>();
  for (final e in other) {
    set.add(e);
  }
  return set;
}

void add(E value) {
  _backingMap[value] = value;
}

void addAll(Collection<E> collection) {
  collection.forEach(void _(E value) {
    add(value);
  });
}

void clear() {
  _backingMap.clear();
}

bool contains(E value) {
  return _backingMap.containsKey(value);
}

bool containsAll(Collection<E> collection) {
  return collection.every(bool _(E value) {
    return contains(value);
  });
}

bool every(bool f(E element)) {
  Collection<E> keys = _backingMap.getKeys();
  return keys.every(f);
}

Set<E> filter(bool f(E element)) {
  Set<E> result = new Set<E>();
  _backingMap.forEach(void _(E key, E value) {
    if (f(key)) result.add(key);
  });
  return result;
}

void forEach(void f(E element)) {
  _backingMap.forEach(void _(E key, E value) {
    f(key);
  });
}

Set<E> intersection(Collection<E> collection) {
  Set<E> result = new Set<E>();
  collection.forEach(void _(E value) {
    if (contains(value)) result.add(value);
  });
  return result;
}

bool isEmpty() {
  return _backingMap.isEmpty();
}

bool isSubsetOf(Collection<E> other) {
  return new Set<E>.from(other).containsAll(this);
}

Iterator<E> iterator() {
  return new HashSetIterator<E>(this);
}

int get length() {
  return _backingMap.length;
}

Set map(f(E element)) {
  Set result = new Set();
  _backingMap.forEach(void _(E key, E value) {
    result.add(f(key));
  });
  return result;
}

bool remove(E value) {
  if (!_backingMap.containsKey(value)) return false;
  _backingMap.remove(value);
  return true;
}

void removeAll(Collection<E> collection) {
  collection.forEach(void _(E value) {
    remove(value);
  });
}

bool some(bool f(E element)) {
  Collection<E> keys = _backingMap.getKeys();
  return keys.some(f);
}

String toString() {
  return Collections.collectionToString(this);
}