anchor.diff:  
       clear() => this._set.clear();
   
  -    operator -(var other) => this.difference(other);
  +    operator -(var other) {
  +        if(other is $PySet)
  +            return new $PySet(this._set.difference(other._set));
  +        else
  +            throw "Invalid Arguments";
  +    }
  +
  +    operator ==(var other){
  +        if(other is $PySet){
  +            if(other._set.length == this._set.length){
  +                return this._set.difference(other._set).length == 0;
  +            }
  +            return false;
  +        }
  +        else
  +            throw "Invalid Arguments";
  +    }
  +
  +    operator <=(var other){
  +        if(other is $PySet)
  +            return other._set.containsAll(this._set);
  +        else
  +            throw "Invalid Arguments";
  +    }
  +
  +    operator <(var other){
  +        if(other is $PySet)
  +            return (this <= other && this != other);
  +        else
  +            throw "Invalid Arguments";
  +    }
  +
  +    operator >=(var other){
  +        if(other is $PySet)
  +            return this._set.containsAll(other._set);
  +        else
  +            throw "Invalid Arguments";
  +    }
  +
  +    operator >(var other){
  +        if(other is $PySet)
  +            return (other <= this && other != this);
  +        else
  +            throw "Invalid Arguments";
  +    }
  +
  +    operator |(var other){
  +        if(other is $PySet)
  +            return new $PySet(this._set.union(other._set));
  +        else
  +            throw "Invalid Arguments";
  +    }
  +
  +    operator &(var other){
  +        if(other is $PySet)
  +            return new $PySet(this._set.intersection(other._set));
  +        else
  +            throw "Invalid Arguments";
  +    }
  +
  +    operator ^(var other){
  +        if(other is $PySet)
  +            return new $PySet(this._set.union(other._set).difference(this._set.intersection(other._set)));
  +        else
  +            throw "Invlaid Arguments";
  +    }
   
   }
   
  
positive.code:             this._set = new Set();
      }
  
      get iterator {
          return 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";
      }
  
      remove(var element) => this._set.remove(element);
  
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;
  