Boost.Hana  1.7.0
Your standard library for metaprogramming
Synopsis of associated functions | Friends | Public Member Functions | List of all members
boost::hana::set< implementation_defined > Struct Template Reference
Data types

Description

template<typename implementation_defined>
struct boost::hana::set< implementation_defined >

Basic unordered container requiring unique, Comparable and Hashable keys.

A set is an unordered container that can hold heterogeneous keys. A set requires (and ensures) that no duplicates are present when inserting new keys.

Note
The actual representation of a hana::set is implementation-defined. In particular, one should not take for granted the order of the template parameters and the presence of any additional constructors or assignment operators than what is documented. The canonical way of creating a hana::set is through hana::make_set. More details in the tutorial.

Modeled concepts

  1. Comparable
    Two sets are equal iff they contain the same elements, regardless of the order.
    // Copyright Louis Dionne 2013-2017
    // Distributed under the Boost Software License, Version 1.0.
    // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
    #include <boost/hana/assert.hpp>
    #include <boost/hana/equal.hpp>
    #include <boost/hana/integral_constant.hpp>
    #include <boost/hana/not_equal.hpp>
    #include <boost/hana/set.hpp>
    #include <boost/hana/type.hpp>
    namespace hana = boost::hana;
    int main() {
    BOOST_HANA_CONSTANT_CHECK(
    hana::make_set(hana::int_c<0>, hana::type_c<char>, hana::int_c<1>)
    ==
    hana::make_set(hana::int_c<1>, hana::int_c<0>, hana::type_c<char>)
    );
    BOOST_HANA_CONSTANT_CHECK(
    hana::make_set(hana::int_c<0>, hana::type_c<char>)
    !=
    hana::make_set(hana::int_c<1>)
    );
    }
  2. Foldable
    Folding a set is equivalent to folding the sequence of its values. However, note that the values are not required to be in any specific order, so using the folds provided here with an operation that is not both commutative and associative will yield non-deterministic behavior.
    // Copyright Louis Dionne 2013-2017
    // Distributed under the Boost Software License, Version 1.0.
    // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
    #include <boost/hana/assert.hpp>
    #include <boost/hana/equal.hpp>
    #include <boost/hana/integral_constant.hpp>
    #include <boost/hana/maximum.hpp>
    #include <boost/hana/minimum.hpp>
    #include <boost/hana/set.hpp>
    #include <boost/hana/sum.hpp>
    namespace hana = boost::hana;
    int main() {
    constexpr auto xs = hana::make_set(hana::int_c<0>, hana::int_c<1>, hana::int_c<2>);
    static_assert(hana::minimum(xs) == hana::int_c<0>, "");
    static_assert(hana::maximum(xs) == hana::int_c<2>, "");
    static_assert(hana::sum<>(xs) == hana::int_c<3>, "");
    }
  3. Searchable
    The elements in a set act as both its keys and its values. Since the elements of a set are unique, searching for an element will return either the only element which is equal to the searched value, or nothing. Also note that operator[] can be used instead of the at_key function.
    // Copyright Louis Dionne 2013-2017
    // Distributed under the Boost Software License, Version 1.0.
    // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
    #include <boost/hana/assert.hpp>
    #include <boost/hana/at_key.hpp>
    #include <boost/hana/equal.hpp>
    #include <boost/hana/find.hpp>
    #include <boost/hana/integral_constant.hpp>
    #include <boost/hana/optional.hpp>
    #include <boost/hana/set.hpp>
    namespace hana = boost::hana;
    int main() {
    constexpr auto xs = hana::make_set(hana::int_c<0>, hana::int_c<1>, hana::int_c<2>);
    BOOST_HANA_CONSTANT_CHECK(hana::find(xs, hana::int_c<0>) == hana::just(hana::int_c<0>));
    BOOST_HANA_CONSTANT_CHECK(hana::find(xs, hana::int_c<3>) == hana::nothing);
    // operator[] is equivalent to at_key
    BOOST_HANA_CONSTANT_CHECK(xs[hana::int_c<2>] == hana::int_c<2>);
    // long_c<0> == int_<0>, and therefore int_<0> is found
    BOOST_HANA_CONSTANT_CHECK(xs[hana::long_c<0>] == hana::int_c<0>);
    }

Conversion from any <tt>Foldable</tt>

