Creating implementation for idiom 34 : Create a set of objects

Idiom

# 34 Create a set of objects

Created by

Lead paragraph

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

New implementation

Language

Imports

Code

Documentation URL

Original attribution URL

Online runnable demo

Username

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations

#include <unordered_set>

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

#include <unordered_set>

std::unordered_set<T> 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]bool)

Demo

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

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);

class T(object):
    pass

x = set(T())

class T:
   ...

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

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))
# Or sub-class
class ObjectSet[T](set):
    def update(self, *s):
        for value in s:
            self.add(value)
    def add(self, *args: T):
        super().add(Object(*args))
x = ObjectSet[int]()
x.update(1, 2, 3)

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)

require 'set'

x = Set.new

Demo
Doc

use std::collections::HashSet;

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

Demo
Doc

val x = Set[T]()

Preview