anchor.diff:              this._set = new Set();
       }
   
  -    get iterator {
  -        return this._set.iterator;
  -    }
  +    get iterator => this._set.iterator;
   
       add(var elem) => this._set.add(elem);
   
  -    isdisjoint(var other) {
  -        if(other is $PySet){
  -            if(this._set.intersection(other._set).length == 0)
  -                return true;
  -            else
  -                return false;
  -        }
  -        else
  -            throw "Invalid Arguments";
  -    }
  -
  -    issubset(var other) {
  -        if(other is $PySet)
  -            return other._set.containsAll(this._set);
  -        else
  -            throw "Invalid Arguments";
  -    }
  -
  -    issuperset(var other){
  -        if(other is $PySet)
  -            return this._set.containsAll(other._set);
  -        else
  -            throw "Invalid Arguments";
  -    }
  -
  -    union(var other) {
  -        if(other is $PySet)
  -            return new $PySet(this._set.union(other._set));
  -        else
  -            throw "Invalid Arguments";
  -    }
  -
  -    intersection(var other) {
  -        if(other is $PySet)
  -            return new $PySet(this._set.intersection(other._set));
  -        else
  -            throw "Invalid Arguments";
  -    }
  -
  -    difference(var other){
  -        if(other is $PySet)
  -            return new $PySet(this._set.difference(other._set));
  -        else
  -            throw "Invalid Arguments";
  -    }
  -
  -    symmetric_difference(var other){
  -        if(other is $PySet)
  -            return new $PySet(this._set.union(other._set).difference(this._set.intersection(other._set)));
  -        else
  -            throw "Invalid Arguments";
  -    }
  -
  -    update(var other){
  -        if(other is $PySet)
  -            this._set = this._set.union(other._set);
  -        else
  -            throw "Invalid Arguments";
  -    }
  -
  -    intersection_update(var other){
  -        if(other is $PySet)
  -            this._set = this._set.intersection(other._set);
  -        else
  -            throw "Invalid Arguments";
  -    }
  -
  -    difference_update(var other){
  -        if(other is $PySet)
  -            this._set = this._set.difference(other._set);
  -        else
  -            throw "Invalid Arguments";
  -    }
  -
  -    symmetric_difference_update(var other){
  -        if(other is $PySet)
  -            this._set = this._set.union(other._set).difference(this._set.intersection(other._set));
  -        else
  -            throw "Invalid Arguments";
  +    isdisjoint(var iterable) {
  +        var other = new $PySet(iterable);
  +        if(this._set.intersection(other._set).length == 0)
  +            return true;
  +        else
  +            return false;
  +    }
  +
  +    issubset(var iterable) {
  +        var other = new $PySet(iterable);
  +        return other._set.containsAll(this._set);
  +    }
  +
  +    issuperset(var iterable){
  +        var other = new $PySet(iterable);
  +        return this._set.containsAll(other._set);
  +    }
  +
  +    union(var iterable) {
  +        var other = new $PySet(iterable);
  +        return new $PySet(this._set.union(other._set));
  +    }
  +
  +    intersection(var iterable) {
  +        var other = new $PySet(iterable);
  +        return new $PySet(this._set.intersection(other._set));
  +    }
  +
  +    difference(var iterable){
  +        var other = new $PySet(iterable);
  +        return new $PySet(this._set.difference(other._set));
  +    }
  +
  +    symmetric_difference(var iterable){
  +        var other = new $PySet(iterable);
  +        return new $PySet(this._set.union(other._set).difference(this._set.intersection(other._set)));
  +    }
  +
  +    update(var iterable){
  +        var other = new $PySet(iterable);
  +        this._set = this._set.union(other._set);
  +    }
  +
  +    intersection_update(var iterable){
  +        var other = new $PySet(iterable);
  +        this._set = this._set.intersection(other._set);
  +    }
  +
  +    difference_update(var iterable){
  +        var other = new $PySet(iterable);
  +        this._set = this._set.difference(other._set);
  +    }
  +
  +    symmetric_difference_update(var iterable){
  +        var other = new $PySet(iterable);
  +        this._set = this._set.union(other._set).difference(this._set.intersection(other._set));
       }
   
       remove(var element) => this._set.remove(element);
  
positive.code: 
      clear() => this._set.clear();
  
      operator -(var other) => this.difference(other);
  
  }
  
  
negative.code: 
          var rng = new Random();
          var key = _dict.keys[rng.nextInt(_dict.length)];
          var value = tuple([keys, _dict[key]]);
  
          _dict.remove(key);
          return value;
  