Any Foldable structure can be converted into a hana::set with to<set_tag>. The elements of the structure must all be compile-time Comparable. If the structure contains duplicate elements, only the first occurence will appear in the resulting set. More specifically, conversion from a Foldable is equivalent to

to<set_tag>(xs) == fold_left(xs, make_set(), insert)

Example

// Copyright Louis Dionne 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/core/to.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
int main() {
constexpr auto xs = hana::make_tuple(
hana::int_c<1>,
hana::int_c<3>,
hana::type_c<int>,
hana::long_c<1>
);
BOOST_HANA_CONSTANT_CHECK(
hana::to<hana::set_tag>(xs)
==
hana::make_set(hana::int_c<1>, hana::int_c<3>, hana::type_c<int>)
);
}

Synopsis of associated functions

template<>
constexpr auto make< set_tag >
 Function object for creating a hana::set. More...
 
constexpr auto make_set = make<set_tag>
 Equivalent to make<set_tag>; provided for convenience. More...
 
constexpr auto insert
 Insert an element in a hana::set. More...
 
constexpr auto erase_key
 Remove an element from a hana::set. More...
 
constexpr auto union_
 Returns the union of two sets. More...
 
constexpr auto intersection
 Returns the intersection of two sets. More...
 
constexpr auto to_set = to<set_tag>
 Equivalent to to<set_tag>; provided for convenience.
 
constexpr auto difference
 Returns the set-theoretic difference of two sets. More...
 
constexpr auto symmetric_difference
 Returns the symmetric set-theoretic difference of two sets. More...
 

Friends

template<typename X , typename Y >
constexpr friend auto operator== (X &&x, Y &&y)
 Equivalent to hana::equal
 
template<typename X , typename Y >
constexpr friend auto operator!= (X &&x, Y &&y)
 Equivalent to hana::not_equal
 

Public Member Functions

constexpr set ()=default
 Default-construct a set. This constructor only exists when all the elements of the set are default-constructible.
 
constexpr set (set const &other)=default
 Copy-construct a set from another set. This constructor only exists when all the elements of the set are copy-constructible.
 
constexpr set (set &&other)=default
 Move-construct a set from another set. This constructor only exists when all the elements of the set are move-constructible.
 
template<typename Key >
constexpr decltype(auto) operator[] (Key &&key)
 Equivalent to hana::at_key
 

Associated functions

◆ make< set_tag >

template<typename implementation_defined >
template<>
constexpr auto make< set_tag >
related
Initial value:
= [](auto&& ...xs) {
return set<implementation_defined>{forwarded(xs)...};
}

Function object for creating a hana::set.

Given zero or more values xs..., make<set_tag> returns a set containing those values. The values must all be compile-time Comparable, and no duplicate values may be provided. To create a set from a sequence with possible duplicates, use to<set_tag> instead.

Example

// Copyright Louis Dionne 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/core/make.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
constexpr auto xs = hana::make_set(hana::int_c<1>, hana::type_c<void>);
BOOST_HANA_CONSTANT_CHECK(xs == hana::make<hana::set_tag>(hana::int_c<1>, hana::type_c<void>));
int main() { }

◆ make_set

template<typename implementation_defined >
constexpr auto make_set = make<set_tag>
related

Equivalent to make<set_tag>; provided for convenience.

Example

// Copyright Louis Dionne 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/core/make.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
constexpr auto xs = hana::make_set(hana::int_c<1>, hana::type_c<void>);
BOOST_HANA_CONSTANT_CHECK(xs == hana::make<hana::set_tag>(hana::int_c<1>, hana::type_c<void>));
int main() { }

◆ insert

template<typename implementation_defined >
constexpr auto insert
related
Initial value:
= [](auto&& set, auto&& element) {
return tag-dispatched;
}

Insert an element in a hana::set.

If the set already contains an element that compares equal, then nothing is done and the set is returned as is.

Parameters
setThe set in which to insert a value.
elementThe value to insert. It must be compile-time Comparable.

Example

// Copyright Louis Dionne 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/insert.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/string.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
int main() {
constexpr auto xs = hana::make_set(hana::int_c<0>, hana::type_c<int>);
BOOST_HANA_CONSTANT_CHECK(
hana::insert(xs, BOOST_HANA_STRING("abc")) ==
hana::make_set(hana::int_c<0>, hana::type_c<int>, BOOST_HANA_STRING("abc"))
);
BOOST_HANA_CONSTANT_CHECK(
hana::insert(xs, hana::int_c<0>) == hana::make_set(hana::int_c<0>, hana::type_c<int>)
);
}

