| Boost.Hana 1.7.1 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>)
   );
   }
   assert.hpp
   Defines macros to perform different kinds of assertions.
   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
   integral_constant.hpp
   Defines boost::hana::integral_constant.
   boost::hana
   Namespace containing everything in the library.
   Definition: accessors.hpp:20
   not_equal.hpp
   Defines boost::hana::not_equal.
   set.hpp
   Defines boost::hana::set.
   type.hpp
   Defines boost::hana::type and related utilities.
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>, "");
   }
   maximum.hpp
   Defines boost::hana::maximum.
   minimum.hpp
   Defines boost::hana::minimum.
   sum.hpp
   Defines boost::hana::sum.
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>);
   }
   at_key.hpp
   Defines boost::hana::at_key.
   find.hpp
   Defines boost::hana::find.
   boost::hana::find
   constexpr auto find
   Finds the value associated to the given key in a structure.
   Definition: find.hpp:44
   optional.hpp
   Defines boost::hana::optional.

## 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)
boost::hana::set::insert
constexpr auto insert
Insert an element in a hana::set.
Definition: set.hpp:156
boost::hana::set::make_set
constexpr auto make_set
Equivalent to make<set_tag>; provided for convenience.
Definition: set.hpp:136

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>)
);
}
to.hpp
Defines boost::hana::to and related utilities.
tuple.hpp
Defines boost::hana::tuple.

## 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.hpp
Defines boost::hana::make.

## ◆ 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;
}
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...

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

  set | The set in which to insert a value.
  element | The 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>)
);
}
boost::hana::insert
constexpr insert_t insert
Insert a value at a given index in a sequence.
Definition: insert.hpp:29
insert.hpp
Defines boost::hana::insert.
string.hpp
Defines boost::hana::string.

## ◆ 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

  set | The set in which to remove a value.
  element | The 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);
}
erase_key.hpp
Defines boost::hana::erase_key.

## ◆ 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,ys | Two 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() { }
union.hpp
Defines boost::hana::union.

## ◆ 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
boost::hana::in
constexpr auto in
Return whether the key occurs in the structure.
Definition: contains.hpp:70
boost::hana::set::intersection
constexpr auto intersection
Returns the intersection of two sets.
Definition: set.hpp:228

Parameters

  xs,ys | Two 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() { }
intersection.hpp
Defines boost::hana::intersection.

## ◆ 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)
boost::hana::set::difference
constexpr auto difference
Returns the set-theoretic difference of two sets.
Definition: set.hpp:265

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

  xs | A set param to remove values from.
  ys | The 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() { }
difference.hpp
Defines boost::hana::difference.

## ◆ 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))
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

Parameters

  xs,ys | Two 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() { }
symmetric_difference.hpp
Defines boost::hana::symmetric_difference.