elbeno

#include <cstdint>
#include <iostream>
#include <iterator>
#include <type_traits>

using namespace std;

// -----------------------------------------------------------------------------
// Traits for treating enums like flags, and/or giving the ability to loop over
// them

elbeno

#include <cstddef>
#include <iostream>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>

using namespace std;

template <typename T>

elbeno

#include <iostream>
#include <string>
#include <type_traits>

using namespace std;

struct Foo
{
  Foo() {}
  Foo(const Foo&)

elbeno

#include <cstddef>
#include <iostream>
#include <string>
#include <utility>

using namespace std;

template <bool div3, bool div5>
struct printer
{

elbeno

#include <iostream>
#include <iterator>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;

//------------------------------------------------------------------------------
// The "many-worlds" method of solving problems with the list monad

elbeno

#include <iostream>
using namespace std;

constexpr unsigned long long fnv_hash64_r(unsigned long long result, const char* string)
{
  return (*string == 0) ? result : fnv_hash64_r(1099511628211ULL * result ^ *string, string + 1);
}

constexpr unsigned long long fnv_hash64(const char* string)
{

elbeno

#include <iostream>
#include <tuple>
using namespace std;

// When tuples get large, compile times suffer because the compiler is hashing
// the name of a really long type. Lambdas offer a way to truncate that type
// name, leading to faster compile times and the ability to instantiate larger
// tuples (the template depth quickly exceeds the max).

// Compare compile times:

elbeno

#include <iostream>
#include <type_traits>
#include <utility>

template<class F>
struct wrapper
{
  static_assert(std::is_empty<F>(), "Lambdas must be empty");
  template<class... Ts>
  decltype(auto) operator()(Ts&&... xs) const

elbeno

#include <algorithm>
#include <cassert>
#include <utility>
#include <iostream>
using namespace std;

class Light
{
public:
  void turn_on() { m_on = true; };

elbeno

//------------------------------------------------------------------------------
// A function that will apply a function to each argument
#include <initializer_list>
#include <utility>

template <typename F, typename... Ts>
void for_each_arg(F&& f, Ts&&... ts)
{
  using I = std::initializer_list<int>;
  (void) I { (std::forward<F>(f)(std::forward<Ts>(ts)), 0)... };