◆ erase_key

template<typename implementation_defined >
constexpr auto erase_key
related
Initial value:
= [](auto&& set, auto&& element) {
return tag-dispatched;
}

Remove an element from a hana::set.

Returns a new set containing all the elements of the original, except the one comparing equal to the given element. If the set does not contain such an element, a new set equal to the original set is returned.

Parameters
setThe set in which to remove a value.
elementThe value to remove. It must be compile-time Comparable.

Example

// Copyright Louis Dionne 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/erase_key.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
int main() {
constexpr auto xs = hana::make_set(hana::int_c<0>, hana::type_c<int>, hana::type_c<void>);
BOOST_HANA_CONSTANT_CHECK(hana::erase_key(xs, hana::type_c<int>) == hana::make_set(hana::int_c<0>, hana::type_c<void>));
BOOST_HANA_CONSTANT_CHECK(hana::erase_key(xs, hana::type_c<char>) == xs);
}

◆ union_

template<typename implementation_defined >
constexpr auto union_
related
Initial value:
= [](auto&& xs, auto&& ys) {
return tag-dispatched;
}

Returns the union of two sets.

Given two sets xs and ys, union_(xs, ys) is a new set containing all the elements of xs and all the elements of ys, without duplicates. For any object x, the following holds: x is in hana::union_(xs, ys) if and only if x is in xs or x is in ys.

Parameters
xs,ysTwo sets to compute the union of.

Example

// Copyright Louis Dionne 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/string.hpp>
#include <boost/hana/type.hpp>
#include <boost/hana/union.hpp>
namespace hana = boost::hana;
using namespace hana::literals;
constexpr auto xs = hana::make_set(hana::int_c<1>, hana::type_c<void>, hana::int_c<2>);
constexpr auto ys = hana::make_set(hana::int_c<2>, hana::type_c<int>, hana::int_c<3>);
BOOST_HANA_CONSTANT_CHECK(hana::union_(xs, ys) == hana::make_set(
hana::int_c<1>, hana::int_c<2>, hana::int_c<3>, hana::type_c<void>, hana::type_c<int>
));
int main() { }

◆ intersection

template<typename implementation_defined >
constexpr auto intersection
related
Initial value:
= [](auto&& xs, auto&& ys) {
return tag-dispatched;
}

Returns the intersection of two sets.

Given two sets xs and ys, intersection(xs, ys) is a new set containing exactly those elements that are present both in xs and in ys. In other words, the following holds for any object x:

x ^in^ intersection(xs, ys) if and only if x ^in^ xs && x ^in^ ys
Parameters
xs,ysTwo sets to intersect.

Example

// Copyright Louis Dionne 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/intersection.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
constexpr auto xs = hana::make_set(hana::int_c<1>, hana::type_c<void>, hana::int_c<2>);
constexpr auto ys = hana::make_set(hana::int_c<2>, hana::type_c<int>, hana::int_c<3>);
BOOST_HANA_CONSTANT_CHECK(hana::intersection(xs, ys) == hana::make_set(hana::int_c<2>));
int main() { }

◆ difference

template<typename implementation_defined >
constexpr auto difference
related
Initial value:
= [](auto&& xs, auto&& ys) {
return tag-dispatched;
}

Returns the set-theoretic difference of two sets.

Given two sets xs and ys, difference(xs, ys) is a new set containing all the elements of xs that are not contained in ys. For any object x, the following holds:

x ^in^ difference(xs, ys) if and only if x ^in^ xs && !(x ^in^ ys)

This operation is not commutative, i.e. difference(xs, ys) is not necessarily the same as difference(ys, xs). Indeed, consider the case where xs is empty and ys isn't. Then, difference(xs, ys) is empty but difference(ys, xs) is equal to ys. For the symmetric version of this operation, see symmetric_difference.

Parameters
xsA set param to remove values from.
ysThe set whose values are removed from xs.

Example

