Idiom #34 Create a set of objects

Declare and initialize a set x containing unique objects of type T.

Python

class Object[T]:
    def __init__(self, *args: T):
        self.value = args
    def __hash__(self):
        return hash(self.value)
    def __eq__(self, other):
        return self.value == other.value
class ObjectSet[T](set[Object[T]]):
    def update(self, *array: T):
        for value in array:
            self.add(value)
    def add(self, value: T):
        super().add(Object(value))
x = ObjectSet[int]()
x.update(1, 2, 3)

Python

class Object[T]:
    def __init__(self, *args: T):
        self.value = args
    def __hash__(self):
        return hash(self.value)
    def __eq__(self, other):
        return self.value == other.value
x = set[Object[int]]()
x.add(Object(1))
x.add(Object(2))
x.add(Object(3))

Python

type Object[T] = T
type ObjectSet[T] = set[Object[T]]
type IntSet = ObjectSet[int]
x: IntSet = set()
x.add(1)
x.add(2)
x.add(3)

Python

class T(object):
    pass

x = set(T())

Python

class T:
   ...

s = set(T() for _ in range(x))

#include <unordered_set>

std::unordered_set<T> x;

#include <unordered_set>

std::unordered_set<T, hasher, eq> x;

using System.Collections.Generic;

HashSet<T> x = new HashSet<T>();

Demo
Doc

import std.container: redBlackTree;

auto x = redBlackTree!T;

var x = new Set<T>();

Demo

x := make(map[T]struct{})

Demo

x := make(map[T]bool)

Demo

import Data.Set

x = empty :: Set T

let x = new Set();

Demo
Doc

import java.util.Set;
import java.util.HashSet;

Set<T> x = new HashSet<T>();
x.add(a);
x.add(b);

import java.util.Set;
import java.util.HashSet;

Set<T> x = new HashSet<T>();

import static java.util.Set.of;
import java.util.Set;

Set<T> x = of(a, b, c);

use Moops;
use Set::Object qw();

class T {}
class Set::Object::T extends Set::Object {
    method BUILDARGS(T @items) { return {data => \@items}; }
    method insert(T @items) { $self->next::method(@items); }
}
my $x = Set::Object::T->new(T->new, T->new, T->new);