elbeno

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}

module Main where

-- Here's the familiar Writer monad. For the purposes here, we're not worried
-- about the instances for functor, monad etc.
newtype Writer a x = Writer { runWriter :: (x, a) }

elbeno

#include <memory>
#include <type_traits>

// Foo is a class that has a private constructor, and it's created by a factory
// function that returns a smart pointer.

class Foo
{
public:
  static std::unique_ptr<Foo> Create();

elbeno

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

template <typename F>
struct Y
{
  Y(F f) : m_f(f) {}

  template <typename T>

elbeno

#include <utility>

// The 2x2 fibonacci matrix
//
// { F(n+1) F(n)   }
// { F(n)   F(n-1) }
//
// can be represented as just the bottom row, since the top row can be computed:
// so just use a pair.
template <typename N>

elbeno

#include <algorithm>
#include <cassert>
#include <tuple>
#include <utility>

namespace detail
{
  template <size_t N>
  struct visit_impl
  {

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

elbeno

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

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

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