// Copyright Louis Dionne 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/difference.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
constexpr auto xs = hana::make_set(hana::int_c<1>, hana::int_c<2>, hana::type_c<int>, hana::int_c<3>);
constexpr auto ys = hana::make_set(hana::int_c<3>, hana::type_c<void>, hana::type_c<int>);
BOOST_HANA_CONSTANT_CHECK(hana::difference(xs, ys) == hana::make_set(hana::int_c<1>, hana::int_c<2>));
BOOST_HANA_CONSTANT_CHECK(hana::difference(ys, xs) == hana::make_set(hana::type_c<void>));
int main() { }

◆ symmetric_difference

template<typename implementation_defined >
constexpr auto symmetric_difference
related
Initial value:
= [](auto&& xs, auto&& ys) {
return tag-dispatched;
}

Returns the symmetric set-theoretic difference of two sets.

Given two sets xs and ys, symmetric_difference(xs, ys) is a new set containing all the elements of xs that are not contained in ys, and all the elements of ys that are not contained in xs. The symmetric difference of two sets satisfies the following:

symmetric_difference(xs, ys) == union_(difference(xs, ys), difference(ys, xs))
Parameters
xs,ysTwo sets to compute the symmetric difference of.

Example

// Copyright Louis Dionne 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/symmetric_difference.hpp>
namespace hana = boost::hana;
constexpr auto xs = hana::make_set(hana::int_c<1>, hana::int_c<2>, hana::type_c<int>, hana::int_c<3>);
constexpr auto ys = hana::make_set(hana::int_c<3>, hana::type_c<void>, hana::type_c<int>);
BOOST_HANA_CONSTANT_CHECK(
hana::symmetric_difference(xs, ys) == hana::make_set(hana::int_c<1>, hana::int_c<2>, hana::type_c<void>)
);
int main() { }
equal.hpp
Defines boost::hana::equal.
BOOST_HANA_CONSTANT_CHECK
#define BOOST_HANA_CONSTANT_CHECK(...)
Equivalent to BOOST_HANA_CONSTANT_ASSERT, but not influenced by the BOOST_HANA_CONFIG_DISABLE_ASSERTI...
Definition: assert.hpp:239
boost::hana::set::set
constexpr set()=default
Default-construct a set. This constructor only exists when all the elements of the set are default-co...
tuple.hpp
Defines boost::hana::tuple.
set.hpp
Defines boost::hana::set.
integral_constant.hpp
Defines boost::hana::integral_constant.
boost::hana::set::difference
constexpr auto difference
Returns the set-theoretic difference of two sets.
Definition: set.hpp:265
make.hpp
Defines boost::hana::make.
boost::hana::find
constexpr auto find
Finds the value associated to the given key in a structure.
Definition: find.hpp:44
find.hpp
Defines boost::hana::find.
boost::hana::insert
constexpr insert_t insert
Insert a value at a given index in a sequence.
Definition: insert.hpp:29
boost::hana::set::insert
constexpr auto insert
Insert an element in a hana::set.
Definition: set.hpp:156
boost::hana::set::symmetric_difference
constexpr auto symmetric_difference
Returns the symmetric set-theoretic difference of two sets.
Definition: set.hpp:290
boost::hana::set::union_
constexpr auto union_
Returns the union of two sets.
Definition: set.hpp:203
string.hpp
Defines boost::hana::string.
erase_key.hpp
Defines boost::hana::erase_key.
intersection.hpp
Defines boost::hana::intersection.
type.hpp
Defines boost::hana::type and related utilities.
maximum.hpp
Defines boost::hana::maximum.
boost::hana
Namespace containing everything in the library.
Definition: accessors.hpp:20
boost::hana::in
constexpr auto in
Return whether the key occurs in the structure.
Definition: contains.hpp:70
assert.hpp
Defines macros to perform different kinds of assertions.
to.hpp
Defines boost::hana::to and related utilities.
boost::hana::set::intersection
constexpr auto intersection
Returns the intersection of two sets.
Definition: set.hpp:228
not_equal.hpp
Defines boost::hana::not_equal.
difference.hpp
Defines boost::hana::difference.
sum.hpp
Defines boost::hana::sum.
symmetric_difference.hpp
Defines boost::hana::symmetric_difference.
at_key.hpp
Defines boost::hana::at_key.
minimum.hpp
Defines boost::hana::minimum.
insert.hpp
Defines boost::hana::insert.
boost::hana::set::make_set
constexpr auto make_set
Equivalent to make<set_tag>; provided for convenience.
Definition: set.hpp:136
union.hpp
Defines boost::hana::union.
optional.hpp
Defines boost::hana::optional.